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>Query string 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 ConsistencyOptions _consistency { get; set; }
		///<summary>Explicit write consistency setting for the operation</summary>
		public BulkRequestParameters Consistency(ConsistencyOptions 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 ReplicationOptions _replication { get; set; }
		///<summary>Explicitely set the replication type</summary>
		public BulkRequestParameters Replication(ReplicationOptions 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>Query string 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>Query string 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 BytesOptions _bytes { get; set; }
		///<summary>The unit in which to display byte values</summary>
		public CatAllocationRequestParameters Bytes(BytesOptions 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>Query string 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>Query string 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>Query string 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>Query string 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 BytesOptions _bytes { get; set; }
		///<summary>The unit in which to display byte values</summary>
		public CatIndicesRequestParameters Bytes(BytesOptions 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>Query string 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>Query string 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>Query string 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>Query string 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>Query string 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 BytesOptions _bytes { get; set; }
		///<summary>The unit in which to display byte values</summary>
		public CatRecoveryRequestParameters Bytes(BytesOptions 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>Query string 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>Query string 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>Query string 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>Query string 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>Query string 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 LevelOptions _level { get; set; }
		///<summary>Specify the level of detail for returned information</summary>
		public ClusterHealthRequestParameters Level(LevelOptions 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 int _wait_for_active_shards { get; set; }
		///<summary>Wait until the specified number of shards is active</summary>
		public ClusterHealthRequestParameters WaitForActiveShards(int 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 int _wait_for_relocating_shards { get; set; }
		///<summary>Wait until the specified number of relocating shards is finished</summary>
		public ClusterHealthRequestParameters WaitForRelocatingShards(int 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 WaitForStatusOptions _wait_for_status { get; set; }
		///<summary>Wait until cluster is in a specific state</summary>
		public ClusterHealthRequestParameters WaitForStatus(WaitForStatusOptions wait_for_status)
		{
			this._wait_for_status = wait_for_status;
			this.AddQueryString("wait_for_status", this._wait_for_status);
			return this;
		}
		
	}
	
	
	///<summary>Query string 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>Query string descriptor for ClusterPutSettings
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-update-settings.html
	///</pre>
	///</summary>
	public class ClusterPutSettingsRequestParameters : FluentRequestParameters<ClusterPutSettingsRequestParameters> 
	{
		
		internal bool _flat_settings { get; set; }
		///<summary>Return settings in flat format (default: false)</summary>
		public ClusterPutSettingsRequestParameters FlatSettings(bool flat_settings)
		{
			this._flat_settings = flat_settings;
			this.AddQueryString("flat_settings", this._flat_settings);
			return this;
		}
		
	}
	
	
	///<summary>Query string 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>Query string 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  string[] _index_templates { get; set; }
		///<summary>A comma separated list to return specific index templates when returning metadata</summary>
		public ClusterStateRequestParameters IndexTemplates(params string[] index_templates)
		{
			this._index_templates = index_templates;
			this.AddQueryString("index_templates", this._index_templates);
			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>Query string 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>Query string 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 ExpandWildcardsOptions _expand_wildcards { get; set; }
		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
		public CountRequestParameters ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
		{
			this._expand_wildcards = expand_wildcards;
			this.AddQueryString("expand_wildcards", this._expand_wildcards);
			return this;
		}
		
		
		internal int _min_score { get; set; }
		///<summary>Include only documents with a specific `_score` value in the result</summary>
		public CountRequestParameters MinScore(int 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>Query string 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 ExpandWildcardsOptions _expand_wildcards { get; set; }
		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
		public PercolateCountRequestParameters ExpandWildcards(ExpandWildcardsOptions 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 int _version { get; set; }
		///<summary>Explicit version number for concurrency control</summary>
		public PercolateCountRequestParameters Version(int version)
		{
			this._version = version;
			this.AddQueryString("version", this._version);
			return this;
		}
		
		
		internal VersionTypeOptions _version_type { get; set; }
		///<summary>Specific version type</summary>
		public PercolateCountRequestParameters VersionType(VersionTypeOptions version_type)
		{
			this._version_type = version_type;
			this.AddQueryString("version_type", this._version_type);
			return this;
		}
		
	}
	
	
	///<summary>Query string 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 ConsistencyOptions _consistency { get; set; }
		///<summary>Specific write consistency setting for the operation</summary>
		public DeleteRequestParameters Consistency(ConsistencyOptions 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 ReplicationOptions _replication { get; set; }
		///<summary>Specific replication type</summary>
		public DeleteRequestParameters Replication(ReplicationOptions 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 int _version { get; set; }
		///<summary>Explicit version number for concurrency control</summary>
		public DeleteRequestParameters Version(int version)
		{
			this._version = version;
			this.AddQueryString("version", this._version);
			return this;
		}
		
		
		internal VersionTypeOptions _version_type { get; set; }
		///<summary>Specific version type</summary>
		public DeleteRequestParameters VersionType(VersionTypeOptions version_type)
		{
			this._version_type = version_type;
			this.AddQueryString("version_type", this._version_type);
			return this;
		}
		
	}
	
	
	///<summary>Query string 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 ConsistencyOptions _consistency { get; set; }
		///<summary>Specific write consistency setting for the operation</summary>
		public DeleteByQueryRequestParameters Consistency(ConsistencyOptions consistency)
		{
			this._consistency = consistency;
			this.AddQueryString("consistency", this._consistency);
			return this;
		}
		
		
		internal DefaultOperatorOptions _default_operator { get; set; }
		///<summary>The default operator for query string query (AND or OR)</summary>
		public DeleteByQueryRequestParameters DefaultOperator(DefaultOperatorOptions 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 ExpandWildcardsOptions _expand_wildcards { get; set; }
		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
		public DeleteByQueryRequestParameters ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
		{
			this._expand_wildcards = expand_wildcards;
			this.AddQueryString("expand_wildcards", this._expand_wildcards);
			return this;
		}
		
		
		internal ReplicationOptions _replication { get; set; }
		///<summary>Specific replication type</summary>
		public DeleteByQueryRequestParameters Replication(ReplicationOptions 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>Query string 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>Query string 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 DefaultOperatorOptions _default_operator { get; set; }
		///<summary>The default operator for query string query (AND or OR)</summary>
		public ExplainRequestParameters DefaultOperator(DefaultOperatorOptions 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 { get; set; }
		///<summary>True or false to return the _source field or not, or a list of fields to return</summary>
		public ExplainRequestParameters Source(params string[] _source)
		{
			this.__source = _source;
			this.AddQueryString("_source", this.__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>Query string 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 { get; set; }
		///<summary>True or false to return the _source field or not, or a list of fields to return</summary>
		public GetRequestParameters Source(params string[] _source)
		{
			this.__source = _source;
			this.AddQueryString("_source", this.__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 int _version { get; set; }
		///<summary>Explicit version number for concurrency control</summary>
		public GetRequestParameters Version(int version)
		{
			this._version = version;
			this.AddQueryString("version", this._version);
			return this;
		}
		
		
		internal VersionTypeOptions _version_type { get; set; }
		///<summary>Specific version type</summary>
		public GetRequestParameters VersionType(VersionTypeOptions version_type)
		{
			this._version_type = version_type;
			this.AddQueryString("version_type", this._version_type);
			return this;
		}
		
	}
	
	
	///<summary>Query string 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 { get; set; }
		///<summary>True or false to return the _source field or not, or a list of fields to return</summary>
		public SourceRequestParameters Source(params string[] _source)
		{
			this.__source = _source;
			this.AddQueryString("_source", this.__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 int _version { get; set; }
		///<summary>Explicit version number for concurrency control</summary>
		public SourceRequestParameters Version(int version)
		{
			this._version = version;
			this.AddQueryString("version", this._version);
			return this;
		}
		
		
		internal VersionTypeOptions _version_type { get; set; }
		///<summary>Specific version type</summary>
		public SourceRequestParameters VersionType(VersionTypeOptions version_type)
		{
			this._version_type = version_type;
			this.AddQueryString("version_type", this._version_type);
			return this;
		}
		
	}
	
	
	///<summary>Query string 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 ConsistencyOptions _consistency { get; set; }
		///<summary>Explicit write consistency setting for the operation</summary>
		public IndexRequestParameters Consistency(ConsistencyOptions consistency)
		{
			this._consistency = consistency;
			this.AddQueryString("consistency", this._consistency);
			return this;
		}
		
		
		internal OpTypeOptions _op_type { get; set; }
		///<summary>Explicit operation type</summary>
		public IndexRequestParameters OpType(OpTypeOptions 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 ReplicationOptions _replication { get; set; }
		///<summary>Specific replication type</summary>
		public IndexRequestParameters Replication(ReplicationOptions 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 int _version { get; set; }
		///<summary>Explicit version number for concurrency control</summary>
		public IndexRequestParameters Version(int version)
		{
			this._version = version;
			this.AddQueryString("version", this._version);
			return this;
		}
		
		
		internal VersionTypeOptions _version_type { get; set; }
		///<summary>Specific version type</summary>
		public IndexRequestParameters VersionType(VersionTypeOptions version_type)
		{
			this._version_type = version_type;
			this.AddQueryString("version_type", this._version_type);
			return this;
		}
		
	}
	
	
	///<summary>Query string 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 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 FormatOptions _format { get; set; }
		///<summary>Format of the output</summary>
		public AnalyzeRequestParameters Format(FormatOptions format)
		{
			this._format = format;
			this.AddQueryString("format", this._format);
			return this;
		}
		
	}
	
	
	///<summary>Query string 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 bool _fielddata { get; set; }
		///<summary>Clear field data</summary>
		public ClearCacheRequestParameters Fielddata(bool fielddata)
		{
			this._fielddata = fielddata;
			this.AddQueryString("fielddata", this._fielddata);
			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 ExpandWildcardsOptions _expand_wildcards { get; set; }
		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
		public ClearCacheRequestParameters ExpandWildcards(ExpandWildcardsOptions 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>Query string 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 ExpandWildcardsOptions _expand_wildcards { get; set; }
		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
		public CloseIndexRequestParameters ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
		{
			this._expand_wildcards = expand_wildcards;
			this.AddQueryString("expand_wildcards", this._expand_wildcards);
			return this;
		}
		
	}
	
	
	///<summary>Query string 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>Query string 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>Query string 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>Query string 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>Query string descriptor for IndicesDeleteTemplateForAll
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html
	///</pre>
	///</summary>
	public class DeleteTemplateRequestParameters : FluentRequestParameters<DeleteTemplateRequestParameters> 
	{
		
		internal string _timeout { get; set; }
		///<summary>Explicit operation timeout</summary>
		public DeleteTemplateRequestParameters Timeout(string timeout)
		{
			this._timeout = timeout;
			this.AddQueryString("timeout", this._timeout);
			return this;
		}
		
		
		internal string _master_timeout { get; set; }
		///<summary>Specify timeout for connection to master</summary>
		public DeleteTemplateRequestParameters MasterTimeout(string master_timeout)
		{
			this._master_timeout = master_timeout;
			this.AddQueryString("master_timeout", this._master_timeout);
			return this;
		}
		
	}
	
	
	///<summary>Query string 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>Query string 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 ExpandWildcardsOptions _expand_wildcards { get; set; }
		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
		public IndexExistsRequestParameters ExpandWildcards(ExpandWildcardsOptions 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>Query string descriptor for IndicesExistsAliasForAll
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html
	///</pre>
	///</summary>
	public class IndicesExistsAliasRequestParameters : FluentRequestParameters<IndicesExistsAliasRequestParameters> 
	{
		
		internal bool _ignore_unavailable { get; set; }
		///<summary>Whether specified concrete indices should be ignored when unavailable (missing or closed)</summary>
		public IndicesExistsAliasRequestParameters 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 IndicesExistsAliasRequestParameters AllowNoIndices(bool allow_no_indices)
		{
			this._allow_no_indices = allow_no_indices;
			this.AddQueryString("allow_no_indices", this._allow_no_indices);
			return this;
		}
		
		
		internal ExpandWildcardsOptions _expand_wildcards { get; set; }
		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
		public IndicesExistsAliasRequestParameters ExpandWildcards(ExpandWildcardsOptions 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 IndicesExistsAliasRequestParameters Local(bool local)
		{
			this._local = local;
			this.AddQueryString("local", this._local);
			return this;
		}
		
	}
	
	
	///<summary>Query string descriptor for IndicesExistsTemplateForAll
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html
	///</pre>
	///</summary>
	public class IndicesExistsTemplateRequestParameters : FluentRequestParameters<IndicesExistsTemplateRequestParameters> 
	{
		
		internal bool _local { get; set; }
		///<summary>Return local information, do not retrieve the state from master node (default: false)</summary>
		public IndicesExistsTemplateRequestParameters Local(bool local)
		{
			this._local = local;
			this.AddQueryString("local", this._local);
			return this;
		}
		
	}
	
	
	///<summary>Query string descriptor for IndicesExistsType
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-types-exists.html
	///</pre>
	///</summary>
	public class IndicesExistsTypeRequestParameters : FluentRequestParameters<IndicesExistsTypeRequestParameters> 
	{
		
		internal bool _ignore_unavailable { get; set; }
		///<summary>Whether specified concrete indices should be ignored when unavailable (missing or closed)</summary>
		public IndicesExistsTypeRequestParameters 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 IndicesExistsTypeRequestParameters AllowNoIndices(bool allow_no_indices)
		{
			this._allow_no_indices = allow_no_indices;
			this.AddQueryString("allow_no_indices", this._allow_no_indices);
			return this;
		}
		
		
		internal ExpandWildcardsOptions _expand_wildcards { get; set; }
		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
		public IndicesExistsTypeRequestParameters ExpandWildcards(ExpandWildcardsOptions 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 IndicesExistsTypeRequestParameters Local(bool local)
		{
			this._local = local;
			this.AddQueryString("local", this._local);
			return this;
		}
		
	}
	
	
	///<summary>Query string 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 ExpandWildcardsOptions _expand_wildcards { get; set; }
		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
		public FlushRequestParameters ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
		{
			this._expand_wildcards = expand_wildcards;
			this.AddQueryString("expand_wildcards", this._expand_wildcards);
			return this;
		}
		
	}
	
	
	///<summary>Query string descriptor for IndicesGetAliasForAll
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html
	///</pre>
	///</summary>
	public class GetAliasesRequestParameters : FluentRequestParameters<GetAliasesRequestParameters> 
	{
		
		internal bool _ignore_unavailable { get; set; }
		///<summary>Whether specified concrete indices should be ignored when unavailable (missing or closed)</summary>
		public GetAliasesRequestParameters 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 GetAliasesRequestParameters AllowNoIndices(bool allow_no_indices)
		{
			this._allow_no_indices = allow_no_indices;
			this.AddQueryString("allow_no_indices", this._allow_no_indices);
			return this;
		}
		
		
		internal ExpandWildcardsOptions _expand_wildcards { get; set; }
		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
		public GetAliasesRequestParameters ExpandWildcards(ExpandWildcardsOptions 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 GetAliasesRequestParameters Local(bool local)
		{
			this._local = local;
			this.AddQueryString("local", this._local);
			return this;
		}
		
	}
	
	
	///<summary>Query string descriptor for IndicesGetAliasesForAll
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html
	///</pre>
	///</summary>
	public class IndicesGetAliasesRequestParameters : FluentRequestParameters<IndicesGetAliasesRequestParameters> 
	{
		
		internal string _timeout { get; set; }
		///<summary>Explicit operation timeout</summary>
		public IndicesGetAliasesRequestParameters 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 IndicesGetAliasesRequestParameters Local(bool local)
		{
			this._local = local;
			this.AddQueryString("local", this._local);
			return this;
		}
		
	}
	
	
	///<summary>Query string descriptor for IndicesGetFieldMappingForAll
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-field-mapping.html
	///</pre>
	///</summary>
	public class IndicesGetFieldMappingRequestParameters : FluentRequestParameters<IndicesGetFieldMappingRequestParameters> 
	{
		
		internal bool _include_defaults { get; set; }
		///<summary>Whether the default mapping values should be returned as well</summary>
		public IndicesGetFieldMappingRequestParameters 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 IndicesGetFieldMappingRequestParameters 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 IndicesGetFieldMappingRequestParameters AllowNoIndices(bool allow_no_indices)
		{
			this._allow_no_indices = allow_no_indices;
			this.AddQueryString("allow_no_indices", this._allow_no_indices);
			return this;
		}
		
		
		internal ExpandWildcardsOptions _expand_wildcards { get; set; }
		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
		public IndicesGetFieldMappingRequestParameters ExpandWildcards(ExpandWildcardsOptions 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 IndicesGetFieldMappingRequestParameters Local(bool local)
		{
			this._local = local;
			this.AddQueryString("local", this._local);
			return this;
		}
		
	}
	
	
	///<summary>Query string 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 ExpandWildcardsOptions _expand_wildcards { get; set; }
		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
		public GetMappingRequestParameters ExpandWildcards(ExpandWildcardsOptions 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>Query string 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 ExpandWildcardsOptions _expand_wildcards { get; set; }
		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
		public GetIndexSettingsRequestParameters ExpandWildcards(ExpandWildcardsOptions 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>Query string descriptor for IndicesGetTemplateForAll
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html
	///</pre>
	///</summary>
	public class GetTemplateRequestParameters : FluentRequestParameters<GetTemplateRequestParameters> 
	{
		
		internal bool _flat_settings { get; set; }
		///<summary>Return settings in flat format (default: false)</summary>
		public GetTemplateRequestParameters FlatSettings(bool flat_settings)
		{
			this._flat_settings = flat_settings;
			this.AddQueryString("flat_settings", this._flat_settings);
			return this;
		}
		
		
		internal bool _local { get; set; }
		///<summary>Return local information, do not retrieve the state from master node (default: false)</summary>
		public GetTemplateRequestParameters Local(bool local)
		{
			this._local = local;
			this.AddQueryString("local", this._local);
			return this;
		}
		
	}
	
	
	///<summary>Query string 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 ExpandWildcardsOptions _expand_wildcards { get; set; }
		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
		public GetWarmerRequestParameters ExpandWildcards(ExpandWildcardsOptions 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>Query string 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 ExpandWildcardsOptions _expand_wildcards { get; set; }
		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
		public OpenIndexRequestParameters ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
		{
			this._expand_wildcards = expand_wildcards;
			this.AddQueryString("expand_wildcards", this._expand_wildcards);
			return this;
		}
		
	}
	
	
	///<summary>Query string 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 ExpandWildcardsOptions _expand_wildcards { get; set; }
		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
		public OptimizeRequestParameters ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
		{
			this._expand_wildcards = expand_wildcards;
			this.AddQueryString("expand_wildcards", this._expand_wildcards);
			return this;
		}
		
		
		internal int _max_num_segments { get; set; }
		///<summary>The number of segments the index should be merged into (default: dynamic)</summary>
		public OptimizeRequestParameters MaxNumSegments(int 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>Query string 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>Query string 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 ExpandWildcardsOptions _expand_wildcards { get; set; }
		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
		public PutMappingRequestParameters ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
		{
			this._expand_wildcards = expand_wildcards;
			this.AddQueryString("expand_wildcards", this._expand_wildcards);
			return this;
		}
		
	}
	
	
	///<summary>Query string 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 ExpandWildcardsOptions _expand_wildcards { get; set; }
		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
		public UpdateSettingsRequestParameters ExpandWildcards(ExpandWildcardsOptions 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>Query string 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 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>Query string 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 ExpandWildcardsOptions _expand_wildcards { get; set; }
		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both, in the search request to warm.</summary>
		public PutWarmerRequestParameters ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
		{
			this._expand_wildcards = expand_wildcards;
			this.AddQueryString("expand_wildcards", this._expand_wildcards);
			return this;
		}
		
	}
	
	
	///<summary>Query string 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>Query string 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 ExpandWildcardsOptions _expand_wildcards { get; set; }
		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
		public RefreshRequestParameters ExpandWildcards(ExpandWildcardsOptions 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>Query string 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 ExpandWildcardsOptions _expand_wildcards { get; set; }
		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
		public SegmentsRequestParameters ExpandWildcards(ExpandWildcardsOptions 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>Query string descriptor for IndicesSnapshotIndexForAll
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-gateway-snapshot.html
	///</pre>
	///</summary>
	public class GatewaySnapshotRequestParameters : FluentRequestParameters<GatewaySnapshotRequestParameters> 
	{
		
		internal bool _ignore_unavailable { get; set; }
		///<summary>Whether specified concrete indices should be ignored when unavailable (missing or closed)</summary>
		public GatewaySnapshotRequestParameters 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 GatewaySnapshotRequestParameters AllowNoIndices(bool allow_no_indices)
		{
			this._allow_no_indices = allow_no_indices;
			this.AddQueryString("allow_no_indices", this._allow_no_indices);
			return this;
		}
		
		
		internal ExpandWildcardsOptions _expand_wildcards { get; set; }
		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
		public GatewaySnapshotRequestParameters ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
		{
			this._expand_wildcards = expand_wildcards;
			this.AddQueryString("expand_wildcards", this._expand_wildcards);
			return this;
		}
		
	}
	
	
	///<summary>Query string 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 bool _groups { get; set; }
		///<summary>A comma-separated list of search groups for `search` index metric</summary>
		public IndicesStatsRequestParameters 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 IndicesStatsRequestParameters Human(bool human)
		{
			this._human = human;
			this.AddQueryString("human", this._human);
			return this;
		}
		
		
		internal LevelOptions _level { get; set; }
		///<summary>Return stats aggregated at cluster, index or shard level</summary>
		public IndicesStatsRequestParameters Level(LevelOptions 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 IndicesStatsRequestParameters Types(params string[] types)
		{
			this._types = types;
			this.AddQueryString("types", this._types);
			return this;
		}
		
	}
	
	
	///<summary>Query string 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 ExpandWildcardsOptions _expand_wildcards { get; set; }
		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
		public IndicesStatusRequestParameters ExpandWildcards(ExpandWildcardsOptions 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>Query string 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>Query string 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 ExpandWildcardsOptions _expand_wildcards { get; set; }
		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
		public ValidateQueryRequestParameters ExpandWildcards(ExpandWildcardsOptions 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>Query string descriptor for Info
	///<pre>
	///http://www.elasticsearch.org/guide/
	///</pre>
	///</summary>
	public class InfoRequestParameters : FluentRequestParameters<InfoRequestParameters> 
	{
	}
	
	
	///<summary>Query string 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 { get; set; }
		///<summary>True or false to return the _source field or not, or a list of fields to return</summary>
		public MultiGetRequestParameters Source(params string[] _source)
		{
			this.__source = _source;
			this.AddQueryString("_source", this.__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>Query string 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 int _max_doc_freq { get; set; }
		///<summary>The word occurrence frequency as count: words with higher occurrence in the corpus will be ignored</summary>
		public MoreLikeThisRequestParameters MaxDocFreq(int max_doc_freq)
		{
			this._max_doc_freq = max_doc_freq;
			this.AddQueryString("max_doc_freq", this._max_doc_freq);
			return this;
		}
		
		
		internal int _max_query_terms { get; set; }
		///<summary>The maximum query terms to be included in the generated query</summary>
		public MoreLikeThisRequestParameters MaxQueryTerms(int max_query_terms)
		{
			this._max_query_terms = max_query_terms;
			this.AddQueryString("max_query_terms", this._max_query_terms);
			return this;
		}
		
		
		internal int _max_word_length { get; set; }
		///<summary>The minimum length of the word: longer words will be ignored</summary>
		public MoreLikeThisRequestParameters MaxWordLength(int max_word_length)
		{
			this._max_word_length = max_word_length;
			this.AddQueryString("max_word_length", this._max_word_length);
			return this;
		}
		
		
		internal int _min_doc_freq { get; set; }
		///<summary>The word occurrence frequency as count: words with lower occurrence in the corpus will be ignored</summary>
		public MoreLikeThisRequestParameters MinDocFreq(int min_doc_freq)
		{
			this._min_doc_freq = min_doc_freq;
			this.AddQueryString("min_doc_freq", this._min_doc_freq);
			return this;
		}
		
		
		internal int _min_term_freq { get; set; }
		///<summary>The term frequency as percent: terms with lower occurence in the source document will be ignored</summary>
		public MoreLikeThisRequestParameters MinTermFreq(int min_term_freq)
		{
			this._min_term_freq = min_term_freq;
			this.AddQueryString("min_term_freq", this._min_term_freq);
			return this;
		}
		
		
		internal int _min_word_length { get; set; }
		///<summary>The minimum length of the word: shorter words will be ignored</summary>
		public MoreLikeThisRequestParameters MinWordLength(int 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 int _search_from { get; set; }
		///<summary>The offset from which to return results</summary>
		public MoreLikeThisRequestParameters SearchFrom(int 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 int _search_size { get; set; }
		///<summary>The number of documents to return (default: 10)</summary>
		public MoreLikeThisRequestParameters SearchSize(int 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>Query string descriptor for MpercolateGet
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html
	///</pre>
	///</summary>
	public class MpercolateRequestParameters : FluentRequestParameters<MpercolateRequestParameters> 
	{
		
		internal bool _ignore_unavailable { get; set; }
		///<summary>Whether specified concrete indices should be ignored when unavailable (missing or closed)</summary>
		public MpercolateRequestParameters 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 MpercolateRequestParameters AllowNoIndices(bool allow_no_indices)
		{
			this._allow_no_indices = allow_no_indices;
			this.AddQueryString("allow_no_indices", this._allow_no_indices);
			return this;
		}
		
		
		internal ExpandWildcardsOptions _expand_wildcards { get; set; }
		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
		public MpercolateRequestParameters ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
		{
			this._expand_wildcards = expand_wildcards;
			this.AddQueryString("expand_wildcards", this._expand_wildcards);
			return this;
		}
		
	}
	
	
	///<summary>Query string 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 SearchTypeOptions _search_type { get; set; }
		///<summary>Search operation type</summary>
		public MultiSearchRequestParameters SearchType(SearchTypeOptions search_type)
		{
			this._search_type = search_type;
			this.AddQueryString("search_type", this._search_type);
			return this;
		}
		
	}
	
	
	///<summary>Query string descriptor for MtermvectorsGet
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html
	///</pre>
	///</summary>
	public class MtermvectorsRequestParameters : FluentRequestParameters<MtermvectorsRequestParameters> 
	{
		
		internal  string[] _ids { get; set; }
		///<summary>A comma-separated list of documents ids. You must define ids as parameter or set &quot;ids&quot; or &quot;docs&quot; in the request body</summary>
		public MtermvectorsRequestParameters Ids(params string[] ids)
		{
			this._ids = ids;
			this.AddQueryString("ids", this._ids);
			return this;
		}
		
		
		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 MtermvectorsRequestParameters 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 MtermvectorsRequestParameters 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 MtermvectorsRequestParameters 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 MtermvectorsRequestParameters 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 MtermvectorsRequestParameters 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 MtermvectorsRequestParameters 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 MtermvectorsRequestParameters 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 MtermvectorsRequestParameters 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 MtermvectorsRequestParameters Parent(string parent)
		{
			this._parent = parent;
			this.AddQueryString("parent", this._parent);
			return this;
		}
		
	}
	
	
	///<summary>Query string 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 int _snapshots { get; set; }
		///<summary>Number of samples of thread stacktrace (default: 10)</summary>
		public NodesHotThreadsRequestParameters Snapshots(int snapshots)
		{
			this._snapshots = snapshots;
			this.AddQueryString("snapshots", this._snapshots);
			return this;
		}
		
		
		internal int _threads { get; set; }
		///<summary>Specify the number of threads to provide information for (default: 3)</summary>
		public NodesHotThreadsRequestParameters Threads(int threads)
		{
			this._threads = threads;
			this.AddQueryString("threads", this._threads);
			return this;
		}
		
		
		internal TypeOptions _type { get; set; }
		///<summary>The type to sample (default: cpu)</summary>
		public NodesHotThreadsRequestParameters Type(TypeOptions type)
		{
			this._type = type;
			this.AddQueryString("type", this._type);
			return this;
		}
		
	}
	
	
	///<summary>Query string 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>Query string 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>Query string 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 LevelOptions _level { get; set; }
		///<summary>Return indices stats aggregated at node, index or shard level</summary>
		public NodesStatsRequestParameters Level(LevelOptions 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>Query string 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 ExpandWildcardsOptions _expand_wildcards { get; set; }
		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
		public PercolateRequestParameters ExpandWildcards(ExpandWildcardsOptions 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 int _version { get; set; }
		///<summary>Explicit version number for concurrency control</summary>
		public PercolateRequestParameters Version(int version)
		{
			this._version = version;
			this.AddQueryString("version", this._version);
			return this;
		}
		
		
		internal VersionTypeOptions _version_type { get; set; }
		///<summary>Specific version type</summary>
		public PercolateRequestParameters VersionType(VersionTypeOptions version_type)
		{
			this._version_type = version_type;
			this.AddQueryString("version_type", this._version_type);
			return this;
		}
		
	}
	
	
	///<summary>Query string descriptor for Ping
	///<pre>
	///http://www.elasticsearch.org/guide/
	///</pre>
	///</summary>
	public class PingRequestParameters : FluentRequestParameters<PingRequestParameters> 
	{
	}
	
	
	///<summary>Query string 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> 
	{
		
		internal string _scroll { get; set; }
		///<summary>Specify how long a consistent view of the index should be maintained for scrolled search</summary>
		public ScrollRequestParameters Scroll(string scroll)
		{
			this._scroll = scroll;
			this.AddQueryString("scroll", this._scroll);
			return this;
		}
		
		
		internal string _scroll_id { get; set; }
		///<summary>The scroll ID for scrolled search</summary>
		public ScrollRequestParameters ScrollId(string scroll_id)
		{
			this._scroll_id = scroll_id;
			this.AddQueryString("scroll_id", this._scroll_id);
			return this;
		}
		
	}
	
	
	///<summary>Query string 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 DefaultOperatorOptions _default_operator { get; set; }
		///<summary>The default operator for query string query (AND or OR)</summary>
		public SearchRequestParameters DefaultOperator(DefaultOperatorOptions 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 ExpandWildcardsOptions _expand_wildcards { get; set; }
		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
		public SearchRequestParameters ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
		{
			this._expand_wildcards = expand_wildcards;
			this.AddQueryString("expand_wildcards", this._expand_wildcards);
			return this;
		}
		
		
		internal  string[] _indices_boost { get; set; }
		///<summary>Comma-separated list of index boosts</summary>
		public SearchRequestParameters IndicesBoost(params string[] indices_boost)
		{
			this._indices_boost = indices_boost;
			this.AddQueryString("indices_boost", this._indices_boost);
			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 SearchTypeOptions _search_type { get; set; }
		///<summary>Search operation type</summary>
		public SearchRequestParameters SearchType(SearchTypeOptions search_type)
		{
			this._search_type = search_type;
			this.AddQueryString("search_type", this._search_type);
			return this;
		}
		
		
		internal string _source { get; set; }
		///<summary>The URL-encoded request definition using the Query DSL (instead of using request body)</summary>
		public SearchRequestParameters Source(string source)
		{
			this._source = source;
			this.AddQueryString("source", this._source);
			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 SuggestModeOptions _suggest_mode { get; set; }
		///<summary>Specify suggest mode</summary>
		public SearchRequestParameters SuggestMode(SuggestModeOptions suggest_mode)
		{
			this._suggest_mode = suggest_mode;
			this.AddQueryString("suggest_mode", this._suggest_mode);
			return this;
		}
		
		
		internal int _suggest_size { get; set; }
		///<summary>How many suggestions to return in response</summary>
		public SearchRequestParameters SuggestSize(int 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>Query string descriptor for SearchTemplateGet
	///<pre>
	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-search.html
	///</pre>
	///</summary>
	public class SearchTemplateRequestParameters : FluentRequestParameters<SearchTemplateRequestParameters> 
	{
	}
	
	
	///<summary>Query string 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>Query string 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>Query string 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>Query string 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>Query string 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>Query string 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>Query string 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>Query string 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>Query string 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 ExpandWildcardsOptions _expand_wildcards { get; set; }
		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
		public SuggestRequestParameters ExpandWildcards(ExpandWildcardsOptions 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>Query string 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>Query string 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 ConsistencyOptions _consistency { get; set; }
		///<summary>Explicit write consistency setting for the operation</summary>
		public UpdateRequestParameters Consistency(ConsistencyOptions consistency)
		{
			this._consistency = consistency;
			this.AddQueryString("consistency", this._consistency);
			return this;
		}
		
		
		internal IEnumerable<object> _fields { get; set; }
		///<summary>A comma-separated list of fields to return in the response</summary>
		public UpdateRequestParameters Fields(params string[] fields)
		{
			this._fields = fields.Select(f=>(object)f);
			this.AddQueryString("fields", this._fields);
			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 ReplicationOptions _replication { get; set; }
		///<summary>Specific replication type</summary>
		public UpdateRequestParameters Replication(ReplicationOptions replication)
		{
			this._replication = replication;
			this.AddQueryString("replication", this._replication);
			return this;
		}
		
		
		internal int _retry_on_conflict { get; set; }
		///<summary>Specify how many times should the operation be retried when a conflict occurs (default: 0)</summary>
		public UpdateRequestParameters RetryOnConflict(int 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 int _version { get; set; }
		///<summary>Explicit version number for concurrency control</summary>
		public UpdateRequestParameters Version(int version)
		{
			this._version = version;
			this.AddQueryString("version", this._version);
			return this;
		}
		
		
		internal VersionTypeOptions _version_type { get; set; }
		///<summary>Specific version type</summary>
		public UpdateRequestParameters VersionType(VersionTypeOptions version_type)
		{
			this._version_type = version_type;
			this.AddQueryString("version_type", this._version_type);
			return this;
		}
		
	}
	
	
}