RequestParameters.Generated.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Linq.Expressions;

//This file contains all the typed querystring 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 Elasticsearch.Net
{
	
	
	///<summary>Request parameters descriptor for AbortBenchmark
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-benchmark.html
	///</pre>
	///</summary>
	public class AbortBenchmarkRequestParameters : FluentRequestParameters<AbortBenchmarkRequestParameters> 
	{
	}
	
	
	///<summary>Request parameters descriptor for Bulk
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-bulk.html
	///</pre>
	///</summary>
	public class BulkRequestParameters : FluentRequestParameters<BulkRequestParameters> 
	{
		
		internal Consistency _consistency { get; set; }
		///<summary>Explicit write consistency setting for the operation</summary>
		public BulkRequestParameters Consistency(Consistency consistency)
		{
			this._consistency = consistency;
			this.AddQueryString("consistency", this._consistency);
			return this;
		}
		
		
		internal bool _refresh { get; set; }
		///<summary>Refresh the index after performing the operation</summary>
		public BulkRequestParameters Refresh(bool refresh)
		{
			this._refresh = refresh;
			this.AddQueryString("refresh", this._refresh);
			return this;
		}
		
		
		internal Replication _replication { get; set; }
		///<summary>Explicitely set the replication type</summary>
		public BulkRequestParameters Replication(Replication replication)
		{
			this._replication = replication;
			this.AddQueryString("replication", this._replication);
			return this;
		}
		
		
		internal string _routing { get; set; }
		///<summary>Specific routing value</summary>
		public BulkRequestParameters Routing(string routing)
		{
			this._routing = routing;
			this.AddQueryString("routing", this._routing);
			return this;
		}
		
		
		internal string _timeout { get; set; }
		///<summary>Explicit operation timeout</summary>
		public BulkRequestParameters Timeout(string timeout)
		{
			this._timeout = timeout;
			this.AddQueryString("timeout", this._timeout);
			return this;
		}
		
		
		internal string _type { get; set; }
		///<summary>Default document type for items which don&#39;t provide one</summary>
		public BulkRequestParameters Type(string type)
		{
			this._type = type;
			this.AddQueryString("type", this._type);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for CatAliases
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-aliases.html
	///</pre>
	///</summary>
	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 CatAliasesRequestParameters Local(bool local)
		{
			this._local = local;
			this.AddQueryString("local", this._local);
			return this;
		}
		
		
		internal string _master_timeout { get; set; }
		///<summary>Explicit operation timeout for connection to master node</summary>
		public CatAliasesRequestParameters MasterTimeout(string master_timeout)
		{
			this._master_timeout = master_timeout;
			this.AddQueryString("master_timeout", this._master_timeout);
			return this;
		}
		
		
		internal  string[] _h { get; set; }
		///<summary>Comma-separated list of column names to display</summary>
		public CatAliasesRequestParameters H(params string[] h)
		{
			this._h = h;
			this.AddQueryString("h", this._h);
			return this;
		}
		
		
		internal bool _help { get; set; }
		///<summary>Return help information</summary>
		public CatAliasesRequestParameters Help(bool help)
		{
			this._help = help;
			this.AddQueryString("help", this._help);
			return this;
		}
		
		
		internal bool _v { get; set; }
		///<summary>Verbose mode. Display column headers</summary>
		public CatAliasesRequestParameters V(bool v)
		{
			this._v = v;
			this.AddQueryString("v", this._v);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for CatAllocation
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-allocation.html
	///</pre>
	///</summary>
	public class CatAllocationRequestParameters : FluentRequestParameters<CatAllocationRequestParameters> 
	{
		
		internal Bytes _bytes { get; set; }
		///<summary>The unit in which to display byte values</summary>
		public CatAllocationRequestParameters Bytes(Bytes bytes)
		{
			this._bytes = bytes;
			this.AddQueryString("bytes", this._bytes);
			return this;
		}
		
		
		internal bool _local { get; set; }
		///<summary>Return local information, do not retrieve the state from master node (default: false)</summary>
		public CatAllocationRequestParameters Local(bool local)
		{
			this._local = local;
			this.AddQueryString("local", this._local);
			return this;
		}
		
		
		internal string _master_timeout { get; set; }
		///<summary>Explicit operation timeout for connection to master node</summary>
		public CatAllocationRequestParameters MasterTimeout(string master_timeout)
		{
			this._master_timeout = master_timeout;
			this.AddQueryString("master_timeout", this._master_timeout);
			return this;
		}
		
		
		internal  string[] _h { get; set; }
		///<summary>Comma-separated list of column names to display</summary>
		public CatAllocationRequestParameters H(params string[] h)
		{
			this._h = h;
			this.AddQueryString("h", this._h);
			return this;
		}
		
		
		internal bool _help { get; set; }
		///<summary>Return help information</summary>
		public CatAllocationRequestParameters Help(bool help)
		{
			this._help = help;
			this.AddQueryString("help", this._help);
			return this;
		}
		
		
		internal bool _v { get; set; }
		///<summary>Verbose mode. Display column headers</summary>
		public CatAllocationRequestParameters V(bool v)
		{
			this._v = v;
			this.AddQueryString("v", this._v);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for CatCount
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-count.html
	///</pre>
	///</summary>
	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 CatCountRequestParameters Local(bool local)
		{
			this._local = local;
			this.AddQueryString("local", this._local);
			return this;
		}
		
		
		internal string _master_timeout { get; set; }
		///<summary>Explicit operation timeout for connection to master node</summary>
		public CatCountRequestParameters MasterTimeout(string master_timeout)
		{
			this._master_timeout = master_timeout;
			this.AddQueryString("master_timeout", this._master_timeout);
			return this;
		}
		
		
		internal  string[] _h { get; set; }
		///<summary>Comma-separated list of column names to display</summary>
		public CatCountRequestParameters H(params string[] h)
		{
			this._h = h;
			this.AddQueryString("h", this._h);
			return this;
		}
		
		
		internal bool _help { get; set; }
		///<summary>Return help information</summary>
		public CatCountRequestParameters Help(bool help)
		{
			this._help = help;
			this.AddQueryString("help", this._help);
			return this;
		}
		
		
		internal bool _v { get; set; }
		///<summary>Verbose mode. Display column headers</summary>
		public CatCountRequestParameters V(bool v)
		{
			this._v = v;
			this.AddQueryString("v", this._v);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for CatFielddata
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/cat-fielddata.html
	///</pre>
	///</summary>
	public class CatFielddataRequestParameters : FluentRequestParameters<CatFielddataRequestParameters> 
	{
		
		internal Bytes _bytes { get; set; }
		///<summary>The unit in which to display byte values</summary>
		public CatFielddataRequestParameters Bytes(Bytes bytes)
		{
			this._bytes = bytes;
			this.AddQueryString("bytes", this._bytes);
			return this;
		}
		
		
		internal bool _local { get; set; }
		///<summary>Return local information, do not retrieve the state from master node (default: false)</summary>
		public CatFielddataRequestParameters Local(bool local)
		{
			this._local = local;
			this.AddQueryString("local", this._local);
			return this;
		}
		
		
		internal string _master_timeout { get; set; }
		///<summary>Explicit operation timeout for connection to master node</summary>
		public CatFielddataRequestParameters MasterTimeout(string master_timeout)
		{
			this._master_timeout = master_timeout;
			this.AddQueryString("master_timeout", this._master_timeout);
			return this;
		}
		
		
		internal  string[] _h { get; set; }
		///<summary>Comma-separated list of column names to display</summary>
		public CatFielddataRequestParameters H(params string[] h)
		{
			this._h = h;
			this.AddQueryString("h", this._h);
			return this;
		}
		
		
		internal bool _help { get; set; }
		///<summary>Return help information</summary>
		public CatFielddataRequestParameters Help(bool help)
		{
			this._help = help;
			this.AddQueryString("help", this._help);
			return this;
		}
		
		
		internal bool _v { get; set; }
		///<summary>Verbose mode. Display column headers</summary>
		public CatFielddataRequestParameters V(bool v)
		{
			this._v = v;
			this.AddQueryString("v", this._v);
			return this;
		}
		
		
		internal IEnumerable<object> _fields { get; set; }
		///<summary>A comma-separated list of fields to return the fielddata size</summary>
		public CatFielddataRequestParameters Fields(params string[] fields)
		{
			this._fields = fields.Select(f=>(object)f);
			this.AddQueryString("fields", this._fields);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for CatHealth
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-health.html
	///</pre>
	///</summary>
	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 CatHealthRequestParameters Local(bool local)
		{
			this._local = local;
			this.AddQueryString("local", this._local);
			return this;
		}
		
		
		internal string _master_timeout { get; set; }
		///<summary>Explicit operation timeout for connection to master node</summary>
		public CatHealthRequestParameters MasterTimeout(string master_timeout)
		{
			this._master_timeout = master_timeout;
			this.AddQueryString("master_timeout", this._master_timeout);
			return this;
		}
		
		
		internal  string[] _h { get; set; }
		///<summary>Comma-separated list of column names to display</summary>
		public CatHealthRequestParameters H(params string[] h)
		{
			this._h = h;
			this.AddQueryString("h", this._h);
			return this;
		}
		
		
		internal bool _help { get; set; }
		///<summary>Return help information</summary>
		public CatHealthRequestParameters Help(bool help)
		{
			this._help = help;
			this.AddQueryString("help", this._help);
			return this;
		}
		
		
		internal bool _ts { get; set; }
		///<summary>Set to false to disable timestamping</summary>
		public CatHealthRequestParameters Ts(bool ts)
		{
			this._ts = ts;
			this.AddQueryString("ts", this._ts);
			return this;
		}
		
		
		internal bool _v { get; set; }
		///<summary>Verbose mode. Display column headers</summary>
		public CatHealthRequestParameters V(bool v)
		{
			this._v = v;
			this.AddQueryString("v", this._v);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for CatHelp
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat.html
	///</pre>
	///</summary>
	public class CatHelpRequestParameters : FluentRequestParameters<CatHelpRequestParameters> 
	{
		
		internal bool _help { get; set; }
		///<summary>Return help information</summary>
		public CatHelpRequestParameters Help(bool help)
		{
			this._help = help;
			this.AddQueryString("help", this._help);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for CatIndices
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-indices.html
	///</pre>
	///</summary>
	public class CatIndicesRequestParameters : FluentRequestParameters<CatIndicesRequestParameters> 
	{
		
		internal Bytes _bytes { get; set; }
		///<summary>The unit in which to display byte values</summary>
		public CatIndicesRequestParameters Bytes(Bytes bytes)
		{
			this._bytes = bytes;
			this.AddQueryString("bytes", this._bytes);
			return this;
		}
		
		
		internal bool _local { get; set; }
		///<summary>Return local information, do not retrieve the state from master node (default: false)</summary>
		public CatIndicesRequestParameters Local(bool local)
		{
			this._local = local;
			this.AddQueryString("local", this._local);
			return this;
		}
		
		
		internal string _master_timeout { get; set; }
		///<summary>Explicit operation timeout for connection to master node</summary>
		public CatIndicesRequestParameters MasterTimeout(string master_timeout)
		{
			this._master_timeout = master_timeout;
			this.AddQueryString("master_timeout", this._master_timeout);
			return this;
		}
		
		
		internal  string[] _h { get; set; }
		///<summary>Comma-separated list of column names to display</summary>
		public CatIndicesRequestParameters H(params string[] h)
		{
			this._h = h;
			this.AddQueryString("h", this._h);
			return this;
		}
		
		
		internal bool _help { get; set; }
		///<summary>Return help information</summary>
		public CatIndicesRequestParameters Help(bool help)
		{
			this._help = help;
			this.AddQueryString("help", this._help);
			return this;
		}
		
		
		internal bool _pri { get; set; }
		///<summary>Set to true to return stats only for primary shards</summary>
		public CatIndicesRequestParameters Pri(bool pri)
		{
			this._pri = pri;
			this.AddQueryString("pri", this._pri);
			return this;
		}
		
		
		internal bool _v { get; set; }
		///<summary>Verbose mode. Display column headers</summary>
		public CatIndicesRequestParameters V(bool v)
		{
			this._v = v;
			this.AddQueryString("v", this._v);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for CatMaster
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-master.html
	///</pre>
	///</summary>
	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 CatMasterRequestParameters Local(bool local)
		{
			this._local = local;
			this.AddQueryString("local", this._local);
			return this;
		}
		
		
		internal string _master_timeout { get; set; }
		///<summary>Explicit operation timeout for connection to master node</summary>
		public CatMasterRequestParameters MasterTimeout(string master_timeout)
		{
			this._master_timeout = master_timeout;
			this.AddQueryString("master_timeout", this._master_timeout);
			return this;
		}
		
		
		internal  string[] _h { get; set; }
		///<summary>Comma-separated list of column names to display</summary>
		public CatMasterRequestParameters H(params string[] h)
		{
			this._h = h;
			this.AddQueryString("h", this._h);
			return this;
		}
		
		
		internal bool _help { get; set; }
		///<summary>Return help information</summary>
		public CatMasterRequestParameters Help(bool help)
		{
			this._help = help;
			this.AddQueryString("help", this._help);
			return this;
		}
		
		
		internal bool _v { get; set; }
		///<summary>Verbose mode. Display column headers</summary>
		public CatMasterRequestParameters V(bool v)
		{
			this._v = v;
			this.AddQueryString("v", this._v);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for CatNodes
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-nodes.html
	///</pre>
	///</summary>
	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 CatNodesRequestParameters Local(bool local)
		{
			this._local = local;
			this.AddQueryString("local", this._local);
			return this;
		}
		
		
		internal string _master_timeout { get; set; }
		///<summary>Explicit operation timeout for connection to master node</summary>
		public CatNodesRequestParameters MasterTimeout(string master_timeout)
		{
			this._master_timeout = master_timeout;
			this.AddQueryString("master_timeout", this._master_timeout);
			return this;
		}
		
		
		internal  string[] _h { get; set; }
		///<summary>Comma-separated list of column names to display</summary>
		public CatNodesRequestParameters H(params string[] h)
		{
			this._h = h;
			this.AddQueryString("h", this._h);
			return this;
		}
		
		
		internal bool _help { get; set; }
		///<summary>Return help information</summary>
		public CatNodesRequestParameters Help(bool help)
		{
			this._help = help;
			this.AddQueryString("help", this._help);
			return this;
		}
		
		
		internal bool _v { get; set; }
		///<summary>Verbose mode. Display column headers</summary>
		public CatNodesRequestParameters V(bool v)
		{
			this._v = v;
			this.AddQueryString("v", this._v);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for CatPendingTasks
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-pending-tasks.html
	///</pre>
	///</summary>
	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 CatPendingTasksRequestParameters Local(bool local)
		{
			this._local = local;
			this.AddQueryString("local", this._local);
			return this;
		}
		
		
		internal string _master_timeout { get; set; }
		///<summary>Explicit operation timeout for connection to master node</summary>
		public CatPendingTasksRequestParameters MasterTimeout(string master_timeout)
		{
			this._master_timeout = master_timeout;
			this.AddQueryString("master_timeout", this._master_timeout);
			return this;
		}
		
		
		internal  string[] _h { get; set; }
		///<summary>Comma-separated list of column names to display</summary>
		public CatPendingTasksRequestParameters H(params string[] h)
		{
			this._h = h;
			this.AddQueryString("h", this._h);
			return this;
		}
		
		
		internal bool _help { get; set; }
		///<summary>Return help information</summary>
		public CatPendingTasksRequestParameters Help(bool help)
		{
			this._help = help;
			this.AddQueryString("help", this._help);
			return this;
		}
		
		
		internal bool _v { get; set; }
		///<summary>Verbose mode. Display column headers</summary>
		public CatPendingTasksRequestParameters V(bool v)
		{
			this._v = v;
			this.AddQueryString("v", this._v);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for CatPlugins
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/cat-plugins.html
	///</pre>
	///</summary>
	public class CatPluginsRequestParameters : FluentRequestParameters<CatPluginsRequestParameters> 
	{
		
		internal bool _local { get; set; }
		///<summary>Return local information, do not retrieve the state from master node (default: false)</summary>
		public CatPluginsRequestParameters Local(bool local)
		{
			this._local = local;
			this.AddQueryString("local", this._local);
			return this;
		}
		
		
		internal string _master_timeout { get; set; }
		///<summary>Explicit operation timeout for connection to master node</summary>
		public CatPluginsRequestParameters MasterTimeout(string master_timeout)
		{
			this._master_timeout = master_timeout;
			this.AddQueryString("master_timeout", this._master_timeout);
			return this;
		}
		
		
		internal  string[] _h { get; set; }
		///<summary>Comma-separated list of column names to display</summary>
		public CatPluginsRequestParameters H(params string[] h)
		{
			this._h = h;
			this.AddQueryString("h", this._h);
			return this;
		}
		
		
		internal bool _help { get; set; }
		///<summary>Return help information</summary>
		public CatPluginsRequestParameters Help(bool help)
		{
			this._help = help;
			this.AddQueryString("help", this._help);
			return this;
		}
		
		
		internal bool _v { get; set; }
		///<summary>Verbose mode. Display column headers</summary>
		public CatPluginsRequestParameters V(bool v)
		{
			this._v = v;
			this.AddQueryString("v", this._v);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for CatRecovery
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-recovery.html
	///</pre>
	///</summary>
	public class CatRecoveryRequestParameters : FluentRequestParameters<CatRecoveryRequestParameters> 
	{
		
		internal Bytes _bytes { get; set; }
		///<summary>The unit in which to display byte values</summary>
		public CatRecoveryRequestParameters Bytes(Bytes bytes)
		{
			this._bytes = bytes;
			this.AddQueryString("bytes", this._bytes);
			return this;
		}
		
		
		internal string _master_timeout { get; set; }
		///<summary>Explicit operation timeout for connection to master node</summary>
		public CatRecoveryRequestParameters MasterTimeout(string master_timeout)
		{
			this._master_timeout = master_timeout;
			this.AddQueryString("master_timeout", this._master_timeout);
			return this;
		}
		
		
		internal  string[] _h { get; set; }
		///<summary>Comma-separated list of column names to display</summary>
		public CatRecoveryRequestParameters H(params string[] h)
		{
			this._h = h;
			this.AddQueryString("h", this._h);
			return this;
		}
		
		
		internal bool _help { get; set; }
		///<summary>Return help information</summary>
		public CatRecoveryRequestParameters Help(bool help)
		{
			this._help = help;
			this.AddQueryString("help", this._help);
			return this;
		}
		
		
		internal bool _v { get; set; }
		///<summary>Verbose mode. Display column headers</summary>
		public CatRecoveryRequestParameters V(bool v)
		{
			this._v = v;
			this.AddQueryString("v", this._v);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for CatShards
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-shards.html
	///</pre>
	///</summary>
	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 CatShardsRequestParameters Local(bool local)
		{
			this._local = local;
			this.AddQueryString("local", this._local);
			return this;
		}
		
		
		internal string _master_timeout { get; set; }
		///<summary>Explicit operation timeout for connection to master node</summary>
		public CatShardsRequestParameters MasterTimeout(string master_timeout)
		{
			this._master_timeout = master_timeout;
			this.AddQueryString("master_timeout", this._master_timeout);
			return this;
		}
		
		
		internal  string[] _h { get; set; }
		///<summary>Comma-separated list of column names to display</summary>
		public CatShardsRequestParameters H(params string[] h)
		{
			this._h = h;
			this.AddQueryString("h", this._h);
			return this;
		}
		
		
		internal bool _help { get; set; }
		///<summary>Return help information</summary>
		public CatShardsRequestParameters Help(bool help)
		{
			this._help = help;
			this.AddQueryString("help", this._help);
			return this;
		}
		
		
		internal bool _v { get; set; }
		///<summary>Verbose mode. Display column headers</summary>
		public CatShardsRequestParameters V(bool v)
		{
			this._v = v;
			this.AddQueryString("v", this._v);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for CatThreadPool
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/cat-thread-pool.html
	///</pre>
	///</summary>
	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 CatThreadPoolRequestParameters Local(bool local)
		{
			this._local = local;
			this.AddQueryString("local", this._local);
			return this;
		}
		
		
		internal string _master_timeout { get; set; }
		///<summary>Explicit operation timeout for connection to master node</summary>
		public CatThreadPoolRequestParameters MasterTimeout(string master_timeout)
		{
			this._master_timeout = master_timeout;
			this.AddQueryString("master_timeout", this._master_timeout);
			return this;
		}
		
		
		internal  string[] _h { get; set; }
		///<summary>Comma-separated list of column names to display</summary>
		public CatThreadPoolRequestParameters H(params string[] h)
		{
			this._h = h;
			this.AddQueryString("h", this._h);
			return this;
		}
		
		
		internal bool _help { get; set; }
		///<summary>Return help information</summary>
		public CatThreadPoolRequestParameters Help(bool help)
		{
			this._help = help;
			this.AddQueryString("help", this._help);
			return this;
		}
		
		
		internal bool _v { get; set; }
		///<summary>Verbose mode. Display column headers</summary>
		public CatThreadPoolRequestParameters V(bool v)
		{
			this._v = v;
			this.AddQueryString("v", this._v);
			return this;
		}
		
		
		internal bool _full_id { get; set; }
		///<summary>Enables displaying the complete node ids</summary>
		public CatThreadPoolRequestParameters FullId(bool full_id)
		{
			this._full_id = full_id;
			this.AddQueryString("full_id", this._full_id);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for ClearScroll
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html
	///</pre>
	///</summary>
	public class ClearScrollRequestParameters : FluentRequestParameters<ClearScrollRequestParameters> 
	{
	}
	
	
	///<summary>Request parameters descriptor for ClusterGetSettings
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-update-settings.html
	///</pre>
	///</summary>
	public class ClusterGetSettingsRequestParameters : FluentRequestParameters<ClusterGetSettingsRequestParameters> 
	{
		
		internal bool _flat_settings { get; set; }
		///<summary>Return settings in flat format (default: false)</summary>
		public ClusterGetSettingsRequestParameters FlatSettings(bool flat_settings)
		{
			this._flat_settings = flat_settings;
			this.AddQueryString("flat_settings", this._flat_settings);
			return this;
		}
		
		
		internal string _master_timeout { get; set; }
		///<summary>Explicit operation timeout for connection to master node</summary>
		public ClusterGetSettingsRequestParameters MasterTimeout(string master_timeout)
		{
			this._master_timeout = master_timeout;
			this.AddQueryString("master_timeout", this._master_timeout);
			return this;
		}
		
		
		internal string _timeout { get; set; }
		///<summary>Explicit operation timeout</summary>
		public ClusterGetSettingsRequestParameters Timeout(string timeout)
		{
			this._timeout = timeout;
			this.AddQueryString("timeout", this._timeout);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for ClusterHealth
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-health.html
	///</pre>
	///</summary>
	public class ClusterHealthRequestParameters : FluentRequestParameters<ClusterHealthRequestParameters> 
	{
		
		internal Level _level { get; set; }
		///<summary>Specify the level of detail for returned information</summary>
		public ClusterHealthRequestParameters Level(Level level)
		{
			this._level = level;
			this.AddQueryString("level", this._level);
			return this;
		}
		
		
		internal bool _local { get; set; }
		///<summary>Return local information, do not retrieve the state from master node (default: false)</summary>
		public ClusterHealthRequestParameters Local(bool local)
		{
			this._local = local;
			this.AddQueryString("local", this._local);
			return this;
		}
		
		
		internal string _master_timeout { get; set; }
		///<summary>Explicit operation timeout for connection to master node</summary>
		public ClusterHealthRequestParameters MasterTimeout(string master_timeout)
		{
			this._master_timeout = master_timeout;
			this.AddQueryString("master_timeout", this._master_timeout);
			return this;
		}
		
		
		internal string _timeout { get; set; }
		///<summary>Explicit operation timeout</summary>
		public ClusterHealthRequestParameters Timeout(string timeout)
		{
			this._timeout = timeout;
			this.AddQueryString("timeout", this._timeout);
			return this;
		}
		
		
		internal long _wait_for_active_shards { get; set; }
		///<summary>Wait until the specified number of shards is active</summary>
		public ClusterHealthRequestParameters WaitForActiveShards(long wait_for_active_shards)
		{
			this._wait_for_active_shards = wait_for_active_shards;
			this.AddQueryString("wait_for_active_shards", this._wait_for_active_shards);
			return this;
		}
		
		
		internal string _wait_for_nodes { get; set; }
		///<summary>Wait until the specified number of nodes is available</summary>
		public ClusterHealthRequestParameters WaitForNodes(string wait_for_nodes)
		{
			this._wait_for_nodes = wait_for_nodes;
			this.AddQueryString("wait_for_nodes", this._wait_for_nodes);
			return this;
		}
		
		
		internal long _wait_for_relocating_shards { get; set; }
		///<summary>Wait until the specified number of relocating shards is finished</summary>
		public ClusterHealthRequestParameters WaitForRelocatingShards(long wait_for_relocating_shards)
		{
			this._wait_for_relocating_shards = wait_for_relocating_shards;
			this.AddQueryString("wait_for_relocating_shards", this._wait_for_relocating_shards);
			return this;
		}
		
		
		internal WaitForStatus _wait_for_status { get; set; }
		///<summary>Wait until cluster is in a specific state</summary>
		public ClusterHealthRequestParameters WaitForStatus(WaitForStatus wait_for_status)
		{
			this._wait_for_status = wait_for_status;
			this.AddQueryString("wait_for_status", this._wait_for_status);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for ClusterPendingTasks
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-pending.html
	///</pre>
	///</summary>
	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 ClusterPendingTasksRequestParameters Local(bool local)
		{
			this._local = local;
			this.AddQueryString("local", this._local);
			return this;
		}
		
		
		internal string _master_timeout { get; set; }
		///<summary>Specify timeout for connection to master</summary>
		public ClusterPendingTasksRequestParameters MasterTimeout(string master_timeout)
		{
			this._master_timeout = master_timeout;
			this.AddQueryString("master_timeout", this._master_timeout);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for ClusterPutSettings
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-update-settings.html
	///</pre>
	///</summary>
	public class ClusterSettingsRequestParameters : FluentRequestParameters<ClusterSettingsRequestParameters> 
	{
		
		internal bool _flat_settings { get; set; }
		///<summary>Return settings in flat format (default: false)</summary>
		public ClusterSettingsRequestParameters FlatSettings(bool flat_settings)
		{
			this._flat_settings = flat_settings;
			this.AddQueryString("flat_settings", this._flat_settings);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for ClusterReroute
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-reroute.html
	///</pre>
	///</summary>
	public class ClusterRerouteRequestParameters : FluentRequestParameters<ClusterRerouteRequestParameters> 
	{
		
		internal bool _dry_run { get; set; }
		///<summary>Simulate the operation only and return the resulting state</summary>
		public ClusterRerouteRequestParameters DryRun(bool dry_run)
		{
			this._dry_run = dry_run;
			this.AddQueryString("dry_run", this._dry_run);
			return this;
		}
		
		
		internal bool _explain { get; set; }
		///<summary>Return an explanation of why the commands can or cannot be executed</summary>
		public ClusterRerouteRequestParameters Explain(bool explain)
		{
			this._explain = explain;
			this.AddQueryString("explain", this._explain);
			return this;
		}
		
		
		internal bool _filter_metadata { get; set; }
		///<summary>Don&#39;t return cluster state metadata (default: false)</summary>
		public ClusterRerouteRequestParameters FilterMetadata(bool filter_metadata)
		{
			this._filter_metadata = filter_metadata;
			this.AddQueryString("filter_metadata", this._filter_metadata);
			return this;
		}
		
		
		internal string _master_timeout { get; set; }
		///<summary>Explicit operation timeout for connection to master node</summary>
		public ClusterRerouteRequestParameters MasterTimeout(string master_timeout)
		{
			this._master_timeout = master_timeout;
			this.AddQueryString("master_timeout", this._master_timeout);
			return this;
		}
		
		
		internal string _timeout { get; set; }
		///<summary>Explicit operation timeout</summary>
		public ClusterRerouteRequestParameters Timeout(string timeout)
		{
			this._timeout = timeout;
			this.AddQueryString("timeout", this._timeout);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for ClusterState
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-state.html
	///</pre>
	///</summary>
	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 ClusterStateRequestParameters Local(bool local)
		{
			this._local = local;
			this.AddQueryString("local", this._local);
			return this;
		}
		
		
		internal string _master_timeout { get; set; }
		///<summary>Specify timeout for connection to master</summary>
		public ClusterStateRequestParameters MasterTimeout(string master_timeout)
		{
			this._master_timeout = master_timeout;
			this.AddQueryString("master_timeout", this._master_timeout);
			return this;
		}
		
		
		internal bool _flat_settings { get; set; }
		///<summary>Return settings in flat format (default: false)</summary>
		public ClusterStateRequestParameters FlatSettings(bool flat_settings)
		{
			this._flat_settings = flat_settings;
			this.AddQueryString("flat_settings", this._flat_settings);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for ClusterStats
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-stats.html
	///</pre>
	///</summary>
	public class ClusterStatsRequestParameters : FluentRequestParameters<ClusterStatsRequestParameters> 
	{
		
		internal bool _flat_settings { get; set; }
		///<summary>Return settings in flat format (default: false)</summary>
		public ClusterStatsRequestParameters FlatSettings(bool flat_settings)
		{
			this._flat_settings = flat_settings;
			this.AddQueryString("flat_settings", this._flat_settings);
			return this;
		}
		
		
		internal bool _human { get; set; }
		///<summary>Whether to return time and byte values in human-readable format.</summary>
		public ClusterStatsRequestParameters Human(bool human)
		{
			this._human = human;
			this.AddQueryString("human", this._human);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for Count
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html
	///</pre>
	///</summary>
	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 CountRequestParameters IgnoreUnavailable(bool ignore_unavailable)
		{
			this._ignore_unavailable = ignore_unavailable;
			this.AddQueryString("ignore_unavailable", this._ignore_unavailable);
			return this;
		}
		
		
		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 CountRequestParameters AllowNoIndices(bool allow_no_indices)
		{
			this._allow_no_indices = allow_no_indices;
			this.AddQueryString("allow_no_indices", this._allow_no_indices);
			return this;
		}
		
		
		internal ExpandWildcards _expand_wildcards { get; set; }
		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
		public CountRequestParameters ExpandWildcards(ExpandWildcards expand_wildcards)
		{
			this._expand_wildcards = expand_wildcards;
			this.AddQueryString("expand_wildcards", this._expand_wildcards);
			return this;
		}
		
		
		internal double _min_score { get; set; }
		///<summary>Include only documents with a specific `_score` value in the result</summary>
		public CountRequestParameters MinScore(double min_score)
		{
			this._min_score = min_score;
			this.AddQueryString("min_score", this._min_score);
			return this;
		}
		
		
		internal string _preference { get; set; }
		///<summary>Specify the node or shard the operation should be performed on (default: random)</summary>
		public CountRequestParameters Preference(string preference)
		{
			this._preference = preference;
			this.AddQueryString("preference", this._preference);
			return this;
		}
		
		
		internal string _routing { get; set; }
		///<summary>Specific routing value</summary>
		public CountRequestParameters Routing(string routing)
		{
			this._routing = routing;
			this.AddQueryString("routing", this._routing);
			return this;
		}
		
		
		internal string _source { get; set; }
		///<summary>The URL-encoded query definition (instead of using the request body)</summary>
		public CountRequestParameters Source(string source)
		{
			this._source = source;
			this.AddQueryString("source", this._source);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for CountPercolateGet
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html
	///</pre>
	///</summary>
	public class PercolateCountRequestParameters : FluentRequestParameters<PercolateCountRequestParameters> 
	{
		
		internal  string[] _routing { get; set; }
		///<summary>A comma-separated list of specific routing values</summary>
		public PercolateCountRequestParameters Routing(params string[] routing)
		{
			this._routing = routing;
			this.AddQueryString("routing", this._routing);
			return this;
		}
		
		
		internal string _preference { get; set; }
		///<summary>Specify the node or shard the operation should be performed on (default: random)</summary>
		public PercolateCountRequestParameters Preference(string preference)
		{
			this._preference = preference;
			this.AddQueryString("preference", this._preference);
			return this;
		}
		
		
		internal bool _ignore_unavailable { get; set; }
		///<summary>Whether specified concrete indices should be ignored when unavailable (missing or closed)</summary>
		public PercolateCountRequestParameters IgnoreUnavailable(bool ignore_unavailable)
		{
			this._ignore_unavailable = ignore_unavailable;
			this.AddQueryString("ignore_unavailable", this._ignore_unavailable);
			return this;
		}
		
		
		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 PercolateCountRequestParameters AllowNoIndices(bool allow_no_indices)
		{
			this._allow_no_indices = allow_no_indices;
			this.AddQueryString("allow_no_indices", this._allow_no_indices);
			return this;
		}
		
		
		internal ExpandWildcards _expand_wildcards { get; set; }
		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
		public PercolateCountRequestParameters ExpandWildcards(ExpandWildcards expand_wildcards)
		{
			this._expand_wildcards = expand_wildcards;
			this.AddQueryString("expand_wildcards", this._expand_wildcards);
			return this;
		}
		
		
		internal string _percolate_index { get; set; }
		///<summary>The index to count percolate the document into. Defaults to index.</summary>
		public PercolateCountRequestParameters PercolateIndex(string percolate_index)
		{
			this._percolate_index = percolate_index;
			this.AddQueryString("percolate_index", this._percolate_index);
			return this;
		}
		
		
		internal string _percolate_type { get; set; }
		///<summary>The type to count percolate document into. Defaults to type.</summary>
		public PercolateCountRequestParameters PercolateType(string percolate_type)
		{
			this._percolate_type = percolate_type;
			this.AddQueryString("percolate_type", this._percolate_type);
			return this;
		}
		
		
		internal long _version { get; set; }
		///<summary>Explicit version number for concurrency control</summary>
		public PercolateCountRequestParameters Version(long version)
		{
			this._version = version;
			this.AddQueryString("version", this._version);
			return this;
		}
		
		
		internal VersionType _version_type { get; set; }
		///<summary>Specific version type</summary>
		public PercolateCountRequestParameters VersionType(VersionType version_type)
		{
			this._version_type = version_type;
			this.AddQueryString("version_type", this._version_type);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for Delete
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-delete.html
	///</pre>
	///</summary>
	public class DeleteRequestParameters : FluentRequestParameters<DeleteRequestParameters> 
	{
		
		internal Consistency _consistency { get; set; }
		///<summary>Specific write consistency setting for the operation</summary>
		public DeleteRequestParameters Consistency(Consistency consistency)
		{
			this._consistency = consistency;
			this.AddQueryString("consistency", this._consistency);
			return this;
		}
		
		
		internal string _parent { get; set; }
		///<summary>ID of parent document</summary>
		public DeleteRequestParameters Parent(string parent)
		{
			this._parent = parent;
			this.AddQueryString("parent", this._parent);
			return this;
		}
		
		
		internal bool _refresh { get; set; }
		///<summary>Refresh the index after performing the operation</summary>
		public DeleteRequestParameters Refresh(bool refresh)
		{
			this._refresh = refresh;
			this.AddQueryString("refresh", this._refresh);
			return this;
		}
		
		
		internal Replication _replication { get; set; }
		///<summary>Specific replication type</summary>
		public DeleteRequestParameters Replication(Replication replication)
		{
			this._replication = replication;
			this.AddQueryString("replication", this._replication);
			return this;
		}
		
		
		internal string _routing { get; set; }
		///<summary>Specific routing value</summary>
		public DeleteRequestParameters Routing(string routing)
		{
			this._routing = routing;
			this.AddQueryString("routing", this._routing);
			return this;
		}
		
		
		internal string _timeout { get; set; }
		///<summary>Explicit operation timeout</summary>
		public DeleteRequestParameters Timeout(string timeout)
		{
			this._timeout = timeout;
			this.AddQueryString("timeout", this._timeout);
			return this;
		}
		
		
		internal long _version { get; set; }
		///<summary>Explicit version number for concurrency control</summary>
		public DeleteRequestParameters Version(long version)
		{
			this._version = version;
			this.AddQueryString("version", this._version);
			return this;
		}
		
		
		internal VersionType _version_type { get; set; }
		///<summary>Specific version type</summary>
		public DeleteRequestParameters VersionType(VersionType version_type)
		{
			this._version_type = version_type;
			this.AddQueryString("version_type", this._version_type);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for DeleteByQuery
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-delete-by-query.html
	///</pre>
	///</summary>
	public class DeleteByQueryRequestParameters : FluentRequestParameters<DeleteByQueryRequestParameters> 
	{
		
		internal string _analyzer { get; set; }
		///<summary>The analyzer to use for the query string</summary>
		public DeleteByQueryRequestParameters Analyzer(string analyzer)
		{
			this._analyzer = analyzer;
			this.AddQueryString("analyzer", this._analyzer);
			return this;
		}
		
		
		internal Consistency _consistency { get; set; }
		///<summary>Specific write consistency setting for the operation</summary>
		public DeleteByQueryRequestParameters Consistency(Consistency consistency)
		{
			this._consistency = consistency;
			this.AddQueryString("consistency", this._consistency);
			return this;
		}
		
		
		internal DefaultOperator _default_operator { get; set; }
		///<summary>The default operator for query string query (AND or OR)</summary>
		public DeleteByQueryRequestParameters DefaultOperator(DefaultOperator default_operator)
		{
			this._default_operator = default_operator;
			this.AddQueryString("default_operator", this._default_operator);
			return this;
		}
		
		
		internal string _df { get; set; }
		///<summary>The field to use as default where no field prefix is given in the query string</summary>
		public DeleteByQueryRequestParameters Df(string df)
		{
			this._df = df;
			this.AddQueryString("df", this._df);
			return this;
		}
		
		
		internal bool _ignore_unavailable { get; set; }
		///<summary>Whether specified concrete indices should be ignored when unavailable (missing or closed)</summary>
		public DeleteByQueryRequestParameters IgnoreUnavailable(bool ignore_unavailable)
		{
			this._ignore_unavailable = ignore_unavailable;
			this.AddQueryString("ignore_unavailable", this._ignore_unavailable);
			return this;
		}
		
		
		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 DeleteByQueryRequestParameters AllowNoIndices(bool allow_no_indices)
		{
			this._allow_no_indices = allow_no_indices;
			this.AddQueryString("allow_no_indices", this._allow_no_indices);
			return this;
		}
		
		
		internal ExpandWildcards _expand_wildcards { get; set; }
		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
		public DeleteByQueryRequestParameters ExpandWildcards(ExpandWildcards expand_wildcards)
		{
			this._expand_wildcards = expand_wildcards;
			this.AddQueryString("expand_wildcards", this._expand_wildcards);
			return this;
		}
		
		
		internal Replication _replication { get; set; }
		///<summary>Specific replication type</summary>
		public DeleteByQueryRequestParameters Replication(Replication replication)
		{
			this._replication = replication;
			this.AddQueryString("replication", this._replication);
			return this;
		}
		
		
		internal string _q { get; set; }
		///<summary>Query in the Lucene query string syntax</summary>
		public DeleteByQueryRequestParameters Q(string q)
		{
			this._q = q;
			this.AddQueryString("q", this._q);
			return this;
		}
		
		
		internal string _routing { get; set; }
		///<summary>Specific routing value</summary>
		public DeleteByQueryRequestParameters Routing(string routing)
		{
			this._routing = routing;
			this.AddQueryString("routing", this._routing);
			return this;
		}
		
		
		internal string _source { get; set; }
		///<summary>The URL-encoded query definition (instead of using the request body)</summary>
		public DeleteByQueryRequestParameters Source(string source)
		{
			this._source = source;
			this.AddQueryString("source", this._source);
			return this;
		}
		
		
		internal string _timeout { get; set; }
		///<summary>Explicit operation timeout</summary>
		public DeleteByQueryRequestParameters Timeout(string timeout)
		{
			this._timeout = timeout;
			this.AddQueryString("timeout", this._timeout);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for DeleteScript
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html
	///</pre>
	///</summary>
	public class DeleteScriptRequestParameters : FluentRequestParameters<DeleteScriptRequestParameters> 
	{
	}
	
	
	///<summary>Request parameters descriptor for DeleteTemplate
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html
	///</pre>
	///</summary>
	public class DeleteTemplateRequestParameters : FluentRequestParameters<DeleteTemplateRequestParameters> 
	{
	}
	
	
	///<summary>Request parameters descriptor for Exists
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-get.html
	///</pre>
	///</summary>
	public class DocumentExistsRequestParameters : FluentRequestParameters<DocumentExistsRequestParameters> 
	{
		
		internal string _parent { get; set; }
		///<summary>The ID of the parent document</summary>
		public DocumentExistsRequestParameters Parent(string parent)
		{
			this._parent = parent;
			this.AddQueryString("parent", this._parent);
			return this;
		}
		
		
		internal string _preference { get; set; }
		///<summary>Specify the node or shard the operation should be performed on (default: random)</summary>
		public DocumentExistsRequestParameters Preference(string preference)
		{
			this._preference = preference;
			this.AddQueryString("preference", this._preference);
			return this;
		}
		
		
		internal bool _realtime { get; set; }
		///<summary>Specify whether to perform the operation in realtime or search mode</summary>
		public DocumentExistsRequestParameters Realtime(bool realtime)
		{
			this._realtime = realtime;
			this.AddQueryString("realtime", this._realtime);
			return this;
		}
		
		
		internal bool _refresh { get; set; }
		///<summary>Refresh the shard containing the document before performing the operation</summary>
		public DocumentExistsRequestParameters Refresh(bool refresh)
		{
			this._refresh = refresh;
			this.AddQueryString("refresh", this._refresh);
			return this;
		}
		
		
		internal string _routing { get; set; }
		///<summary>Specific routing value</summary>
		public DocumentExistsRequestParameters Routing(string routing)
		{
			this._routing = routing;
			this.AddQueryString("routing", this._routing);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for ExplainGet
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-explain.html
	///</pre>
	///</summary>
	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 ExplainRequestParameters AnalyzeWildcard(bool analyze_wildcard)
		{
			this._analyze_wildcard = analyze_wildcard;
			this.AddQueryString("analyze_wildcard", this._analyze_wildcard);
			return this;
		}
		
		
		internal string _analyzer { get; set; }
		///<summary>The analyzer for the query string query</summary>
		public ExplainRequestParameters Analyzer(string analyzer)
		{
			this._analyzer = analyzer;
			this.AddQueryString("analyzer", this._analyzer);
			return this;
		}
		
		
		internal DefaultOperator _default_operator { get; set; }
		///<summary>The default operator for query string query (AND or OR)</summary>
		public ExplainRequestParameters DefaultOperator(DefaultOperator default_operator)
		{
			this._default_operator = default_operator;
			this.AddQueryString("default_operator", this._default_operator);
			return this;
		}
		
		
		internal string _df { get; set; }
		///<summary>The default field for query string query (default: _all)</summary>
		public ExplainRequestParameters Df(string df)
		{
			this._df = df;
			this.AddQueryString("df", this._df);
			return this;
		}
		
		
		internal IEnumerable<object> _fields { get; set; }
		///<summary>A comma-separated list of fields to return in the response</summary>
		public ExplainRequestParameters Fields(params string[] fields)
		{
			this._fields = fields.Select(f=>(object)f);
			this.AddQueryString("fields", this._fields);
			return this;
		}
		
		
		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 ExplainRequestParameters Lenient(bool lenient)
		{
			this._lenient = lenient;
			this.AddQueryString("lenient", this._lenient);
			return this;
		}
		
		
		internal bool _lowercase_expanded_terms { get; set; }
		///<summary>Specify whether query terms should be lowercased</summary>
		public ExplainRequestParameters LowercaseExpandedTerms(bool lowercase_expanded_terms)
		{
			this._lowercase_expanded_terms = lowercase_expanded_terms;
			this.AddQueryString("lowercase_expanded_terms", this._lowercase_expanded_terms);
			return this;
		}
		
		
		internal string _parent { get; set; }
		///<summary>The ID of the parent document</summary>
		public ExplainRequestParameters Parent(string parent)
		{
			this._parent = parent;
			this.AddQueryString("parent", this._parent);
			return this;
		}
		
		
		internal string _preference { get; set; }
		///<summary>Specify the node or shard the operation should be performed on (default: random)</summary>
		public ExplainRequestParameters Preference(string preference)
		{
			this._preference = preference;
			this.AddQueryString("preference", this._preference);
			return this;
		}
		
		
		internal string _q { get; set; }
		///<summary>Query in the Lucene query string syntax</summary>
		public ExplainRequestParameters Q(string q)
		{
			this._q = q;
			this.AddQueryString("q", this._q);
			return this;
		}
		
		
		internal string _routing { get; set; }
		///<summary>Specific routing value</summary>
		public ExplainRequestParameters Routing(string routing)
		{
			this._routing = routing;
			this.AddQueryString("routing", this._routing);
			return this;
		}
		
		
		internal string _source { get; set; }
		///<summary>The URL-encoded query definition (instead of using the request body)</summary>
		public ExplainRequestParameters Source(string source)
		{
			this._source = source;
			this.AddQueryString("source", this._source);
			return this;
		}
		
		
		internal  string[] _source_enabled { get; set; }
		///<summary>True or false to return the _source field or not, or a list of fields to return</summary>
		public ExplainRequestParameters SourceEnabled(params string[] source_enabled)
		{
			this._source_enabled = source_enabled;
			this.AddQueryString("_source", this._source_enabled);
			return this;
		}
		
		
		internal bool _enable_source { get; set; }
		///<summary>True or false to return the _source field or not, or a list of fields to return</summary>
		public ExplainRequestParameters EnableSource(bool enable_source)
		{
			this._enable_source = enable_source;
			this.AddQueryString("_source", this._enable_source);
			return this;
		}
		
		
		internal IEnumerable<object> _source_exclude { get; set; }
		///<summary>A list of fields to exclude from the returned _source field</summary>
		public ExplainRequestParameters SourceExclude(params string[] source_exclude)
		{
			this._source_exclude = source_exclude.Select(f=>(object)f);
			this.AddQueryString("_source_exclude", this._source_exclude);
			return this;
		}
		
		
		internal IEnumerable<object> _source_include { get; set; }
		///<summary>A list of fields to extract and return from the _source field</summary>
		public ExplainRequestParameters SourceInclude(params string[] source_include)
		{
			this._source_include = source_include.Select(f=>(object)f);
			this.AddQueryString("_source_include", this._source_include);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for Get
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-get.html
	///</pre>
	///</summary>
	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 GetRequestParameters Fields(params string[] fields)
		{
			this._fields = fields.Select(f=>(object)f);
			this.AddQueryString("fields", this._fields);
			return this;
		}
		
		
		internal string _parent { get; set; }
		///<summary>The ID of the parent document</summary>
		public GetRequestParameters Parent(string parent)
		{
			this._parent = parent;
			this.AddQueryString("parent", this._parent);
			return this;
		}
		
		
		internal string _preference { get; set; }
		///<summary>Specify the node or shard the operation should be performed on (default: random)</summary>
		public GetRequestParameters Preference(string preference)
		{
			this._preference = preference;
			this.AddQueryString("preference", this._preference);
			return this;
		}
		
		
		internal bool _realtime { get; set; }
		///<summary>Specify whether to perform the operation in realtime or search mode</summary>
		public GetRequestParameters Realtime(bool realtime)
		{
			this._realtime = realtime;
			this.AddQueryString("realtime", this._realtime);
			return this;
		}
		
		
		internal bool _refresh { get; set; }
		///<summary>Refresh the shard containing the document before performing the operation</summary>
		public GetRequestParameters Refresh(bool refresh)
		{
			this._refresh = refresh;
			this.AddQueryString("refresh", this._refresh);
			return this;
		}
		
		
		internal string _routing { get; set; }
		///<summary>Specific routing value</summary>
		public GetRequestParameters Routing(string routing)
		{
			this._routing = routing;
			this.AddQueryString("routing", this._routing);
			return this;
		}
		
		
		internal  string[] _source_enabled { get; set; }
		///<summary>True or false to return the _source field or not, or a list of fields to return</summary>
		public GetRequestParameters SourceEnabled(params string[] source_enabled)
		{
			this._source_enabled = source_enabled;
			this.AddQueryString("_source", this._source_enabled);
			return this;
		}
		
		
		internal bool _enable_source { get; set; }
		///<summary>True or false to return the _source field or not, or a list of fields to return</summary>
		public GetRequestParameters EnableSource(bool enable_source)
		{
			this._enable_source = enable_source;
			this.AddQueryString("_source", this._enable_source);
			return this;
		}
		
		
		internal IEnumerable<object> _source_exclude { get; set; }
		///<summary>A list of fields to exclude from the returned _source field</summary>
		public GetRequestParameters SourceExclude(params string[] source_exclude)
		{
			this._source_exclude = source_exclude.Select(f=>(object)f);
			this.AddQueryString("_source_exclude", this._source_exclude);
			return this;
		}
		
		
		internal IEnumerable<object> _source_include { get; set; }
		///<summary>A list of fields to extract and return from the _source field</summary>
		public GetRequestParameters SourceInclude(params string[] source_include)
		{
			this._source_include = source_include.Select(f=>(object)f);
			this.AddQueryString("_source_include", this._source_include);
			return this;
		}
		
		
		internal long _version { get; set; }
		///<summary>Explicit version number for concurrency control</summary>
		public GetRequestParameters Version(long version)
		{
			this._version = version;
			this.AddQueryString("version", this._version);
			return this;
		}
		
		
		internal VersionType _version_type { get; set; }
		///<summary>Specific version type</summary>
		public GetRequestParameters VersionType(VersionType version_type)
		{
			this._version_type = version_type;
			this.AddQueryString("version_type", this._version_type);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for GetScript
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html
	///</pre>
	///</summary>
	public class GetScriptRequestParameters : FluentRequestParameters<GetScriptRequestParameters> 
	{
	}
	
	
	///<summary>Request parameters descriptor for GetSource
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-get.html
	///</pre>
	///</summary>
	public class SourceRequestParameters : FluentRequestParameters<SourceRequestParameters> 
	{
		
		internal string _parent { get; set; }
		///<summary>The ID of the parent document</summary>
		public SourceRequestParameters Parent(string parent)
		{
			this._parent = parent;
			this.AddQueryString("parent", this._parent);
			return this;
		}
		
		
		internal string _preference { get; set; }
		///<summary>Specify the node or shard the operation should be performed on (default: random)</summary>
		public SourceRequestParameters Preference(string preference)
		{
			this._preference = preference;
			this.AddQueryString("preference", this._preference);
			return this;
		}
		
		
		internal bool _realtime { get; set; }
		///<summary>Specify whether to perform the operation in realtime or search mode</summary>
		public SourceRequestParameters Realtime(bool realtime)
		{
			this._realtime = realtime;
			this.AddQueryString("realtime", this._realtime);
			return this;
		}
		
		
		internal bool _refresh { get; set; }
		///<summary>Refresh the shard containing the document before performing the operation</summary>
		public SourceRequestParameters Refresh(bool refresh)
		{
			this._refresh = refresh;
			this.AddQueryString("refresh", this._refresh);
			return this;
		}
		
		
		internal string _routing { get; set; }
		///<summary>Specific routing value</summary>
		public SourceRequestParameters Routing(string routing)
		{
			this._routing = routing;
			this.AddQueryString("routing", this._routing);
			return this;
		}
		
		
		internal  string[] _source_enabled { get; set; }
		///<summary>True or false to return the _source field or not, or a list of fields to return</summary>
		public SourceRequestParameters SourceEnabled(params string[] source_enabled)
		{
			this._source_enabled = source_enabled;
			this.AddQueryString("_source", this._source_enabled);
			return this;
		}
		
		
		internal bool _enable_source { get; set; }
		///<summary>True or false to return the _source field or not, or a list of fields to return</summary>
		public SourceRequestParameters EnableSource(bool enable_source)
		{
			this._enable_source = enable_source;
			this.AddQueryString("_source", this._enable_source);
			return this;
		}
		
		
		internal IEnumerable<object> _source_exclude { get; set; }
		///<summary>A list of fields to exclude from the returned _source field</summary>
		public SourceRequestParameters SourceExclude(params string[] source_exclude)
		{
			this._source_exclude = source_exclude.Select(f=>(object)f);
			this.AddQueryString("_source_exclude", this._source_exclude);
			return this;
		}
		
		
		internal IEnumerable<object> _source_include { get; set; }
		///<summary>A list of fields to extract and return from the _source field</summary>
		public SourceRequestParameters SourceInclude(params string[] source_include)
		{
			this._source_include = source_include.Select(f=>(object)f);
			this.AddQueryString("_source_include", this._source_include);
			return this;
		}
		
		
		internal long _version { get; set; }
		///<summary>Explicit version number for concurrency control</summary>
		public SourceRequestParameters Version(long version)
		{
			this._version = version;
			this.AddQueryString("version", this._version);
			return this;
		}
		
		
		internal VersionType _version_type { get; set; }
		///<summary>Specific version type</summary>
		public SourceRequestParameters VersionType(VersionType version_type)
		{
			this._version_type = version_type;
			this.AddQueryString("version_type", this._version_type);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for GetTemplate
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html
	///</pre>
	///</summary>
	public class GetTemplateRequestParameters : FluentRequestParameters<GetTemplateRequestParameters> 
	{
	}
	
	
	///<summary>Request parameters descriptor for Index
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-index_.html
	///</pre>
	///</summary>
	public class IndexRequestParameters : FluentRequestParameters<IndexRequestParameters> 
	{
		
		internal Consistency _consistency { get; set; }
		///<summary>Explicit write consistency setting for the operation</summary>
		public IndexRequestParameters Consistency(Consistency consistency)
		{
			this._consistency = consistency;
			this.AddQueryString("consistency", this._consistency);
			return this;
		}
		
		
		internal OpType _op_type { get; set; }
		///<summary>Explicit operation type</summary>
		public IndexRequestParameters OpType(OpType op_type)
		{
			this._op_type = op_type;
			this.AddQueryString("op_type", this._op_type);
			return this;
		}
		
		
		internal string _parent { get; set; }
		///<summary>ID of the parent document</summary>
		public IndexRequestParameters Parent(string parent)
		{
			this._parent = parent;
			this.AddQueryString("parent", this._parent);
			return this;
		}
		
		
		internal bool _refresh { get; set; }
		///<summary>Refresh the index after performing the operation</summary>
		public IndexRequestParameters Refresh(bool refresh)
		{
			this._refresh = refresh;
			this.AddQueryString("refresh", this._refresh);
			return this;
		}
		
		
		internal Replication _replication { get; set; }
		///<summary>Specific replication type</summary>
		public IndexRequestParameters Replication(Replication replication)
		{
			this._replication = replication;
			this.AddQueryString("replication", this._replication);
			return this;
		}
		
		
		internal string _routing { get; set; }
		///<summary>Specific routing value</summary>
		public IndexRequestParameters Routing(string routing)
		{
			this._routing = routing;
			this.AddQueryString("routing", this._routing);
			return this;
		}
		
		
		internal string _timeout { get; set; }
		///<summary>Explicit operation timeout</summary>
		public IndexRequestParameters Timeout(string timeout)
		{
			this._timeout = timeout;
			this.AddQueryString("timeout", this._timeout);
			return this;
		}
		
		
		internal string _timestamp { get; set; }
		///<summary>Explicit timestamp for the document</summary>
		public IndexRequestParameters Timestamp(string timestamp)
		{
			this._timestamp = timestamp;
			this.AddQueryString("timestamp", this._timestamp);
			return this;
		}
		
		
		internal string _ttl { get; set; }
		///<summary>Expiration time for the document</summary>
		public IndexRequestParameters Ttl(string ttl)
		{
			this._ttl = ttl;
			this.AddQueryString("ttl", this._ttl);
			return this;
		}
		
		
		internal long _version { get; set; }
		///<summary>Explicit version number for concurrency control</summary>
		public IndexRequestParameters Version(long version)
		{
			this._version = version;
			this.AddQueryString("version", this._version);
			return this;
		}
		
		
		internal VersionType _version_type { get; set; }
		///<summary>Specific version type</summary>
		public IndexRequestParameters VersionType(VersionType version_type)
		{
			this._version_type = version_type;
			this.AddQueryString("version_type", this._version_type);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for IndicesAnalyzeGetForAll
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-analyze.html
	///</pre>
	///</summary>
	public class AnalyzeRequestParameters : FluentRequestParameters<AnalyzeRequestParameters> 
	{
		
		internal string _analyzer { get; set; }
		///<summary>The name of the analyzer to use</summary>
		public AnalyzeRequestParameters Analyzer(string analyzer)
		{
			this._analyzer = analyzer;
			this.AddQueryString("analyzer", this._analyzer);
			return this;
		}
		
		
		internal  string[] _char_filters { get; set; }
		///<summary>A comma-separated list of character filters to use for the analysis</summary>
		public AnalyzeRequestParameters CharFilters(params string[] char_filters)
		{
			this._char_filters = char_filters;
			this.AddQueryString("char_filters", this._char_filters);
			return this;
		}
		
		
		internal object _field { get; set; }
		///<summary>Use the analyzer configured for this field (instead of passing the analyzer name)</summary>
		public AnalyzeRequestParameters Field(string field)
		{
			this._field = field;
			this.AddQueryString("field", this._field);
			return this;
		}
		
		
		internal  string[] _filters { get; set; }
		///<summary>A comma-separated list of filters to use for the analysis</summary>
		public AnalyzeRequestParameters Filters(params string[] filters)
		{
			this._filters = filters;
			this.AddQueryString("filters", this._filters);
			return this;
		}
		
		
		internal string _index { get; set; }
		///<summary>The name of the index to scope the operation</summary>
		public AnalyzeRequestParameters Index(string index)
		{
			this._index = index;
			this.AddQueryString("index", this._index);
			return this;
		}
		
		
		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 AnalyzeRequestParameters PreferLocal(bool prefer_local)
		{
			this._prefer_local = prefer_local;
			this.AddQueryString("prefer_local", this._prefer_local);
			return this;
		}
		
		
		internal string _text { get; set; }
		///<summary>The text on which the analysis should be performed (when request body is not used)</summary>
		public AnalyzeRequestParameters Text(string text)
		{
			this._text = text;
			this.AddQueryString("text", this._text);
			return this;
		}
		
		
		internal string _tokenizer { get; set; }
		///<summary>The name of the tokenizer to use for the analysis</summary>
		public AnalyzeRequestParameters Tokenizer(string tokenizer)
		{
			this._tokenizer = tokenizer;
			this.AddQueryString("tokenizer", this._tokenizer);
			return this;
		}
		
		
		internal Format _format { get; set; }
		///<summary>Format of the output</summary>
		public AnalyzeRequestParameters Format(Format format)
		{
			this._format = format;
			this.AddQueryString("format", this._format);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for IndicesClearCacheForAll
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-clearcache.html
	///</pre>
	///</summary>
	public class ClearCacheRequestParameters : FluentRequestParameters<ClearCacheRequestParameters> 
	{
		
		internal bool _field_data { get; set; }
		///<summary>Clear field data</summary>
		public ClearCacheRequestParameters FieldData(bool field_data)
		{
			this._field_data = field_data;
			this.AddQueryString("field_data", this._field_data);
			return this;
		}
		
		
		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 ClearCacheRequestParameters Fields(params string[] fields)
		{
			this._fields = fields.Select(f=>(object)f);
			this.AddQueryString("fields", this._fields);
			return this;
		}
		
		
		internal bool _filter { get; set; }
		///<summary>Clear filter caches</summary>
		public ClearCacheRequestParameters Filter(bool filter)
		{
			this._filter = filter;
			this.AddQueryString("filter", this._filter);
			return this;
		}
		
		
		internal bool _filter_cache { get; set; }
		///<summary>Clear filter caches</summary>
		public ClearCacheRequestParameters FilterCache(bool filter_cache)
		{
			this._filter_cache = filter_cache;
			this.AddQueryString("filter_cache", this._filter_cache);
			return this;
		}
		
		
		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 ClearCacheRequestParameters FilterKeys(bool filter_keys)
		{
			this._filter_keys = filter_keys;
			this.AddQueryString("filter_keys", this._filter_keys);
			return this;
		}
		
		
		internal bool _id { get; set; }
		///<summary>Clear ID caches for parent/child</summary>
		public ClearCacheRequestParameters Id(bool id)
		{
			this._id = id;
			this.AddQueryString("id", this._id);
			return this;
		}
		
		
		internal bool _id_cache { get; set; }
		///<summary>Clear ID caches for parent/child</summary>
		public ClearCacheRequestParameters IdCache(bool id_cache)
		{
			this._id_cache = id_cache;
			this.AddQueryString("id_cache", this._id_cache);
			return this;
		}
		
		
		internal bool _ignore_unavailable { get; set; }
		///<summary>Whether specified concrete indices should be ignored when unavailable (missing or closed)</summary>
		public ClearCacheRequestParameters IgnoreUnavailable(bool ignore_unavailable)
		{
			this._ignore_unavailable = ignore_unavailable;
			this.AddQueryString("ignore_unavailable", this._ignore_unavailable);
			return this;
		}
		
		
		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 ClearCacheRequestParameters AllowNoIndices(bool allow_no_indices)
		{
			this._allow_no_indices = allow_no_indices;
			this.AddQueryString("allow_no_indices", this._allow_no_indices);
			return this;
		}
		
		
		internal ExpandWildcards _expand_wildcards { get; set; }
		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
		public ClearCacheRequestParameters ExpandWildcards(ExpandWildcards expand_wildcards)
		{
			this._expand_wildcards = expand_wildcards;
			this.AddQueryString("expand_wildcards", this._expand_wildcards);
			return this;
		}
		
		
		internal  string[] _index { get; set; }
		///<summary>A comma-separated list of index name to limit the operation</summary>
		public ClearCacheRequestParameters Index(params string[] index)
		{
			this._index = index;
			this.AddQueryString("index", this._index);
			return this;
		}
		
		
		internal bool _recycler { get; set; }
		///<summary>Clear the recycler cache</summary>
		public ClearCacheRequestParameters Recycler(bool recycler)
		{
			this._recycler = recycler;
			this.AddQueryString("recycler", this._recycler);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for IndicesClose
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-open-close.html
	///</pre>
	///</summary>
	public class CloseIndexRequestParameters : FluentRequestParameters<CloseIndexRequestParameters> 
	{
		
		internal string _timeout { get; set; }
		///<summary>Explicit operation timeout</summary>
		public CloseIndexRequestParameters Timeout(string timeout)
		{
			this._timeout = timeout;
			this.AddQueryString("timeout", this._timeout);
			return this;
		}
		
		
		internal string _master_timeout { get; set; }
		///<summary>Specify timeout for connection to master</summary>
		public CloseIndexRequestParameters MasterTimeout(string master_timeout)
		{
			this._master_timeout = master_timeout;
			this.AddQueryString("master_timeout", this._master_timeout);
			return this;
		}
		
		
		internal bool _ignore_unavailable { get; set; }
		///<summary>Whether specified concrete indices should be ignored when unavailable (missing or closed)</summary>
		public CloseIndexRequestParameters IgnoreUnavailable(bool ignore_unavailable)
		{
			this._ignore_unavailable = ignore_unavailable;
			this.AddQueryString("ignore_unavailable", this._ignore_unavailable);
			return this;
		}
		
		
		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 CloseIndexRequestParameters AllowNoIndices(bool allow_no_indices)
		{
			this._allow_no_indices = allow_no_indices;
			this.AddQueryString("allow_no_indices", this._allow_no_indices);
			return this;
		}
		
		
		internal ExpandWildcards _expand_wildcards { get; set; }
		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
		public CloseIndexRequestParameters ExpandWildcards(ExpandWildcards expand_wildcards)
		{
			this._expand_wildcards = expand_wildcards;
			this.AddQueryString("expand_wildcards", this._expand_wildcards);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for IndicesCreate
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-create-index.html
	///</pre>
	///</summary>
	public class CreateIndexRequestParameters : FluentRequestParameters<CreateIndexRequestParameters> 
	{
		
		internal string _timeout { get; set; }
		///<summary>Explicit operation timeout</summary>
		public CreateIndexRequestParameters Timeout(string timeout)
		{
			this._timeout = timeout;
			this.AddQueryString("timeout", this._timeout);
			return this;
		}
		
		
		internal string _master_timeout { get; set; }
		///<summary>Specify timeout for connection to master</summary>
		public CreateIndexRequestParameters MasterTimeout(string master_timeout)
		{
			this._master_timeout = master_timeout;
			this.AddQueryString("master_timeout", this._master_timeout);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for IndicesDelete
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-delete-index.html
	///</pre>
	///</summary>
	public class DeleteIndexRequestParameters : FluentRequestParameters<DeleteIndexRequestParameters> 
	{
		
		internal string _timeout { get; set; }
		///<summary>Explicit operation timeout</summary>
		public DeleteIndexRequestParameters Timeout(string timeout)
		{
			this._timeout = timeout;
			this.AddQueryString("timeout", this._timeout);
			return this;
		}
		
		
		internal string _master_timeout { get; set; }
		///<summary>Specify timeout for connection to master</summary>
		public DeleteIndexRequestParameters MasterTimeout(string master_timeout)
		{
			this._master_timeout = master_timeout;
			this.AddQueryString("master_timeout", this._master_timeout);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for IndicesDeleteAlias
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html
	///</pre>
	///</summary>
	public class IndicesDeleteAliasRequestParameters : FluentRequestParameters<IndicesDeleteAliasRequestParameters> 
	{
		
		internal string _timeout { get; set; }
		///<summary>Explicit timestamp for the document</summary>
		public IndicesDeleteAliasRequestParameters Timeout(string timeout)
		{
			this._timeout = timeout;
			this.AddQueryString("timeout", this._timeout);
			return this;
		}
		
		
		internal string _master_timeout { get; set; }
		///<summary>Specify timeout for connection to master</summary>
		public IndicesDeleteAliasRequestParameters MasterTimeout(string master_timeout)
		{
			this._master_timeout = master_timeout;
			this.AddQueryString("master_timeout", this._master_timeout);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for IndicesDeleteMapping
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-delete-mapping.html
	///</pre>
	///</summary>
	public class DeleteMappingRequestParameters : FluentRequestParameters<DeleteMappingRequestParameters> 
	{
		
		internal string _master_timeout { get; set; }
		///<summary>Specify timeout for connection to master</summary>
		public DeleteMappingRequestParameters MasterTimeout(string master_timeout)
		{
			this._master_timeout = master_timeout;
			this.AddQueryString("master_timeout", this._master_timeout);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for IndicesDeleteWarmer
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html
	///</pre>
	///</summary>
	public class DeleteWarmerRequestParameters : FluentRequestParameters<DeleteWarmerRequestParameters> 
	{
		
		internal string _master_timeout { get; set; }
		///<summary>Specify timeout for connection to master</summary>
		public DeleteWarmerRequestParameters MasterTimeout(string master_timeout)
		{
			this._master_timeout = master_timeout;
			this.AddQueryString("master_timeout", this._master_timeout);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for IndicesExists
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-settings.html
	///</pre>
	///</summary>
	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 IndexExistsRequestParameters IgnoreUnavailable(bool ignore_unavailable)
		{
			this._ignore_unavailable = ignore_unavailable;
			this.AddQueryString("ignore_unavailable", this._ignore_unavailable);
			return this;
		}
		
		
		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 IndexExistsRequestParameters AllowNoIndices(bool allow_no_indices)
		{
			this._allow_no_indices = allow_no_indices;
			this.AddQueryString("allow_no_indices", this._allow_no_indices);
			return this;
		}
		
		
		internal ExpandWildcards _expand_wildcards { get; set; }
		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
		public IndexExistsRequestParameters ExpandWildcards(ExpandWildcards expand_wildcards)
		{
			this._expand_wildcards = expand_wildcards;
			this.AddQueryString("expand_wildcards", this._expand_wildcards);
			return this;
		}
		
		
		internal bool _local { get; set; }
		///<summary>Return local information, do not retrieve the state from master node (default: false)</summary>
		public IndexExistsRequestParameters Local(bool local)
		{
			this._local = local;
			this.AddQueryString("local", this._local);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for IndicesExistsAliasForAll
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html
	///</pre>
	///</summary>
	public class AliasExistsRequestParameters : FluentRequestParameters<AliasExistsRequestParameters> 
	{
		
		internal bool _ignore_unavailable { get; set; }
		///<summary>Whether specified concrete indices should be ignored when unavailable (missing or closed)</summary>
		public AliasExistsRequestParameters IgnoreUnavailable(bool ignore_unavailable)
		{
			this._ignore_unavailable = ignore_unavailable;
			this.AddQueryString("ignore_unavailable", this._ignore_unavailable);
			return this;
		}
		
		
		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 AliasExistsRequestParameters AllowNoIndices(bool allow_no_indices)
		{
			this._allow_no_indices = allow_no_indices;
			this.AddQueryString("allow_no_indices", this._allow_no_indices);
			return this;
		}
		
		
		internal ExpandWildcards _expand_wildcards { get; set; }
		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
		public AliasExistsRequestParameters ExpandWildcards(ExpandWildcards expand_wildcards)
		{
			this._expand_wildcards = expand_wildcards;
			this.AddQueryString("expand_wildcards", this._expand_wildcards);
			return this;
		}
		
		
		internal bool _local { get; set; }
		///<summary>Return local information, do not retrieve the state from master node (default: false)</summary>
		public AliasExistsRequestParameters Local(bool local)
		{
			this._local = local;
			this.AddQueryString("local", this._local);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for IndicesExistsTemplateForAll
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html
	///</pre>
	///</summary>
	public class TemplateExistsRequestParameters : FluentRequestParameters<TemplateExistsRequestParameters> 
	{
		
		internal bool _local { get; set; }
		///<summary>Return local information, do not retrieve the state from master node (default: false)</summary>
		public TemplateExistsRequestParameters Local(bool local)
		{
			this._local = local;
			this.AddQueryString("local", this._local);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for IndicesExistsType
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-types-exists.html
	///</pre>
	///</summary>
	public class TypeExistsRequestParameters : FluentRequestParameters<TypeExistsRequestParameters> 
	{
		
		internal bool _ignore_unavailable { get; set; }
		///<summary>Whether specified concrete indices should be ignored when unavailable (missing or closed)</summary>
		public TypeExistsRequestParameters IgnoreUnavailable(bool ignore_unavailable)
		{
			this._ignore_unavailable = ignore_unavailable;
			this.AddQueryString("ignore_unavailable", this._ignore_unavailable);
			return this;
		}
		
		
		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 TypeExistsRequestParameters AllowNoIndices(bool allow_no_indices)
		{
			this._allow_no_indices = allow_no_indices;
			this.AddQueryString("allow_no_indices", this._allow_no_indices);
			return this;
		}
		
		
		internal ExpandWildcards _expand_wildcards { get; set; }
		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
		public TypeExistsRequestParameters ExpandWildcards(ExpandWildcards expand_wildcards)
		{
			this._expand_wildcards = expand_wildcards;
			this.AddQueryString("expand_wildcards", this._expand_wildcards);
			return this;
		}
		
		
		internal bool _local { get; set; }
		///<summary>Return local information, do not retrieve the state from master node (default: false)</summary>
		public TypeExistsRequestParameters Local(bool local)
		{
			this._local = local;
			this.AddQueryString("local", this._local);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for IndicesFlushForAll
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-flush.html
	///</pre>
	///</summary>
	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 FlushRequestParameters Force(bool force)
		{
			this._force = force;
			this.AddQueryString("force", this._force);
			return this;
		}
		
		
		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 FlushRequestParameters Full(bool full)
		{
			this._full = full;
			this.AddQueryString("full", this._full);
			return this;
		}
		
		
		internal bool _ignore_unavailable { get; set; }
		///<summary>Whether specified concrete indices should be ignored when unavailable (missing or closed)</summary>
		public FlushRequestParameters IgnoreUnavailable(bool ignore_unavailable)
		{
			this._ignore_unavailable = ignore_unavailable;
			this.AddQueryString("ignore_unavailable", this._ignore_unavailable);
			return this;
		}
		
		
		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 FlushRequestParameters AllowNoIndices(bool allow_no_indices)
		{
			this._allow_no_indices = allow_no_indices;
			this.AddQueryString("allow_no_indices", this._allow_no_indices);
			return this;
		}
		
		
		internal ExpandWildcards _expand_wildcards { get; set; }
		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
		public FlushRequestParameters ExpandWildcards(ExpandWildcards expand_wildcards)
		{
			this._expand_wildcards = expand_wildcards;
			this.AddQueryString("expand_wildcards", this._expand_wildcards);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for IndicesGetAliasForAll
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html
	///</pre>
	///</summary>
	public class GetAliasRequestParameters : FluentRequestParameters<GetAliasRequestParameters> 
	{
		
		internal bool _ignore_unavailable { get; set; }
		///<summary>Whether specified concrete indices should be ignored when unavailable (missing or closed)</summary>
		public GetAliasRequestParameters IgnoreUnavailable(bool ignore_unavailable)
		{
			this._ignore_unavailable = ignore_unavailable;
			this.AddQueryString("ignore_unavailable", this._ignore_unavailable);
			return this;
		}
		
		
		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 GetAliasRequestParameters AllowNoIndices(bool allow_no_indices)
		{
			this._allow_no_indices = allow_no_indices;
			this.AddQueryString("allow_no_indices", this._allow_no_indices);
			return this;
		}
		
		
		internal ExpandWildcards _expand_wildcards { get; set; }
		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
		public GetAliasRequestParameters ExpandWildcards(ExpandWildcards expand_wildcards)
		{
			this._expand_wildcards = expand_wildcards;
			this.AddQueryString("expand_wildcards", this._expand_wildcards);
			return this;
		}
		
		
		internal bool _local { get; set; }
		///<summary>Return local information, do not retrieve the state from master node (default: false)</summary>
		public GetAliasRequestParameters Local(bool local)
		{
			this._local = local;
			this.AddQueryString("local", this._local);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for IndicesGetAliasesForAll
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html
	///</pre>
	///</summary>
	public class GetAliasesRequestParameters : FluentRequestParameters<GetAliasesRequestParameters> 
	{
		
		internal string _timeout { get; set; }
		///<summary>Explicit operation timeout</summary>
		public GetAliasesRequestParameters Timeout(string timeout)
		{
			this._timeout = timeout;
			this.AddQueryString("timeout", this._timeout);
			return this;
		}
		
		
		internal bool _local { get; set; }
		///<summary>Return local information, do not retrieve the state from master node (default: false)</summary>
		public GetAliasesRequestParameters Local(bool local)
		{
			this._local = local;
			this.AddQueryString("local", this._local);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for IndicesGetFieldMappingForAll
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-field-mapping.html
	///</pre>
	///</summary>
	public class GetFieldMappingRequestParameters : FluentRequestParameters<GetFieldMappingRequestParameters> 
	{
		
		internal bool _include_defaults { get; set; }
		///<summary>Whether the default mapping values should be returned as well</summary>
		public GetFieldMappingRequestParameters IncludeDefaults(bool include_defaults)
		{
			this._include_defaults = include_defaults;
			this.AddQueryString("include_defaults", this._include_defaults);
			return this;
		}
		
		
		internal bool _ignore_unavailable { get; set; }
		///<summary>Whether specified concrete indices should be ignored when unavailable (missing or closed)</summary>
		public GetFieldMappingRequestParameters IgnoreUnavailable(bool ignore_unavailable)
		{
			this._ignore_unavailable = ignore_unavailable;
			this.AddQueryString("ignore_unavailable", this._ignore_unavailable);
			return this;
		}
		
		
		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 GetFieldMappingRequestParameters AllowNoIndices(bool allow_no_indices)
		{
			this._allow_no_indices = allow_no_indices;
			this.AddQueryString("allow_no_indices", this._allow_no_indices);
			return this;
		}
		
		
		internal ExpandWildcards _expand_wildcards { get; set; }
		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
		public GetFieldMappingRequestParameters ExpandWildcards(ExpandWildcards expand_wildcards)
		{
			this._expand_wildcards = expand_wildcards;
			this.AddQueryString("expand_wildcards", this._expand_wildcards);
			return this;
		}
		
		
		internal bool _local { get; set; }
		///<summary>Return local information, do not retrieve the state from master node (default: false)</summary>
		public GetFieldMappingRequestParameters Local(bool local)
		{
			this._local = local;
			this.AddQueryString("local", this._local);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for IndicesGetMappingForAll
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html
	///</pre>
	///</summary>
	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 GetMappingRequestParameters IgnoreUnavailable(bool ignore_unavailable)
		{
			this._ignore_unavailable = ignore_unavailable;
			this.AddQueryString("ignore_unavailable", this._ignore_unavailable);
			return this;
		}
		
		
		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 GetMappingRequestParameters AllowNoIndices(bool allow_no_indices)
		{
			this._allow_no_indices = allow_no_indices;
			this.AddQueryString("allow_no_indices", this._allow_no_indices);
			return this;
		}
		
		
		internal ExpandWildcards _expand_wildcards { get; set; }
		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
		public GetMappingRequestParameters ExpandWildcards(ExpandWildcards expand_wildcards)
		{
			this._expand_wildcards = expand_wildcards;
			this.AddQueryString("expand_wildcards", this._expand_wildcards);
			return this;
		}
		
		
		internal bool _local { get; set; }
		///<summary>Return local information, do not retrieve the state from master node (default: false)</summary>
		public GetMappingRequestParameters Local(bool local)
		{
			this._local = local;
			this.AddQueryString("local", this._local);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for IndicesGetSettingsForAll
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html
	///</pre>
	///</summary>
	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 GetIndexSettingsRequestParameters IgnoreUnavailable(bool ignore_unavailable)
		{
			this._ignore_unavailable = ignore_unavailable;
			this.AddQueryString("ignore_unavailable", this._ignore_unavailable);
			return this;
		}
		
		
		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 GetIndexSettingsRequestParameters AllowNoIndices(bool allow_no_indices)
		{
			this._allow_no_indices = allow_no_indices;
			this.AddQueryString("allow_no_indices", this._allow_no_indices);
			return this;
		}
		
		
		internal ExpandWildcards _expand_wildcards { get; set; }
		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
		public GetIndexSettingsRequestParameters ExpandWildcards(ExpandWildcards expand_wildcards)
		{
			this._expand_wildcards = expand_wildcards;
			this.AddQueryString("expand_wildcards", this._expand_wildcards);
			return this;
		}
		
		
		internal bool _flat_settings { get; set; }
		///<summary>Return settings in flat format (default: false)</summary>
		public GetIndexSettingsRequestParameters FlatSettings(bool flat_settings)
		{
			this._flat_settings = flat_settings;
			this.AddQueryString("flat_settings", this._flat_settings);
			return this;
		}
		
		
		internal bool _local { get; set; }
		///<summary>Return local information, do not retrieve the state from master node (default: false)</summary>
		public GetIndexSettingsRequestParameters Local(bool local)
		{
			this._local = local;
			this.AddQueryString("local", this._local);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for IndicesGetWarmerForAll
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html
	///</pre>
	///</summary>
	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 GetWarmerRequestParameters IgnoreUnavailable(bool ignore_unavailable)
		{
			this._ignore_unavailable = ignore_unavailable;
			this.AddQueryString("ignore_unavailable", this._ignore_unavailable);
			return this;
		}
		
		
		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 GetWarmerRequestParameters AllowNoIndices(bool allow_no_indices)
		{
			this._allow_no_indices = allow_no_indices;
			this.AddQueryString("allow_no_indices", this._allow_no_indices);
			return this;
		}
		
		
		internal ExpandWildcards _expand_wildcards { get; set; }
		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
		public GetWarmerRequestParameters ExpandWildcards(ExpandWildcards expand_wildcards)
		{
			this._expand_wildcards = expand_wildcards;
			this.AddQueryString("expand_wildcards", this._expand_wildcards);
			return this;
		}
		
		
		internal bool _local { get; set; }
		///<summary>Return local information, do not retrieve the state from master node (default: false)</summary>
		public GetWarmerRequestParameters Local(bool local)
		{
			this._local = local;
			this.AddQueryString("local", this._local);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for IndicesOpen
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-open-close.html
	///</pre>
	///</summary>
	public class OpenIndexRequestParameters : FluentRequestParameters<OpenIndexRequestParameters> 
	{
		
		internal string _timeout { get; set; }
		///<summary>Explicit operation timeout</summary>
		public OpenIndexRequestParameters Timeout(string timeout)
		{
			this._timeout = timeout;
			this.AddQueryString("timeout", this._timeout);
			return this;
		}
		
		
		internal string _master_timeout { get; set; }
		///<summary>Specify timeout for connection to master</summary>
		public OpenIndexRequestParameters MasterTimeout(string master_timeout)
		{
			this._master_timeout = master_timeout;
			this.AddQueryString("master_timeout", this._master_timeout);
			return this;
		}
		
		
		internal bool _ignore_unavailable { get; set; }
		///<summary>Whether specified concrete indices should be ignored when unavailable (missing or closed)</summary>
		public OpenIndexRequestParameters IgnoreUnavailable(bool ignore_unavailable)
		{
			this._ignore_unavailable = ignore_unavailable;
			this.AddQueryString("ignore_unavailable", this._ignore_unavailable);
			return this;
		}
		
		
		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 OpenIndexRequestParameters AllowNoIndices(bool allow_no_indices)
		{
			this._allow_no_indices = allow_no_indices;
			this.AddQueryString("allow_no_indices", this._allow_no_indices);
			return this;
		}
		
		
		internal ExpandWildcards _expand_wildcards { get; set; }
		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
		public OpenIndexRequestParameters ExpandWildcards(ExpandWildcards expand_wildcards)
		{
			this._expand_wildcards = expand_wildcards;
			this.AddQueryString("expand_wildcards", this._expand_wildcards);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for IndicesOptimizeForAll
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-optimize.html
	///</pre>
	///</summary>
	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 OptimizeRequestParameters Flush(bool flush)
		{
			this._flush = flush;
			this.AddQueryString("flush", this._flush);
			return this;
		}
		
		
		internal bool _ignore_unavailable { get; set; }
		///<summary>Whether specified concrete indices should be ignored when unavailable (missing or closed)</summary>
		public OptimizeRequestParameters IgnoreUnavailable(bool ignore_unavailable)
		{
			this._ignore_unavailable = ignore_unavailable;
			this.AddQueryString("ignore_unavailable", this._ignore_unavailable);
			return this;
		}
		
		
		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 OptimizeRequestParameters AllowNoIndices(bool allow_no_indices)
		{
			this._allow_no_indices = allow_no_indices;
			this.AddQueryString("allow_no_indices", this._allow_no_indices);
			return this;
		}
		
		
		internal ExpandWildcards _expand_wildcards { get; set; }
		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
		public OptimizeRequestParameters ExpandWildcards(ExpandWildcards expand_wildcards)
		{
			this._expand_wildcards = expand_wildcards;
			this.AddQueryString("expand_wildcards", this._expand_wildcards);
			return this;
		}
		
		
		internal long _max_num_segments { get; set; }
		///<summary>The number of segments the index should be merged into (default: dynamic)</summary>
		public OptimizeRequestParameters MaxNumSegments(long max_num_segments)
		{
			this._max_num_segments = max_num_segments;
			this.AddQueryString("max_num_segments", this._max_num_segments);
			return this;
		}
		
		
		internal bool _only_expunge_deletes { get; set; }
		///<summary>Specify whether the operation should only expunge deleted documents</summary>
		public OptimizeRequestParameters OnlyExpungeDeletes(bool only_expunge_deletes)
		{
			this._only_expunge_deletes = only_expunge_deletes;
			this.AddQueryString("only_expunge_deletes", this._only_expunge_deletes);
			return this;
		}
		
		
		internal string _operation_threading { get; set; }
		///<summary>TODO: ?</summary>
		public OptimizeRequestParameters OperationThreading(string operation_threading)
		{
			this._operation_threading = operation_threading;
			this.AddQueryString("operation_threading", this._operation_threading);
			return this;
		}
		
		
		internal bool _wait_for_merge { get; set; }
		///<summary>Specify whether the request should block until the merge process is finished (default: true)</summary>
		public OptimizeRequestParameters WaitForMerge(bool wait_for_merge)
		{
			this._wait_for_merge = wait_for_merge;
			this.AddQueryString("wait_for_merge", this._wait_for_merge);
			return this;
		}
		
		
		internal bool _force { get; set; }
		///<summary>Force a merge operation to run, even if there is a single segment in the index (default: false)</summary>
		public OptimizeRequestParameters Force(bool force)
		{
			this._force = force;
			this.AddQueryString("force", this._force);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for IndicesPutAlias
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html
	///</pre>
	///</summary>
	public class IndicesPutAliasRequestParameters : FluentRequestParameters<IndicesPutAliasRequestParameters> 
	{
		
		internal string _timeout { get; set; }
		///<summary>Explicit timestamp for the document</summary>
		public IndicesPutAliasRequestParameters Timeout(string timeout)
		{
			this._timeout = timeout;
			this.AddQueryString("timeout", this._timeout);
			return this;
		}
		
		
		internal string _master_timeout { get; set; }
		///<summary>Specify timeout for connection to master</summary>
		public IndicesPutAliasRequestParameters MasterTimeout(string master_timeout)
		{
			this._master_timeout = master_timeout;
			this.AddQueryString("master_timeout", this._master_timeout);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for IndicesPutMapping
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-put-mapping.html
	///</pre>
	///</summary>
	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 PutMappingRequestParameters IgnoreConflicts(bool ignore_conflicts)
		{
			this._ignore_conflicts = ignore_conflicts;
			this.AddQueryString("ignore_conflicts", this._ignore_conflicts);
			return this;
		}
		
		
		internal string _timeout { get; set; }
		///<summary>Explicit operation timeout</summary>
		public PutMappingRequestParameters Timeout(string timeout)
		{
			this._timeout = timeout;
			this.AddQueryString("timeout", this._timeout);
			return this;
		}
		
		
		internal string _master_timeout { get; set; }
		///<summary>Specify timeout for connection to master</summary>
		public PutMappingRequestParameters MasterTimeout(string master_timeout)
		{
			this._master_timeout = master_timeout;
			this.AddQueryString("master_timeout", this._master_timeout);
			return this;
		}
		
		
		internal bool _ignore_unavailable { get; set; }
		///<summary>Whether specified concrete indices should be ignored when unavailable (missing or closed)</summary>
		public PutMappingRequestParameters IgnoreUnavailable(bool ignore_unavailable)
		{
			this._ignore_unavailable = ignore_unavailable;
			this.AddQueryString("ignore_unavailable", this._ignore_unavailable);
			return this;
		}
		
		
		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 PutMappingRequestParameters AllowNoIndices(bool allow_no_indices)
		{
			this._allow_no_indices = allow_no_indices;
			this.AddQueryString("allow_no_indices", this._allow_no_indices);
			return this;
		}
		
		
		internal ExpandWildcards _expand_wildcards { get; set; }
		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
		public PutMappingRequestParameters ExpandWildcards(ExpandWildcards expand_wildcards)
		{
			this._expand_wildcards = expand_wildcards;
			this.AddQueryString("expand_wildcards", this._expand_wildcards);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for IndicesPutSettingsForAll
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-update-settings.html
	///</pre>
	///</summary>
	public class UpdateSettingsRequestParameters : FluentRequestParameters<UpdateSettingsRequestParameters> 
	{
		
		internal string _master_timeout { get; set; }
		///<summary>Specify timeout for connection to master</summary>
		public UpdateSettingsRequestParameters MasterTimeout(string master_timeout)
		{
			this._master_timeout = master_timeout;
			this.AddQueryString("master_timeout", this._master_timeout);
			return this;
		}
		
		
		internal bool _ignore_unavailable { get; set; }
		///<summary>Whether specified concrete indices should be ignored when unavailable (missing or closed)</summary>
		public UpdateSettingsRequestParameters IgnoreUnavailable(bool ignore_unavailable)
		{
			this._ignore_unavailable = ignore_unavailable;
			this.AddQueryString("ignore_unavailable", this._ignore_unavailable);
			return this;
		}
		
		
		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 UpdateSettingsRequestParameters AllowNoIndices(bool allow_no_indices)
		{
			this._allow_no_indices = allow_no_indices;
			this.AddQueryString("allow_no_indices", this._allow_no_indices);
			return this;
		}
		
		
		internal ExpandWildcards _expand_wildcards { get; set; }
		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
		public UpdateSettingsRequestParameters ExpandWildcards(ExpandWildcards expand_wildcards)
		{
			this._expand_wildcards = expand_wildcards;
			this.AddQueryString("expand_wildcards", this._expand_wildcards);
			return this;
		}
		
		
		internal bool _flat_settings { get; set; }
		///<summary>Return settings in flat format (default: false)</summary>
		public UpdateSettingsRequestParameters FlatSettings(bool flat_settings)
		{
			this._flat_settings = flat_settings;
			this.AddQueryString("flat_settings", this._flat_settings);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for IndicesPutTemplateForAll
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html
	///</pre>
	///</summary>
	public class PutTemplateRequestParameters : FluentRequestParameters<PutTemplateRequestParameters> 
	{
		
		internal bool _create { get; set; }
		///<summary>Whether the index template should only be added if new or can also replace an existing one</summary>
		public PutTemplateRequestParameters Create(bool create)
		{
			this._create = create;
			this.AddQueryString("create", this._create);
			return this;
		}
		
		
		internal string _timeout { get; set; }
		///<summary>Explicit operation timeout</summary>
		public PutTemplateRequestParameters Timeout(string timeout)
		{
			this._timeout = timeout;
			this.AddQueryString("timeout", this._timeout);
			return this;
		}
		
		
		internal string _master_timeout { get; set; }
		///<summary>Specify timeout for connection to master</summary>
		public PutTemplateRequestParameters MasterTimeout(string master_timeout)
		{
			this._master_timeout = master_timeout;
			this.AddQueryString("master_timeout", this._master_timeout);
			return this;
		}
		
		
		internal bool _flat_settings { get; set; }
		///<summary>Return settings in flat format (default: false)</summary>
		public PutTemplateRequestParameters FlatSettings(bool flat_settings)
		{
			this._flat_settings = flat_settings;
			this.AddQueryString("flat_settings", this._flat_settings);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for IndicesPutWarmerForAll
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html
	///</pre>
	///</summary>
	public class PutWarmerRequestParameters : FluentRequestParameters<PutWarmerRequestParameters> 
	{
		
		internal string _master_timeout { get; set; }
		///<summary>Specify timeout for connection to master</summary>
		public PutWarmerRequestParameters MasterTimeout(string master_timeout)
		{
			this._master_timeout = master_timeout;
			this.AddQueryString("master_timeout", this._master_timeout);
			return this;
		}
		
		
		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 PutWarmerRequestParameters IgnoreUnavailable(bool ignore_unavailable)
		{
			this._ignore_unavailable = ignore_unavailable;
			this.AddQueryString("ignore_unavailable", this._ignore_unavailable);
			return this;
		}
		
		
		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 PutWarmerRequestParameters AllowNoIndices(bool allow_no_indices)
		{
			this._allow_no_indices = allow_no_indices;
			this.AddQueryString("allow_no_indices", this._allow_no_indices);
			return this;
		}
		
		
		internal ExpandWildcards _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 PutWarmerRequestParameters ExpandWildcards(ExpandWildcards expand_wildcards)
		{
			this._expand_wildcards = expand_wildcards;
			this.AddQueryString("expand_wildcards", this._expand_wildcards);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for IndicesRecoveryForAll
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/indices-recovery.html
	///</pre>
	///</summary>
	public class IndicesRecoveryRequestParameters : FluentRequestParameters<IndicesRecoveryRequestParameters> 
	{
		
		internal bool _detailed { get; set; }
		///<summary>Whether to display detailed information about shard recovery</summary>
		public IndicesRecoveryRequestParameters Detailed(bool detailed)
		{
			this._detailed = detailed;
			this.AddQueryString("detailed", this._detailed);
			return this;
		}
		
		
		internal bool _active_only { get; set; }
		///<summary>Display only those recoveries that are currently on-going</summary>
		public IndicesRecoveryRequestParameters ActiveOnly(bool active_only)
		{
			this._active_only = active_only;
			this.AddQueryString("active_only", this._active_only);
			return this;
		}
		
		
		internal bool _human { get; set; }
		///<summary>Whether to return time and byte values in human-readable format.</summary>
		public IndicesRecoveryRequestParameters Human(bool human)
		{
			this._human = human;
			this.AddQueryString("human", this._human);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for IndicesRefreshForAll
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-refresh.html
	///</pre>
	///</summary>
	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 RefreshRequestParameters IgnoreUnavailable(bool ignore_unavailable)
		{
			this._ignore_unavailable = ignore_unavailable;
			this.AddQueryString("ignore_unavailable", this._ignore_unavailable);
			return this;
		}
		
		
		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 RefreshRequestParameters AllowNoIndices(bool allow_no_indices)
		{
			this._allow_no_indices = allow_no_indices;
			this.AddQueryString("allow_no_indices", this._allow_no_indices);
			return this;
		}
		
		
		internal ExpandWildcards _expand_wildcards { get; set; }
		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
		public RefreshRequestParameters ExpandWildcards(ExpandWildcards expand_wildcards)
		{
			this._expand_wildcards = expand_wildcards;
			this.AddQueryString("expand_wildcards", this._expand_wildcards);
			return this;
		}
		
		
		internal bool _force { get; set; }
		///<summary>Force a refresh even if not required</summary>
		public RefreshRequestParameters Force(bool force)
		{
			this._force = force;
			this.AddQueryString("force", this._force);
			return this;
		}
		
		
		internal string _operation_threading { get; set; }
		///<summary>TODO: ?</summary>
		public RefreshRequestParameters OperationThreading(string operation_threading)
		{
			this._operation_threading = operation_threading;
			this.AddQueryString("operation_threading", this._operation_threading);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for IndicesSegmentsForAll
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-segments.html
	///</pre>
	///</summary>
	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 SegmentsRequestParameters IgnoreUnavailable(bool ignore_unavailable)
		{
			this._ignore_unavailable = ignore_unavailable;
			this.AddQueryString("ignore_unavailable", this._ignore_unavailable);
			return this;
		}
		
		
		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 SegmentsRequestParameters AllowNoIndices(bool allow_no_indices)
		{
			this._allow_no_indices = allow_no_indices;
			this.AddQueryString("allow_no_indices", this._allow_no_indices);
			return this;
		}
		
		
		internal ExpandWildcards _expand_wildcards { get; set; }
		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
		public SegmentsRequestParameters ExpandWildcards(ExpandWildcards expand_wildcards)
		{
			this._expand_wildcards = expand_wildcards;
			this.AddQueryString("expand_wildcards", this._expand_wildcards);
			return this;
		}
		
		
		internal bool _human { get; set; }
		///<summary>Whether to return time and byte values in human-readable format.</summary>
		public SegmentsRequestParameters Human(bool human)
		{
			this._human = human;
			this.AddQueryString("human", this._human);
			return this;
		}
		
		
		internal string _operation_threading { get; set; }
		///<summary>TODO: ?</summary>
		public SegmentsRequestParameters OperationThreading(string operation_threading)
		{
			this._operation_threading = operation_threading;
			this.AddQueryString("operation_threading", this._operation_threading);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for IndicesStatsForAll
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-stats.html
	///</pre>
	///</summary>
	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 IndicesStatsRequestParameters CompletionFields(params string[] completion_fields)
		{
			this._completion_fields = completion_fields.Select(f=>(object)f);
			this.AddQueryString("completion_fields", this._completion_fields);
			return this;
		}
		
		
		internal IEnumerable<object> _fielddata_fields { get; set; }
		///<summary>A comma-separated list of fields for `fielddata` index metric (supports wildcards)</summary>
		public IndicesStatsRequestParameters FielddataFields(params string[] fielddata_fields)
		{
			this._fielddata_fields = fielddata_fields.Select(f=>(object)f);
			this.AddQueryString("fielddata_fields", this._fielddata_fields);
			return this;
		}
		
		
		internal IEnumerable<object> _fields { get; set; }
		///<summary>A comma-separated list of fields for `fielddata` and `completion` index metric (supports wildcards)</summary>
		public IndicesStatsRequestParameters Fields(params string[] fields)
		{
			this._fields = fields.Select(f=>(object)f);
			this.AddQueryString("fields", this._fields);
			return this;
		}
		
		
		internal  string[] _groups { get; set; }
		///<summary>A comma-separated list of search groups for `search` index metric</summary>
		public IndicesStatsRequestParameters Groups(params string[] groups)
		{
			this._groups = groups;
			this.AddQueryString("groups", this._groups);
			return this;
		}
		
		
		internal bool _human { get; set; }
		///<summary>Whether to return time and byte values in human-readable format.</summary>
		public IndicesStatsRequestParameters Human(bool human)
		{
			this._human = human;
			this.AddQueryString("human", this._human);
			return this;
		}
		
		
		internal Level _level { get; set; }
		///<summary>Return stats aggregated at cluster, index or shard level</summary>
		public IndicesStatsRequestParameters Level(Level level)
		{
			this._level = level;
			this.AddQueryString("level", this._level);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for IndicesStatusForAll
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-status.html
	///</pre>
	///</summary>
	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 IndicesStatusRequestParameters IgnoreUnavailable(bool ignore_unavailable)
		{
			this._ignore_unavailable = ignore_unavailable;
			this.AddQueryString("ignore_unavailable", this._ignore_unavailable);
			return this;
		}
		
		
		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 IndicesStatusRequestParameters AllowNoIndices(bool allow_no_indices)
		{
			this._allow_no_indices = allow_no_indices;
			this.AddQueryString("allow_no_indices", this._allow_no_indices);
			return this;
		}
		
		
		internal ExpandWildcards _expand_wildcards { get; set; }
		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
		public IndicesStatusRequestParameters ExpandWildcards(ExpandWildcards expand_wildcards)
		{
			this._expand_wildcards = expand_wildcards;
			this.AddQueryString("expand_wildcards", this._expand_wildcards);
			return this;
		}
		
		
		internal bool _human { get; set; }
		///<summary>Whether to return time and byte values in human-readable format.</summary>
		public IndicesStatusRequestParameters Human(bool human)
		{
			this._human = human;
			this.AddQueryString("human", this._human);
			return this;
		}
		
		
		internal string _operation_threading { get; set; }
		///<summary>TODO: ?</summary>
		public IndicesStatusRequestParameters OperationThreading(string operation_threading)
		{
			this._operation_threading = operation_threading;
			this.AddQueryString("operation_threading", this._operation_threading);
			return this;
		}
		
		
		internal bool _recovery { get; set; }
		///<summary>Return information about shard recovery</summary>
		public IndicesStatusRequestParameters Recovery(bool recovery)
		{
			this._recovery = recovery;
			this.AddQueryString("recovery", this._recovery);
			return this;
		}
		
		
		internal bool _snapshot { get; set; }
		///<summary>TODO: ?</summary>
		public IndicesStatusRequestParameters Snapshot(bool snapshot)
		{
			this._snapshot = snapshot;
			this.AddQueryString("snapshot", this._snapshot);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for IndicesUpdateAliasesForAll
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html
	///</pre>
	///</summary>
	public class AliasRequestParameters : FluentRequestParameters<AliasRequestParameters> 
	{
		
		internal string _timeout { get; set; }
		///<summary>Request timeout</summary>
		public AliasRequestParameters Timeout(string timeout)
		{
			this._timeout = timeout;
			this.AddQueryString("timeout", this._timeout);
			return this;
		}
		
		
		internal string _master_timeout { get; set; }
		///<summary>Specify timeout for connection to master</summary>
		public AliasRequestParameters MasterTimeout(string master_timeout)
		{
			this._master_timeout = master_timeout;
			this.AddQueryString("master_timeout", this._master_timeout);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for IndicesValidateQueryGetForAll
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html
	///</pre>
	///</summary>
	public class ValidateQueryRequestParameters : FluentRequestParameters<ValidateQueryRequestParameters> 
	{
		
		internal bool _explain { get; set; }
		///<summary>Return detailed information about the error</summary>
		public ValidateQueryRequestParameters Explain(bool explain)
		{
			this._explain = explain;
			this.AddQueryString("explain", this._explain);
			return this;
		}
		
		
		internal bool _ignore_unavailable { get; set; }
		///<summary>Whether specified concrete indices should be ignored when unavailable (missing or closed)</summary>
		public ValidateQueryRequestParameters IgnoreUnavailable(bool ignore_unavailable)
		{
			this._ignore_unavailable = ignore_unavailable;
			this.AddQueryString("ignore_unavailable", this._ignore_unavailable);
			return this;
		}
		
		
		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 ValidateQueryRequestParameters AllowNoIndices(bool allow_no_indices)
		{
			this._allow_no_indices = allow_no_indices;
			this.AddQueryString("allow_no_indices", this._allow_no_indices);
			return this;
		}
		
		
		internal ExpandWildcards _expand_wildcards { get; set; }
		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
		public ValidateQueryRequestParameters ExpandWildcards(ExpandWildcards expand_wildcards)
		{
			this._expand_wildcards = expand_wildcards;
			this.AddQueryString("expand_wildcards", this._expand_wildcards);
			return this;
		}
		
		
		internal string _operation_threading { get; set; }
		///<summary>TODO: ?</summary>
		public ValidateQueryRequestParameters OperationThreading(string operation_threading)
		{
			this._operation_threading = operation_threading;
			this.AddQueryString("operation_threading", this._operation_threading);
			return this;
		}
		
		
		internal string _source { get; set; }
		///<summary>The URL-encoded query definition (instead of using the request body)</summary>
		public ValidateQueryRequestParameters Source(string source)
		{
			this._source = source;
			this.AddQueryString("source", this._source);
			return this;
		}
		
		
		internal string _q { get; set; }
		///<summary>Query in the Lucene query string syntax</summary>
		public ValidateQueryRequestParameters Q(string q)
		{
			this._q = q;
			this.AddQueryString("q", this._q);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for Info
	///<pre>
	///http://www.elasticsearch.org/guide/
	///</pre>
	///</summary>
	public class InfoRequestParameters : FluentRequestParameters<InfoRequestParameters> 
	{
	}
	
	
	///<summary>Request parameters descriptor for ListBenchmarks
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-benchmark.html
	///</pre>
	///</summary>
	public class ListBenchmarksRequestParameters : FluentRequestParameters<ListBenchmarksRequestParameters> 
	{
	}
	
	
	///<summary>Request parameters descriptor for MgetGet
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-get.html
	///</pre>
	///</summary>
	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 MultiGetRequestParameters Fields(params string[] fields)
		{
			this._fields = fields.Select(f=>(object)f);
			this.AddQueryString("fields", this._fields);
			return this;
		}
		
		
		internal string _preference { get; set; }
		///<summary>Specify the node or shard the operation should be performed on (default: random)</summary>
		public MultiGetRequestParameters Preference(string preference)
		{
			this._preference = preference;
			this.AddQueryString("preference", this._preference);
			return this;
		}
		
		
		internal bool _realtime { get; set; }
		///<summary>Specify whether to perform the operation in realtime or search mode</summary>
		public MultiGetRequestParameters Realtime(bool realtime)
		{
			this._realtime = realtime;
			this.AddQueryString("realtime", this._realtime);
			return this;
		}
		
		
		internal bool _refresh { get; set; }
		///<summary>Refresh the shard containing the document before performing the operation</summary>
		public MultiGetRequestParameters Refresh(bool refresh)
		{
			this._refresh = refresh;
			this.AddQueryString("refresh", this._refresh);
			return this;
		}
		
		
		internal  string[] _source_enabled { get; set; }
		///<summary>True or false to return the _source field or not, or a list of fields to return</summary>
		public MultiGetRequestParameters SourceEnabled(params string[] source_enabled)
		{
			this._source_enabled = source_enabled;
			this.AddQueryString("_source", this._source_enabled);
			return this;
		}
		
		
		internal bool _enable_source { get; set; }
		///<summary>True or false to return the _source field or not, or a list of fields to return</summary>
		public MultiGetRequestParameters EnableSource(bool enable_source)
		{
			this._enable_source = enable_source;
			this.AddQueryString("_source", this._enable_source);
			return this;
		}
		
		
		internal IEnumerable<object> _source_exclude { get; set; }
		///<summary>A list of fields to exclude from the returned _source field</summary>
		public MultiGetRequestParameters SourceExclude(params string[] source_exclude)
		{
			this._source_exclude = source_exclude.Select(f=>(object)f);
			this.AddQueryString("_source_exclude", this._source_exclude);
			return this;
		}
		
		
		internal IEnumerable<object> _source_include { get; set; }
		///<summary>A list of fields to extract and return from the _source field</summary>
		public MultiGetRequestParameters SourceInclude(params string[] source_include)
		{
			this._source_include = source_include.Select(f=>(object)f);
			this.AddQueryString("_source_include", this._source_include);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for MltGet
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-more-like-this.html
	///</pre>
	///</summary>
	public class MoreLikeThisRequestParameters : FluentRequestParameters<MoreLikeThisRequestParameters> 
	{
		
		internal double _boost_terms { get; set; }
		///<summary>The boost factor</summary>
		public MoreLikeThisRequestParameters BoostTerms(double boost_terms)
		{
			this._boost_terms = boost_terms;
			this.AddQueryString("boost_terms", this._boost_terms);
			return this;
		}
		
		
		internal long _max_doc_freq { get; set; }
		///<summary>The word occurrence frequency as count: words with higher occurrence in the corpus will be ignored</summary>
		public MoreLikeThisRequestParameters MaxDocFreq(long max_doc_freq)
		{
			this._max_doc_freq = max_doc_freq;
			this.AddQueryString("max_doc_freq", this._max_doc_freq);
			return this;
		}
		
		
		internal long _max_query_terms { get; set; }
		///<summary>The maximum query terms to be included in the generated query</summary>
		public MoreLikeThisRequestParameters MaxQueryTerms(long max_query_terms)
		{
			this._max_query_terms = max_query_terms;
			this.AddQueryString("max_query_terms", this._max_query_terms);
			return this;
		}
		
		
		internal long _max_word_length { get; set; }
		///<summary>The minimum length of the word: longer words will be ignored</summary>
		public MoreLikeThisRequestParameters MaxWordLength(long max_word_length)
		{
			this._max_word_length = max_word_length;
			this.AddQueryString("max_word_length", this._max_word_length);
			return this;
		}
		
		
		internal long _min_doc_freq { get; set; }
		///<summary>The word occurrence frequency as count: words with lower occurrence in the corpus will be ignored</summary>
		public MoreLikeThisRequestParameters MinDocFreq(long min_doc_freq)
		{
			this._min_doc_freq = min_doc_freq;
			this.AddQueryString("min_doc_freq", this._min_doc_freq);
			return this;
		}
		
		
		internal long _min_term_freq { get; set; }
		///<summary>The term frequency as percent: terms with lower occurence in the source document will be ignored</summary>
		public MoreLikeThisRequestParameters MinTermFreq(long min_term_freq)
		{
			this._min_term_freq = min_term_freq;
			this.AddQueryString("min_term_freq", this._min_term_freq);
			return this;
		}
		
		
		internal long _min_word_length { get; set; }
		///<summary>The minimum length of the word: shorter words will be ignored</summary>
		public MoreLikeThisRequestParameters MinWordLength(long min_word_length)
		{
			this._min_word_length = min_word_length;
			this.AddQueryString("min_word_length", this._min_word_length);
			return this;
		}
		
		
		internal IEnumerable<object> _mlt_fields { get; set; }
		///<summary>Specific fields to perform the query against</summary>
		public MoreLikeThisRequestParameters MltFields(params string[] mlt_fields)
		{
			this._mlt_fields = mlt_fields.Select(f=>(object)f);
			this.AddQueryString("mlt_fields", this._mlt_fields);
			return this;
		}
		
		
		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 MoreLikeThisRequestParameters PercentTermsToMatch(double percent_terms_to_match)
		{
			this._percent_terms_to_match = percent_terms_to_match;
			this.AddQueryString("percent_terms_to_match", this._percent_terms_to_match);
			return this;
		}
		
		
		internal string _routing { get; set; }
		///<summary>Specific routing value</summary>
		public MoreLikeThisRequestParameters Routing(string routing)
		{
			this._routing = routing;
			this.AddQueryString("routing", this._routing);
			return this;
		}
		
		
		internal long _search_from { get; set; }
		///<summary>The offset from which to return results</summary>
		public MoreLikeThisRequestParameters SearchFrom(long search_from)
		{
			this._search_from = search_from;
			this.AddQueryString("search_from", this._search_from);
			return this;
		}
		
		
		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 MoreLikeThisRequestParameters SearchIndices(params string[] search_indices)
		{
			this._search_indices = search_indices;
			this.AddQueryString("search_indices", this._search_indices);
			return this;
		}
		
		
		internal string _search_query_hint { get; set; }
		///<summary>The search query hint</summary>
		public MoreLikeThisRequestParameters SearchQueryHint(string search_query_hint)
		{
			this._search_query_hint = search_query_hint;
			this.AddQueryString("search_query_hint", this._search_query_hint);
			return this;
		}
		
		
		internal string _search_scroll { get; set; }
		///<summary>A scroll search request definition</summary>
		public MoreLikeThisRequestParameters SearchScroll(string search_scroll)
		{
			this._search_scroll = search_scroll;
			this.AddQueryString("search_scroll", this._search_scroll);
			return this;
		}
		
		
		internal long _search_size { get; set; }
		///<summary>The number of documents to return (default: 10)</summary>
		public MoreLikeThisRequestParameters SearchSize(long search_size)
		{
			this._search_size = search_size;
			this.AddQueryString("search_size", this._search_size);
			return this;
		}
		
		
		internal string _search_source { get; set; }
		///<summary>A specific search request definition (instead of using the request body)</summary>
		public MoreLikeThisRequestParameters SearchSource(string search_source)
		{
			this._search_source = search_source;
			this.AddQueryString("search_source", this._search_source);
			return this;
		}
		
		
		internal string _search_type { get; set; }
		///<summary>Specific search type (eg. `dfs_then_fetch`, `count`, etc)</summary>
		public MoreLikeThisRequestParameters SearchType(string search_type)
		{
			this._search_type = search_type;
			this.AddQueryString("search_type", this._search_type);
			return this;
		}
		
		
		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 MoreLikeThisRequestParameters SearchTypes(params string[] search_types)
		{
			this._search_types = search_types;
			this.AddQueryString("search_types", this._search_types);
			return this;
		}
		
		
		internal  string[] _stop_words { get; set; }
		///<summary>A list of stop words to be ignored</summary>
		public MoreLikeThisRequestParameters StopWords(params string[] stop_words)
		{
			this._stop_words = stop_words;
			this.AddQueryString("stop_words", this._stop_words);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for MpercolateGet
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html
	///</pre>
	///</summary>
	public class MultiPercolateRequestParameters : FluentRequestParameters<MultiPercolateRequestParameters> 
	{
		
		internal bool _ignore_unavailable { get; set; }
		///<summary>Whether specified concrete indices should be ignored when unavailable (missing or closed)</summary>
		public MultiPercolateRequestParameters IgnoreUnavailable(bool ignore_unavailable)
		{
			this._ignore_unavailable = ignore_unavailable;
			this.AddQueryString("ignore_unavailable", this._ignore_unavailable);
			return this;
		}
		
		
		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 MultiPercolateRequestParameters AllowNoIndices(bool allow_no_indices)
		{
			this._allow_no_indices = allow_no_indices;
			this.AddQueryString("allow_no_indices", this._allow_no_indices);
			return this;
		}
		
		
		internal ExpandWildcards _expand_wildcards { get; set; }
		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
		public MultiPercolateRequestParameters ExpandWildcards(ExpandWildcards expand_wildcards)
		{
			this._expand_wildcards = expand_wildcards;
			this.AddQueryString("expand_wildcards", this._expand_wildcards);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for MsearchGet
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-multi-search.html
	///</pre>
	///</summary>
	public class MultiSearchRequestParameters : FluentRequestParameters<MultiSearchRequestParameters> 
	{
		
		internal SearchType _search_type { get; set; }
		///<summary>Search operation type</summary>
		public MultiSearchRequestParameters SearchType(SearchType search_type)
		{
			this._search_type = search_type;
			this.AddQueryString("search_type", this._search_type);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for MtermvectorsGet
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html
	///</pre>
	///</summary>
	public class MultiTermVectorsRequestParameters : FluentRequestParameters<MultiTermVectorsRequestParameters> 
	{
		
		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 MultiTermVectorsRequestParameters TermStatistics(bool term_statistics)
		{
			this._term_statistics = term_statistics;
			this.AddQueryString("term_statistics", this._term_statistics);
			return this;
		}
		
		
		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 MultiTermVectorsRequestParameters FieldStatistics(bool field_statistics)
		{
			this._field_statistics = field_statistics;
			this.AddQueryString("field_statistics", this._field_statistics);
			return this;
		}
		
		
		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 MultiTermVectorsRequestParameters Fields(params string[] fields)
		{
			this._fields = fields.Select(f=>(object)f);
			this.AddQueryString("fields", this._fields);
			return this;
		}
		
		
		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 MultiTermVectorsRequestParameters Offsets(bool offsets)
		{
			this._offsets = offsets;
			this.AddQueryString("offsets", this._offsets);
			return this;
		}
		
		
		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 MultiTermVectorsRequestParameters Positions(bool positions)
		{
			this._positions = positions;
			this.AddQueryString("positions", this._positions);
			return this;
		}
		
		
		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 MultiTermVectorsRequestParameters Payloads(bool payloads)
		{
			this._payloads = payloads;
			this.AddQueryString("payloads", this._payloads);
			return this;
		}
		
		
		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 MultiTermVectorsRequestParameters Preference(string preference)
		{
			this._preference = preference;
			this.AddQueryString("preference", this._preference);
			return this;
		}
		
		
		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 MultiTermVectorsRequestParameters Routing(string routing)
		{
			this._routing = routing;
			this.AddQueryString("routing", this._routing);
			return this;
		}
		
		
		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 MultiTermVectorsRequestParameters Parent(string parent)
		{
			this._parent = parent;
			this.AddQueryString("parent", this._parent);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for NodesHotThreadsForAll
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-hot-threads.html
	///</pre>
	///</summary>
	public class NodesHotThreadsRequestParameters : FluentRequestParameters<NodesHotThreadsRequestParameters> 
	{
		
		internal string _interval { get; set; }
		///<summary>The interval for the second sampling of threads</summary>
		public NodesHotThreadsRequestParameters Interval(string interval)
		{
			this._interval = interval;
			this.AddQueryString("interval", this._interval);
			return this;
		}
		
		
		internal long _snapshots { get; set; }
		///<summary>Number of samples of thread stacktrace (default: 10)</summary>
		public NodesHotThreadsRequestParameters Snapshots(long snapshots)
		{
			this._snapshots = snapshots;
			this.AddQueryString("snapshots", this._snapshots);
			return this;
		}
		
		
		internal long _threads { get; set; }
		///<summary>Specify the number of threads to provide information for (default: 3)</summary>
		public NodesHotThreadsRequestParameters Threads(long threads)
		{
			this._threads = threads;
			this.AddQueryString("threads", this._threads);
			return this;
		}
		
		
		internal ThreadType _thread_type { get; set; }
		///<summary>The type to sample (default: cpu)</summary>
		public NodesHotThreadsRequestParameters ThreadType(ThreadType thread_type)
		{
			this._thread_type = thread_type;
			this.AddQueryString("type", this._thread_type);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for NodesInfoForAll
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-info.html
	///</pre>
	///</summary>
	public class NodesInfoRequestParameters : FluentRequestParameters<NodesInfoRequestParameters> 
	{
		
		internal bool _flat_settings { get; set; }
		///<summary>Return settings in flat format (default: false)</summary>
		public NodesInfoRequestParameters FlatSettings(bool flat_settings)
		{
			this._flat_settings = flat_settings;
			this.AddQueryString("flat_settings", this._flat_settings);
			return this;
		}
		
		
		internal bool _human { get; set; }
		///<summary>Whether to return time and byte values in human-readable format.</summary>
		public NodesInfoRequestParameters Human(bool human)
		{
			this._human = human;
			this.AddQueryString("human", this._human);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for NodesShutdownForAll
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-shutdown.html
	///</pre>
	///</summary>
	public class NodesShutdownRequestParameters : FluentRequestParameters<NodesShutdownRequestParameters> 
	{
		
		internal string _delay { get; set; }
		///<summary>Set the delay for the operation (default: 1s)</summary>
		public NodesShutdownRequestParameters Delay(string delay)
		{
			this._delay = delay;
			this.AddQueryString("delay", this._delay);
			return this;
		}
		
		
		internal bool _exit { get; set; }
		///<summary>Exit the JVM as well (default: true)</summary>
		public NodesShutdownRequestParameters Exit(bool exit)
		{
			this._exit = exit;
			this.AddQueryString("exit", this._exit);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for NodesStatsForAll
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-stats.html
	///</pre>
	///</summary>
	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 NodesStatsRequestParameters CompletionFields(params string[] completion_fields)
		{
			this._completion_fields = completion_fields.Select(f=>(object)f);
			this.AddQueryString("completion_fields", this._completion_fields);
			return this;
		}
		
		
		internal IEnumerable<object> _fielddata_fields { get; set; }
		///<summary>A comma-separated list of fields for `fielddata` index metric (supports wildcards)</summary>
		public NodesStatsRequestParameters FielddataFields(params string[] fielddata_fields)
		{
			this._fielddata_fields = fielddata_fields.Select(f=>(object)f);
			this.AddQueryString("fielddata_fields", this._fielddata_fields);
			return this;
		}
		
		
		internal IEnumerable<object> _fields { get; set; }
		///<summary>A comma-separated list of fields for `fielddata` and `completion` index metric (supports wildcards)</summary>
		public NodesStatsRequestParameters Fields(params string[] fields)
		{
			this._fields = fields.Select(f=>(object)f);
			this.AddQueryString("fields", this._fields);
			return this;
		}
		
		
		internal bool _groups { get; set; }
		///<summary>A comma-separated list of search groups for `search` index metric</summary>
		public NodesStatsRequestParameters Groups(bool groups)
		{
			this._groups = groups;
			this.AddQueryString("groups", this._groups);
			return this;
		}
		
		
		internal bool _human { get; set; }
		///<summary>Whether to return time and byte values in human-readable format.</summary>
		public NodesStatsRequestParameters Human(bool human)
		{
			this._human = human;
			this.AddQueryString("human", this._human);
			return this;
		}
		
		
		internal Level _level { get; set; }
		///<summary>Return indices stats aggregated at node, index or shard level</summary>
		public NodesStatsRequestParameters Level(Level level)
		{
			this._level = level;
			this.AddQueryString("level", this._level);
			return this;
		}
		
		
		internal  string[] _types { get; set; }
		///<summary>A comma-separated list of document types for the `indexing` index metric</summary>
		public NodesStatsRequestParameters Types(params string[] types)
		{
			this._types = types;
			this.AddQueryString("types", this._types);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for PercolateGet
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html
	///</pre>
	///</summary>
	public class PercolateRequestParameters : FluentRequestParameters<PercolateRequestParameters> 
	{
		
		internal  string[] _routing { get; set; }
		///<summary>A comma-separated list of specific routing values</summary>
		public PercolateRequestParameters Routing(params string[] routing)
		{
			this._routing = routing;
			this.AddQueryString("routing", this._routing);
			return this;
		}
		
		
		internal string _preference { get; set; }
		///<summary>Specify the node or shard the operation should be performed on (default: random)</summary>
		public PercolateRequestParameters Preference(string preference)
		{
			this._preference = preference;
			this.AddQueryString("preference", this._preference);
			return this;
		}
		
		
		internal bool _ignore_unavailable { get; set; }
		///<summary>Whether specified concrete indices should be ignored when unavailable (missing or closed)</summary>
		public PercolateRequestParameters IgnoreUnavailable(bool ignore_unavailable)
		{
			this._ignore_unavailable = ignore_unavailable;
			this.AddQueryString("ignore_unavailable", this._ignore_unavailable);
			return this;
		}
		
		
		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 PercolateRequestParameters AllowNoIndices(bool allow_no_indices)
		{
			this._allow_no_indices = allow_no_indices;
			this.AddQueryString("allow_no_indices", this._allow_no_indices);
			return this;
		}
		
		
		internal ExpandWildcards _expand_wildcards { get; set; }
		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
		public PercolateRequestParameters ExpandWildcards(ExpandWildcards expand_wildcards)
		{
			this._expand_wildcards = expand_wildcards;
			this.AddQueryString("expand_wildcards", this._expand_wildcards);
			return this;
		}
		
		
		internal string _percolate_index { get; set; }
		///<summary>The index to percolate the document into. Defaults to index.</summary>
		public PercolateRequestParameters PercolateIndex(string percolate_index)
		{
			this._percolate_index = percolate_index;
			this.AddQueryString("percolate_index", this._percolate_index);
			return this;
		}
		
		
		internal string _percolate_type { get; set; }
		///<summary>The type to percolate document into. Defaults to type.</summary>
		public PercolateRequestParameters PercolateType(string percolate_type)
		{
			this._percolate_type = percolate_type;
			this.AddQueryString("percolate_type", this._percolate_type);
			return this;
		}
		
		
		internal long _version { get; set; }
		///<summary>Explicit version number for concurrency control</summary>
		public PercolateRequestParameters Version(long version)
		{
			this._version = version;
			this.AddQueryString("version", this._version);
			return this;
		}
		
		
		internal VersionType _version_type { get; set; }
		///<summary>Specific version type</summary>
		public PercolateRequestParameters VersionType(VersionType version_type)
		{
			this._version_type = version_type;
			this.AddQueryString("version_type", this._version_type);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for Ping
	///<pre>
	///http://www.elasticsearch.org/guide/
	///</pre>
	///</summary>
	public class PingRequestParameters : FluentRequestParameters<PingRequestParameters> 
	{
	}
	
	
	///<summary>Request parameters descriptor for PutScript
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html
	///</pre>
	///</summary>
	public class PutScriptRequestParameters : FluentRequestParameters<PutScriptRequestParameters> 
	{
	}
	
	
	///<summary>Request parameters descriptor for ScrollGet
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html
	///</pre>
	///</summary>
	public class ScrollRequestParameters : FluentRequestParameters<ScrollRequestParameters> 
	{
	}
	
	
	///<summary>Request parameters descriptor for SearchGet
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html
	///</pre>
	///</summary>
	public class SearchRequestParameters : FluentRequestParameters<SearchRequestParameters> 
	{
		
		internal string _analyzer { get; set; }
		///<summary>The analyzer to use for the query string</summary>
		public SearchRequestParameters Analyzer(string analyzer)
		{
			this._analyzer = analyzer;
			this.AddQueryString("analyzer", this._analyzer);
			return this;
		}
		
		
		internal bool _analyze_wildcard { get; set; }
		///<summary>Specify whether wildcard and prefix queries should be analyzed (default: false)</summary>
		public SearchRequestParameters AnalyzeWildcard(bool analyze_wildcard)
		{
			this._analyze_wildcard = analyze_wildcard;
			this.AddQueryString("analyze_wildcard", this._analyze_wildcard);
			return this;
		}
		
		
		internal DefaultOperator _default_operator { get; set; }
		///<summary>The default operator for query string query (AND or OR)</summary>
		public SearchRequestParameters DefaultOperator(DefaultOperator default_operator)
		{
			this._default_operator = default_operator;
			this.AddQueryString("default_operator", this._default_operator);
			return this;
		}
		
		
		internal string _df { get; set; }
		///<summary>The field to use as default where no field prefix is given in the query string</summary>
		public SearchRequestParameters Df(string df)
		{
			this._df = df;
			this.AddQueryString("df", this._df);
			return this;
		}
		
		
		internal bool _ignore_unavailable { get; set; }
		///<summary>Whether specified concrete indices should be ignored when unavailable (missing or closed)</summary>
		public SearchRequestParameters IgnoreUnavailable(bool ignore_unavailable)
		{
			this._ignore_unavailable = ignore_unavailable;
			this.AddQueryString("ignore_unavailable", this._ignore_unavailable);
			return this;
		}
		
		
		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 SearchRequestParameters AllowNoIndices(bool allow_no_indices)
		{
			this._allow_no_indices = allow_no_indices;
			this.AddQueryString("allow_no_indices", this._allow_no_indices);
			return this;
		}
		
		
		internal ExpandWildcards _expand_wildcards { get; set; }
		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
		public SearchRequestParameters ExpandWildcards(ExpandWildcards expand_wildcards)
		{
			this._expand_wildcards = expand_wildcards;
			this.AddQueryString("expand_wildcards", this._expand_wildcards);
			return this;
		}
		
		
		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 SearchRequestParameters Lenient(bool lenient)
		{
			this._lenient = lenient;
			this.AddQueryString("lenient", this._lenient);
			return this;
		}
		
		
		internal bool _lowercase_expanded_terms { get; set; }
		///<summary>Specify whether query terms should be lowercased</summary>
		public SearchRequestParameters LowercaseExpandedTerms(bool lowercase_expanded_terms)
		{
			this._lowercase_expanded_terms = lowercase_expanded_terms;
			this.AddQueryString("lowercase_expanded_terms", this._lowercase_expanded_terms);
			return this;
		}
		
		
		internal string _preference { get; set; }
		///<summary>Specify the node or shard the operation should be performed on (default: random)</summary>
		public SearchRequestParameters Preference(string preference)
		{
			this._preference = preference;
			this.AddQueryString("preference", this._preference);
			return this;
		}
		
		
		internal  string[] _routing { get; set; }
		///<summary>A comma-separated list of specific routing values</summary>
		public SearchRequestParameters Routing(params string[] routing)
		{
			this._routing = routing;
			this.AddQueryString("routing", this._routing);
			return this;
		}
		
		
		internal string _scroll { get; set; }
		///<summary>Specify how long a consistent view of the index should be maintained for scrolled search</summary>
		public SearchRequestParameters Scroll(string scroll)
		{
			this._scroll = scroll;
			this.AddQueryString("scroll", this._scroll);
			return this;
		}
		
		
		internal SearchType _search_type { get; set; }
		///<summary>Search operation type</summary>
		public SearchRequestParameters SearchType(SearchType search_type)
		{
			this._search_type = search_type;
			this.AddQueryString("search_type", this._search_type);
			return this;
		}
		
		
		internal  string[] _stats { get; set; }
		///<summary>Specific &#39;tag&#39; of the request for logging and statistical purposes</summary>
		public SearchRequestParameters Stats(params string[] stats)
		{
			this._stats = stats;
			this.AddQueryString("stats", this._stats);
			return this;
		}
		
		
		internal object _suggest_field { get; set; }
		///<summary>Specify which field to use for suggestions</summary>
		public SearchRequestParameters SuggestField(string suggest_field)
		{
			this._suggest_field = suggest_field;
			this.AddQueryString("suggest_field", this._suggest_field);
			return this;
		}
		
		
		internal SuggestMode _suggest_mode { get; set; }
		///<summary>Specify suggest mode</summary>
		public SearchRequestParameters SuggestMode(SuggestMode suggest_mode)
		{
			this._suggest_mode = suggest_mode;
			this.AddQueryString("suggest_mode", this._suggest_mode);
			return this;
		}
		
		
		internal long _suggest_size { get; set; }
		///<summary>How many suggestions to return in response</summary>
		public SearchRequestParameters SuggestSize(long suggest_size)
		{
			this._suggest_size = suggest_size;
			this.AddQueryString("suggest_size", this._suggest_size);
			return this;
		}
		
		
		internal string _suggest_text { get; set; }
		///<summary>The source text for which the suggestions should be returned</summary>
		public SearchRequestParameters SuggestText(string suggest_text)
		{
			this._suggest_text = suggest_text;
			this.AddQueryString("suggest_text", this._suggest_text);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for SearchShardsGet
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-shards.html
	///</pre>
	///</summary>
	public class SearchShardsRequestParameters : FluentRequestParameters<SearchShardsRequestParameters> 
	{
		
		internal string _preference { get; set; }
		///<summary>Specify the node or shard the operation should be performed on (default: random)</summary>
		public SearchShardsRequestParameters Preference(string preference)
		{
			this._preference = preference;
			this.AddQueryString("preference", this._preference);
			return this;
		}
		
		
		internal string _routing { get; set; }
		///<summary>Specific routing value</summary>
		public SearchShardsRequestParameters Routing(string routing)
		{
			this._routing = routing;
			this.AddQueryString("routing", this._routing);
			return this;
		}
		
		
		internal bool _local { get; set; }
		///<summary>Return local information, do not retrieve the state from master node (default: false)</summary>
		public SearchShardsRequestParameters Local(bool local)
		{
			this._local = local;
			this.AddQueryString("local", this._local);
			return this;
		}
		
		
		internal bool _ignore_unavailable { get; set; }
		///<summary>Whether specified concrete indices should be ignored when unavailable (missing or closed)</summary>
		public SearchShardsRequestParameters IgnoreUnavailable(bool ignore_unavailable)
		{
			this._ignore_unavailable = ignore_unavailable;
			this.AddQueryString("ignore_unavailable", this._ignore_unavailable);
			return this;
		}
		
		
		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 SearchShardsRequestParameters AllowNoIndices(bool allow_no_indices)
		{
			this._allow_no_indices = allow_no_indices;
			this.AddQueryString("allow_no_indices", this._allow_no_indices);
			return this;
		}
		
		
		internal ExpandWildcards _expand_wildcards { get; set; }
		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
		public SearchShardsRequestParameters ExpandWildcards(ExpandWildcards expand_wildcards)
		{
			this._expand_wildcards = expand_wildcards;
			this.AddQueryString("expand_wildcards", this._expand_wildcards);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for SearchTemplateGet
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-template.html
	///</pre>
	///</summary>
	public class SearchTemplateRequestParameters : FluentRequestParameters<SearchTemplateRequestParameters> 
	{
		
		internal bool _ignore_unavailable { get; set; }
		///<summary>Whether specified concrete indices should be ignored when unavailable (missing or closed)</summary>
		public SearchTemplateRequestParameters IgnoreUnavailable(bool ignore_unavailable)
		{
			this._ignore_unavailable = ignore_unavailable;
			this.AddQueryString("ignore_unavailable", this._ignore_unavailable);
			return this;
		}
		
		
		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 SearchTemplateRequestParameters AllowNoIndices(bool allow_no_indices)
		{
			this._allow_no_indices = allow_no_indices;
			this.AddQueryString("allow_no_indices", this._allow_no_indices);
			return this;
		}
		
		
		internal ExpandWildcards _expand_wildcards { get; set; }
		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
		public SearchTemplateRequestParameters ExpandWildcards(ExpandWildcards expand_wildcards)
		{
			this._expand_wildcards = expand_wildcards;
			this.AddQueryString("expand_wildcards", this._expand_wildcards);
			return this;
		}
		
		
		internal string _preference { get; set; }
		///<summary>Specify the node or shard the operation should be performed on (default: random)</summary>
		public SearchTemplateRequestParameters Preference(string preference)
		{
			this._preference = preference;
			this.AddQueryString("preference", this._preference);
			return this;
		}
		
		
		internal  string[] _routing { get; set; }
		///<summary>A comma-separated list of specific routing values</summary>
		public SearchTemplateRequestParameters Routing(params string[] routing)
		{
			this._routing = routing;
			this.AddQueryString("routing", this._routing);
			return this;
		}
		
		
		internal string _scroll { get; set; }
		///<summary>Specify how long a consistent view of the index should be maintained for scrolled search</summary>
		public SearchTemplateRequestParameters Scroll(string scroll)
		{
			this._scroll = scroll;
			this.AddQueryString("scroll", this._scroll);
			return this;
		}
		
		
		internal SearchType _search_type { get; set; }
		///<summary>Search operation type</summary>
		public SearchTemplateRequestParameters SearchType(SearchType search_type)
		{
			this._search_type = search_type;
			this.AddQueryString("search_type", this._search_type);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for SnapshotCreate
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html
	///</pre>
	///</summary>
	public class SnapshotRequestParameters : FluentRequestParameters<SnapshotRequestParameters> 
	{
		
		internal string _master_timeout { get; set; }
		///<summary>Explicit operation timeout for connection to master node</summary>
		public SnapshotRequestParameters MasterTimeout(string master_timeout)
		{
			this._master_timeout = master_timeout;
			this.AddQueryString("master_timeout", this._master_timeout);
			return this;
		}
		
		
		internal bool _wait_for_completion { get; set; }
		///<summary>Should this request wait until the operation has completed before returning</summary>
		public SnapshotRequestParameters WaitForCompletion(bool wait_for_completion)
		{
			this._wait_for_completion = wait_for_completion;
			this.AddQueryString("wait_for_completion", this._wait_for_completion);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for SnapshotCreateRepository
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html
	///</pre>
	///</summary>
	public class CreateRepositoryRequestParameters : FluentRequestParameters<CreateRepositoryRequestParameters> 
	{
		
		internal string _master_timeout { get; set; }
		///<summary>Explicit operation timeout for connection to master node</summary>
		public CreateRepositoryRequestParameters MasterTimeout(string master_timeout)
		{
			this._master_timeout = master_timeout;
			this.AddQueryString("master_timeout", this._master_timeout);
			return this;
		}
		
		
		internal string _timeout { get; set; }
		///<summary>Explicit operation timeout</summary>
		public CreateRepositoryRequestParameters Timeout(string timeout)
		{
			this._timeout = timeout;
			this.AddQueryString("timeout", this._timeout);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for SnapshotDelete
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html
	///</pre>
	///</summary>
	public class DeleteSnapshotRequestParameters : FluentRequestParameters<DeleteSnapshotRequestParameters> 
	{
		
		internal string _master_timeout { get; set; }
		///<summary>Explicit operation timeout for connection to master node</summary>
		public DeleteSnapshotRequestParameters MasterTimeout(string master_timeout)
		{
			this._master_timeout = master_timeout;
			this.AddQueryString("master_timeout", this._master_timeout);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for SnapshotDeleteRepository
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html
	///</pre>
	///</summary>
	public class DeleteRepositoryRequestParameters : FluentRequestParameters<DeleteRepositoryRequestParameters> 
	{
		
		internal string _master_timeout { get; set; }
		///<summary>Explicit operation timeout for connection to master node</summary>
		public DeleteRepositoryRequestParameters MasterTimeout(string master_timeout)
		{
			this._master_timeout = master_timeout;
			this.AddQueryString("master_timeout", this._master_timeout);
			return this;
		}
		
		
		internal string _timeout { get; set; }
		///<summary>Explicit operation timeout</summary>
		public DeleteRepositoryRequestParameters Timeout(string timeout)
		{
			this._timeout = timeout;
			this.AddQueryString("timeout", this._timeout);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for SnapshotGet
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html
	///</pre>
	///</summary>
	public class GetSnapshotRequestParameters : FluentRequestParameters<GetSnapshotRequestParameters> 
	{
		
		internal string _master_timeout { get; set; }
		///<summary>Explicit operation timeout for connection to master node</summary>
		public GetSnapshotRequestParameters MasterTimeout(string master_timeout)
		{
			this._master_timeout = master_timeout;
			this.AddQueryString("master_timeout", this._master_timeout);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for SnapshotGetRepository
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html
	///</pre>
	///</summary>
	public class SnapshotGetRepositoryRequestParameters : FluentRequestParameters<SnapshotGetRepositoryRequestParameters> 
	{
		
		internal string _master_timeout { get; set; }
		///<summary>Explicit operation timeout for connection to master node</summary>
		public SnapshotGetRepositoryRequestParameters MasterTimeout(string master_timeout)
		{
			this._master_timeout = master_timeout;
			this.AddQueryString("master_timeout", this._master_timeout);
			return this;
		}
		
		
		internal bool _local { get; set; }
		///<summary>Return local information, do not retrieve the state from master node (default: false)</summary>
		public SnapshotGetRepositoryRequestParameters Local(bool local)
		{
			this._local = local;
			this.AddQueryString("local", this._local);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for SnapshotRestore
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html
	///</pre>
	///</summary>
	public class RestoreRequestParameters : FluentRequestParameters<RestoreRequestParameters> 
	{
		
		internal string _master_timeout { get; set; }
		///<summary>Explicit operation timeout for connection to master node</summary>
		public RestoreRequestParameters MasterTimeout(string master_timeout)
		{
			this._master_timeout = master_timeout;
			this.AddQueryString("master_timeout", this._master_timeout);
			return this;
		}
		
		
		internal bool _wait_for_completion { get; set; }
		///<summary>Should this request wait until the operation has completed before returning</summary>
		public RestoreRequestParameters WaitForCompletion(bool wait_for_completion)
		{
			this._wait_for_completion = wait_for_completion;
			this.AddQueryString("wait_for_completion", this._wait_for_completion);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for SnapshotStatus
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-snapshots.html
	///</pre>
	///</summary>
	public class SnapshotStatusRequestParameters : FluentRequestParameters<SnapshotStatusRequestParameters> 
	{
		
		internal string _master_timeout { get; set; }
		///<summary>Explicit operation timeout for connection to master node</summary>
		public SnapshotStatusRequestParameters MasterTimeout(string master_timeout)
		{
			this._master_timeout = master_timeout;
			this.AddQueryString("master_timeout", this._master_timeout);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for Suggest
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html
	///</pre>
	///</summary>
	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 SuggestRequestParameters IgnoreUnavailable(bool ignore_unavailable)
		{
			this._ignore_unavailable = ignore_unavailable;
			this.AddQueryString("ignore_unavailable", this._ignore_unavailable);
			return this;
		}
		
		
		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 SuggestRequestParameters AllowNoIndices(bool allow_no_indices)
		{
			this._allow_no_indices = allow_no_indices;
			this.AddQueryString("allow_no_indices", this._allow_no_indices);
			return this;
		}
		
		
		internal ExpandWildcards _expand_wildcards { get; set; }
		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
		public SuggestRequestParameters ExpandWildcards(ExpandWildcards expand_wildcards)
		{
			this._expand_wildcards = expand_wildcards;
			this.AddQueryString("expand_wildcards", this._expand_wildcards);
			return this;
		}
		
		
		internal string _preference { get; set; }
		///<summary>Specify the node or shard the operation should be performed on (default: random)</summary>
		public SuggestRequestParameters Preference(string preference)
		{
			this._preference = preference;
			this.AddQueryString("preference", this._preference);
			return this;
		}
		
		
		internal string _routing { get; set; }
		///<summary>Specific routing value</summary>
		public SuggestRequestParameters Routing(string routing)
		{
			this._routing = routing;
			this.AddQueryString("routing", this._routing);
			return this;
		}
		
		
		internal string _source { get; set; }
		///<summary>The URL-encoded request definition (instead of using request body)</summary>
		public SuggestRequestParameters Source(string source)
		{
			this._source = source;
			this.AddQueryString("source", this._source);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for TermvectorGet
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-termvectors.html
	///</pre>
	///</summary>
	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 TermvectorRequestParameters TermStatistics(bool term_statistics)
		{
			this._term_statistics = term_statistics;
			this.AddQueryString("term_statistics", this._term_statistics);
			return this;
		}
		
		
		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 TermvectorRequestParameters FieldStatistics(bool field_statistics)
		{
			this._field_statistics = field_statistics;
			this.AddQueryString("field_statistics", this._field_statistics);
			return this;
		}
		
		
		internal IEnumerable<object> _fields { get; set; }
		///<summary>A comma-separated list of fields to return.</summary>
		public TermvectorRequestParameters Fields(params string[] fields)
		{
			this._fields = fields.Select(f=>(object)f);
			this.AddQueryString("fields", this._fields);
			return this;
		}
		
		
		internal bool _offsets { get; set; }
		///<summary>Specifies if term offsets should be returned.</summary>
		public TermvectorRequestParameters Offsets(bool offsets)
		{
			this._offsets = offsets;
			this.AddQueryString("offsets", this._offsets);
			return this;
		}
		
		
		internal bool _positions { get; set; }
		///<summary>Specifies if term positions should be returned.</summary>
		public TermvectorRequestParameters Positions(bool positions)
		{
			this._positions = positions;
			this.AddQueryString("positions", this._positions);
			return this;
		}
		
		
		internal bool _payloads { get; set; }
		///<summary>Specifies if term payloads should be returned.</summary>
		public TermvectorRequestParameters Payloads(bool payloads)
		{
			this._payloads = payloads;
			this.AddQueryString("payloads", this._payloads);
			return this;
		}
		
		
		internal string _preference { get; set; }
		///<summary>Specify the node or shard the operation should be performed on (default: random).</summary>
		public TermvectorRequestParameters Preference(string preference)
		{
			this._preference = preference;
			this.AddQueryString("preference", this._preference);
			return this;
		}
		
		
		internal string _routing { get; set; }
		///<summary>Specific routing value.</summary>
		public TermvectorRequestParameters Routing(string routing)
		{
			this._routing = routing;
			this.AddQueryString("routing", this._routing);
			return this;
		}
		
		
		internal string _parent { get; set; }
		///<summary>Parent id of documents.</summary>
		public TermvectorRequestParameters Parent(string parent)
		{
			this._parent = parent;
			this.AddQueryString("parent", this._parent);
			return this;
		}
		
	}
	
	
	///<summary>Request parameters descriptor for Update
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-update.html
	///</pre>
	///</summary>
	public class UpdateRequestParameters : FluentRequestParameters<UpdateRequestParameters> 
	{
		
		internal Consistency _consistency { get; set; }
		///<summary>Explicit write consistency setting for the operation</summary>
		public UpdateRequestParameters Consistency(Consistency consistency)
		{
			this._consistency = consistency;
			this.AddQueryString("consistency", this._consistency);
			return this;
		}
		
		
		internal string _lang { get; set; }
		///<summary>The script language (default: mvel)</summary>
		public UpdateRequestParameters Lang(string lang)
		{
			this._lang = lang;
			this.AddQueryString("lang", this._lang);
			return this;
		}
		
		
		internal string _parent { get; set; }
		///<summary>ID of the parent document</summary>
		public UpdateRequestParameters Parent(string parent)
		{
			this._parent = parent;
			this.AddQueryString("parent", this._parent);
			return this;
		}
		
		
		internal bool _refresh { get; set; }
		///<summary>Refresh the index after performing the operation</summary>
		public UpdateRequestParameters Refresh(bool refresh)
		{
			this._refresh = refresh;
			this.AddQueryString("refresh", this._refresh);
			return this;
		}
		
		
		internal Replication _replication { get; set; }
		///<summary>Specific replication type</summary>
		public UpdateRequestParameters Replication(Replication replication)
		{
			this._replication = replication;
			this.AddQueryString("replication", this._replication);
			return this;
		}
		
		
		internal long _retry_on_conflict { get; set; }
		///<summary>Specify how many times should the operation be retried when a conflict occurs (default: 0)</summary>
		public UpdateRequestParameters RetryOnConflict(long retry_on_conflict)
		{
			this._retry_on_conflict = retry_on_conflict;
			this.AddQueryString("retry_on_conflict", this._retry_on_conflict);
			return this;
		}
		
		
		internal string _routing { get; set; }
		///<summary>Specific routing value</summary>
		public UpdateRequestParameters Routing(string routing)
		{
			this._routing = routing;
			this.AddQueryString("routing", this._routing);
			return this;
		}
		
		
		internal string _script { get; set; }
		///<summary>The URL-encoded script definition (instead of using request body)</summary>
		public UpdateRequestParameters Script(string script)
		{
			this._script = script;
			this.AddQueryString("script", this._script);
			return this;
		}
		
		
		internal string _timeout { get; set; }
		///<summary>Explicit operation timeout</summary>
		public UpdateRequestParameters Timeout(string timeout)
		{
			this._timeout = timeout;
			this.AddQueryString("timeout", this._timeout);
			return this;
		}
		
		
		internal string _timestamp { get; set; }
		///<summary>Explicit timestamp for the document</summary>
		public UpdateRequestParameters Timestamp(string timestamp)
		{
			this._timestamp = timestamp;
			this.AddQueryString("timestamp", this._timestamp);
			return this;
		}
		
		
		internal string _ttl { get; set; }
		///<summary>Expiration time for the document</summary>
		public UpdateRequestParameters Ttl(string ttl)
		{
			this._ttl = ttl;
			this.AddQueryString("ttl", this._ttl);
			return this;
		}
		
		
		internal long _version { get; set; }
		///<summary>Explicit version number for concurrency control</summary>
		public UpdateRequestParameters Version(long version)
		{
			this._version = version;
			this.AddQueryString("version", this._version);
			return this;
		}
		
		
		internal VersionType _version_type { get; set; }
		///<summary>Specific version type</summary>
		public UpdateRequestParameters VersionType(VersionType version_type)
		{
			this._version_type = version_type;
			this.AddQueryString("version_type", this._version_type);
			return this;
		}
		
	}
	
	
}