diff --git a/TimberWinR.ServiceHost/Properties/AssemblyInfo.cs b/TimberWinR.ServiceHost/Properties/AssemblyInfo.cs index ca35740..86c588b 100644 --- a/TimberWinR.ServiceHost/Properties/AssemblyInfo.cs +++ b/TimberWinR.ServiceHost/Properties/AssemblyInfo.cs @@ -32,5 +32,5 @@ using System.Runtime.InteropServices; // You can specify all the values or you can default the Build and Revision Numbers // by using the '*' as shown below: // [assembly: AssemblyVersion("1.0.*")] -[assembly: AssemblyVersion("1.3.19.1")] -[assembly: AssemblyFileVersion("1.3.19.1")] +[assembly: AssemblyVersion("1.3.20.0")] +[assembly: AssemblyFileVersion("1.3.20.0")] diff --git a/TimberWinR/Outputs/Elasticsearch.cs b/TimberWinR/Outputs/Elasticsearch.cs index 062e3f3..93e889b 100644 --- a/TimberWinR/Outputs/Elasticsearch.cs +++ b/TimberWinR/Outputs/Elasticsearch.cs @@ -2,52 +2,91 @@ using System.Collections.Generic; using System.Linq; using System.Net; +using System.Net.Sockets; +using System.Text; using System.Threading; using System.Threading.Tasks; +using Elasticsearch.Net; +using Elasticsearch.Net.ConnectionPool; +using Nest; using Newtonsoft.Json.Linq; using NLog; using RapidRegex.Core; using RestSharp; +using System.Text.RegularExpressions; +using Elasticsearch.Net.Serialization; +using Newtonsoft.Json; namespace TimberWinR.Outputs { - using System.Text.RegularExpressions; + public class Person + { + public string Firstname { get; set; } + public string Lastname { get; set; } + } public partial class ElasticsearchOutput : OutputSender { private TimberWinR.Manager _manager; private readonly int _port; private readonly int _interval; - private readonly string[] _host; - private readonly string _protocol; - private int _hostIndex; + private readonly int _flushSize; + private readonly int _idleFlushTimeSeconds; + private readonly string[] _hosts; + private readonly string _protocol; private readonly int _timeout; private readonly object _locker = new object(); private readonly List _jsonQueue; private readonly int _numThreads; private long _sentMessages; private long _errorCount; - private Parser.ElasticsearchOutputParameters eo; + private readonly int _maxQueueSize; + private readonly bool _queueOverflowDiscardOldest; + private Parser.ElasticsearchOutputParameters _parameters; public bool Stop { get; set; } + + /// + /// Get the next client from the list of hosts. + /// + /// + private ElasticClient getClient() + { + var nodes = new List(); + foreach (var host in _hosts) + { + var url = string.Format("http://{0}:{1}", host, _port); + nodes.Add(new Uri(url)); + } + var pool = new StaticConnectionPool(nodes.ToArray()); + var settings = new ConnectionSettings(pool) + .ExposeRawResponse(); - public ElasticsearchOutput(TimberWinR.Manager manager, Parser.ElasticsearchOutputParameters eo, CancellationToken cancelToken) + var client = new ElasticClient(settings); + return client; + } + + public ElasticsearchOutput(TimberWinR.Manager manager, Parser.ElasticsearchOutputParameters parameters, CancellationToken cancelToken) : base(cancelToken, "Elasticsearch") { _sentMessages = 0; _errorCount = 0; - this.eo = eo; - _protocol = eo.Protocol; - _timeout = eo.Timeout; + _parameters = parameters; + _flushSize = parameters.FlushSize; + _idleFlushTimeSeconds = parameters.IdleFlushTimeInSeconds; + _protocol = parameters.Protocol; + _timeout = parameters.Timeout; _manager = manager; - _port = eo.Port; - _interval = eo.Interval; - _host = eo.Host; - _hostIndex = 0; + _port = parameters.Port; + _interval = parameters.Interval; + _hosts = parameters.Host; _jsonQueue = new List(); - _numThreads = eo.NumThreads; + _numThreads = parameters.NumThreads; + _maxQueueSize = parameters.MaxQueueSize; + _queueOverflowDiscardOldest = parameters.QueueOverflowDiscardOldest; + - for (int i = 0; i < eo.NumThreads; i++) + for (int i = 0; i < parameters.NumThreads; i++) { Task.Factory.StartNew(ElasticsearchSender, cancelToken, TaskCreationOptions.LongRunning, TaskScheduler.Current); } @@ -58,16 +97,20 @@ namespace TimberWinR.Outputs JObject json = new JObject( new JProperty("elasticsearch", new JObject( - new JProperty("host", string.Join(",", _host)), + new JProperty("host", string.Join(",", _hosts)), new JProperty("errors", _errorCount), new JProperty("sentMmessageCount", _sentMessages), new JProperty("queuedMessageCount", _jsonQueue.Count), new JProperty("port", _port), + new JProperty("flushSize", _flushSize), + new JProperty("idleFlushTime", _idleFlushTimeSeconds), new JProperty("interval", _interval), new JProperty("threads", _numThreads), + new JProperty("maxQueueSize", _maxQueueSize), + new JProperty("overflowDiscardOldest", _queueOverflowDiscardOldest), new JProperty("hosts", new JArray( - from h in _host + from h in _hosts select new JObject( new JProperty("host", h))))))); return json; @@ -77,137 +120,145 @@ namespace TimberWinR.Outputs // private void ElasticsearchSender() { + // Force an inital flush + DateTime lastFlushTime = DateTime.MinValue; + using (var syncHandle = new ManualResetEventSlim()) - { + { // Execute the query while (!Stop) - { + { if (!CancelToken.IsCancellationRequested) { try - { - JObject[] messages; + { + int messageCount = 0; + List messages = new List(); + + // Lets get whats in the queue lock (_locker) { - var count = _jsonQueue.Count; - messages = _jsonQueue.Take(count).ToArray(); - _jsonQueue.RemoveRange(0, count); - if (messages.Length > 0) - _manager.IncrementMessageCount(messages.Length); + messageCount = _jsonQueue.Count; + + // Time to flush? + if (messageCount >= _flushSize || (DateTime.UtcNow - lastFlushTime).Seconds >= _idleFlushTimeSeconds) + { + messages = _jsonQueue.Take(messageCount).ToList(); + _jsonQueue.RemoveRange(0, messageCount); + if (messages.Count > 0) + _manager.IncrementMessageCount(messages.Count); + } } - if (messages.Length > 0) + // We have some messages to work with + if (messages.Count > 0) { - int numHosts = _host.Length; - while (numHosts-- > 0) + var client = getClient(); + + LogManager.GetCurrentClassLogger() + .Debug("Sending {0} Messages to {1}", messages.Count, client.Connection.ToString()); + + // This loop will process all messages we've taken from the queue + // that have the same index and type (an elasticsearch requirement) + do { try { - // Get the next client - RestClient client = getClient(); - if (client != null) - { - LogManager.GetCurrentClassLogger() - .Debug("Sending {0} Messages to {1}", messages.Length, client.BaseUrl); + // Grab all messages with same index and type + var bulkTypeName = this._parameters.GetTypeName(messages[0]); + var bulkIndexName = this._parameters.GetIndexName(messages[0]); - foreach (JObject json in messages) - { - var typeName = this.eo.GetTypeName(json); - var indexName = this.eo.GetIndexName(json); - var req = - new RestRequest(string.Format("/{0}/{1}/", indexName, typeName), - Method.POST); - - req.AddParameter("text/json", json.ToString(), ParameterType.RequestBody); - - req.RequestFormat = DataFormat.Json; - - try - { - client.ExecuteAsync(req, response => - { - if (response.StatusCode != HttpStatusCode.Created) - { - LogManager.GetCurrentClassLogger() - .Error("Failed to send: {0}, code: {1}, descr: {2}, resp: {3}", response.ErrorMessage, response.StatusCode, response.StatusDescription, response.ResponseStatus); - Interlocked.Increment(ref _errorCount); - } - else - { - _sentMessages++; - GC.Collect(); - } - }); - } - catch (Exception error) - { - LogManager.GetCurrentClassLogger().Error(error); - Interlocked.Increment(ref _errorCount); - } - } - GC.Collect(); - } - else - { - LogManager.GetCurrentClassLogger() - .Fatal("Unable to connect with any Elasticsearch hosts, {0}", - String.Join(",", _host)); - Interlocked.Increment(ref _errorCount); - } + IEnumerable bulkItems = + messages.TakeWhile( + message => + String.Compare(bulkTypeName, _parameters.GetTypeName(message), false) == 0 && + String.Compare(bulkIndexName, _parameters.GetIndexName(message), false) == 0); + // Send the message(s), if the are successfully sent, they + // are removed from the queue + lastFlushTime = transmitBulkData(bulkItems, bulkIndexName, bulkTypeName, client, lastFlushTime, messages); + + GC.Collect(); } catch (Exception ex) { LogManager.GetCurrentClassLogger().Error(ex); - Interlocked.Increment(ref _errorCount); + break; } - } + } while (messages.Count > 0); } GC.Collect(); if (!Stop) - { - syncHandle.Wait(TimeSpan.FromMilliseconds(_interval), CancelToken); + { + syncHandle.Wait(TimeSpan.FromMilliseconds(_interval), CancelToken); } - } + } catch (OperationCanceledException) { break; } - catch (Exception) + catch (Exception ex) { - throw; + LogManager.GetCurrentClassLogger().Error(ex); } } } } } - private RestClient getClient() + + // + // Send the messages to Elasticsearch (bulk) + // + private DateTime transmitBulkData(IEnumerable bulkItems, string bulkIndexName, string bulkTypeName, + ElasticClient client, DateTime lastFlushTime, List messages) { - if (_hostIndex >= _host.Length) - _hostIndex = 0; - - int numTries = 0; - while (numTries < _host.Length) + var bulkRequest = new BulkRequest() {Refresh = true}; + bulkRequest.Operations = new List(); + foreach (var json in bulkItems) { - try - { - string url = string.Format("{0}://{1}:{2}", _protocol.Replace(":", ""), _host[_hostIndex], _port); - var client = new RestClient(url); - client.Timeout = _timeout; - - _hostIndex++; - if (_hostIndex >= _host.Length) - _hostIndex = 0; - - return client; - } - catch (Exception) - { - } - numTries++; + // ES requires a timestamp, add one if not present + var ts = json["@timestamp"]; + if (ts == null) + json["@timestamp"] = DateTime.UtcNow; + var bi = new BulkIndexOperation(json); + bi.Index = bulkIndexName; + bi.Type = bulkTypeName; + bulkRequest.Operations.Add(bi); } - return null; + // The total messages processed for this operation. + int numMessages = bulkItems.Count(); + + var response = client.Bulk(bulkRequest); + if (!response.IsValid) + { + LogManager.GetCurrentClassLogger().Error("Failed to send: {0}", response); + Interlocked.Increment(ref _errorCount); + interlockedInsert(messages); // Put the messages back into the queue + } + else // Success! + { + lastFlushTime = DateTime.UtcNow; + LogManager.GetCurrentClassLogger().Info(response); + Interlocked.Add(ref _sentMessages, numMessages); + } + + // Remove them from the work list + messages.RemoveRange(0, numMessages); + return lastFlushTime; + } + + // Places messages back into the queue + private void interlockedInsert(List messages) + { + lock (_locker) + { + _jsonQueue.InsertRange(0, messages); + if (_jsonQueue.Count > _maxQueueSize) + { + LogManager.GetCurrentClassLogger().Warn("Exceeded maximum queue depth"); + } + } } @@ -221,6 +272,26 @@ namespace TimberWinR.Outputs lock (_locker) { + if (_jsonQueue.Count >= _maxQueueSize) + { + // If we've exceeded our queue size, and we're supposed to throw out the oldest objects first, + // then remove as many as necessary to get us under our limit + if (_queueOverflowDiscardOldest) + { + LogManager.GetCurrentClassLogger() + .Warn("Overflow discarding oldest {0} messages", _jsonQueue.Count - _maxQueueSize + 1); + + _jsonQueue.RemoveRange(0, (_jsonQueue.Count - _maxQueueSize) + 1); + } + // Otherwise we're in a "discard newest" mode, and this is the newest message, so just ignore it + else + { + LogManager.GetCurrentClassLogger() + .Warn("Overflow discarding newest message: {0}", message); + + return; + } + } _jsonQueue.Add(jsonMessage); } } diff --git a/TimberWinR/Parser.cs b/TimberWinR/Parser.cs index 34f73b4..b100526 100644 --- a/TimberWinR/Parser.cs +++ b/TimberWinR/Parser.cs @@ -512,9 +512,19 @@ namespace TimberWinR.Parser public string Protocol { get; set; } [JsonProperty(PropertyName = "interval")] public int Interval { get; set; } + [JsonProperty(PropertyName = "flush_size")] + public int FlushSize { get; set; } + [JsonProperty(PropertyName = "idle_flush_time")] + public int IdleFlushTimeInSeconds { get; set; } + [JsonProperty(PropertyName = "max_queue_size")] + public int MaxQueueSize { get; set; } + [JsonProperty(PropertyName = "queue_overflow_discard_oldest")] + public bool QueueOverflowDiscardOldest { get; set; } public ElasticsearchOutputParameters() { + FlushSize = 5000; + IdleFlushTimeInSeconds = 1; Protocol = "http"; Port = 9200; Index = ""; @@ -522,6 +532,8 @@ namespace TimberWinR.Parser Timeout = 10000; NumThreads = 1; Interval = 1000; + QueueOverflowDiscardOldest = true; + MaxQueueSize = 50000; } public string GetIndexName(JObject json) diff --git a/TimberWinR/TimberWinR.csproj b/TimberWinR/TimberWinR.csproj index d78ca9a..afefd2c 100644 --- a/TimberWinR/TimberWinR.csproj +++ b/TimberWinR/TimberWinR.csproj @@ -34,6 +34,9 @@ ..\packages\csredis.1.4.7.1\lib\net40\csredis.dll + + ..\packages\Elasticsearch.Net.1.3.1\lib\Elasticsearch.Net.dll + False False @@ -47,6 +50,9 @@ ..\packages\MaxMind.GeoIP2.0.4.0.0\lib\net40\MaxMind.GeoIP2.dll True + + ..\packages\NEST.1.3.1\lib\Nest.dll + False ..\packages\Newtonsoft.Json.6.0.4\lib\net40\Newtonsoft.Json.dll diff --git a/TimberWinR/mdocs/ElasticsearchOutput.md b/TimberWinR/mdocs/ElasticsearchOutput.md index af68bb0..b6b93ce 100644 --- a/TimberWinR/mdocs/ElasticsearchOutput.md +++ b/TimberWinR/mdocs/ElasticsearchOutput.md @@ -7,11 +7,15 @@ The following parameters are allowed when configuring the Redis output. | Parameter | Type | Description | Details | Default | | :-------------|:---------|:------------------------------------------------------------| :--------------------------- | :-- | -| *threads* | string | Location of log files(s) to monitor | Number of worker theads to send messages | 1 | -| *interval* | integer | Interval in milliseconds to sleep during batch sends | Interval | 5000 | -| *index* | string | The index name to use | index used/created | logstash-yyyy.dd.mm | -| *host* | [string] | The hostname(s) of your Elasticsearch server(s) | IP or DNS name | | -| *port* | integer | Redis port number | This port must be open | 9200 | +| *flush_size* | integer | Maximum number of messages before flushing | | 50000 | +| *host* | [string] | The hostname(s) of your Elasticsearch server(s) | IP or DNS name | | +| *idle_flush_time* | integer | Maximum number of seconds elapsed before triggering a flush | | 10 | +| *index* | [string] | The index name to use | index used/created | logstash-yyyy.dd.mm | +| *interval* | integer | Interval in milliseconds to sleep during batch sends | Interval | 5000 | +| *max_queue_size* | integer | Maximum Elasticsearch queue depth | | 50000 | +| *port* | integer | Elasticsearch port number | This port must be open | 9200 | +| *queue_overflow_discard_oldest* | bool | If true, discard oldest messages when max_queue_size reached otherwise discard newest | | true | +| *threads* | [string] | Number of Threads | Number of worker threads processing messages | 1 | ### Index parameter If you want to output your data everyday to a new index, use following index format: "index-%{yyyy.MM.dd}". Here date format could be any forwat which you need. diff --git a/TimberWinR/packages.config b/TimberWinR/packages.config index 9424c65..9a46d62 100644 --- a/TimberWinR/packages.config +++ b/TimberWinR/packages.config @@ -1,8 +1,10 @@  + + diff --git a/chocolateyUninstall.ps1.template b/chocolateyUninstall.ps1.template index 7659c85..9f209d6 100644 --- a/chocolateyUninstall.ps1.template +++ b/chocolateyUninstall.ps1.template @@ -1,7 +1,7 @@ $packageName = 'TimberWinR-${version}' # arbitrary name for the package, used in messages $installerType = 'msi' #only one of these: exe, msi, msu $url = 'http://www.ericfontana.com/TimberWinR/TimberWinR-${version}.0.msi' # download url -$silentArgs = '${PROJECTGUID} /quiet' +$silentArgs = '{02388D50-DE8F-4F6E-8CEE-B93077DD77B6} /quiet' $validExitCodes = @(0) #please insert other valid exit codes here, exit codes for ms http://msdn.microsoft.com/en-us/library/aa368542(VS.85).aspx UnInstall-ChocolateyPackage "$packageName" "$installerType" "$silentArgs" "$url" -validExitCodes $validExitCodes diff --git a/packages/Elasticsearch.Net.1.3.1/Elasticsearch.Net.1.3.1.nupkg b/packages/Elasticsearch.Net.1.3.1/Elasticsearch.Net.1.3.1.nupkg new file mode 100644 index 0000000..fbc375e Binary files /dev/null and b/packages/Elasticsearch.Net.1.3.1/Elasticsearch.Net.1.3.1.nupkg differ diff --git a/packages/Elasticsearch.Net.1.3.1/lib/Elasticsearch.Net.XML b/packages/Elasticsearch.Net.1.3.1/lib/Elasticsearch.Net.XML new file mode 100644 index 0000000..7833384 --- /dev/null +++ b/packages/Elasticsearch.Net.1.3.1/lib/Elasticsearch.Net.XML @@ -0,0 +1,41449 @@ + + + + Elasticsearch.Net + + + + + The timeout for this specific request, takes precedence over the global timeout settings + + + + + The connect timeout for this specific request + + + + + Force a difference content type header on the request + + + + + This will override whatever is set on the connection configuration or whatever default the connectionpool has. + + + + + This will force the operation on the specified node, this will bypass any configured connection pool and will no retry. + + + + + Forces no sniffing to occur on the request no matter what configuration is in place + globally + + + + + Under no circumstance do a ping before the actual call. If a node was previously dead a small ping with + low connect timeout will be tried first in normal circumstances + + + + + Treat the following statuses (on top of the 200 range) NOT as error. + + + + + Basic access authorization credentials to specify with this request. + Overrides any credentials that are set at the global IConnectionSettings level. + + TODO: rename to BasicAuthenticationCredentials in 2.0 + + + + Whether or not this request should be pipelined. http://en.wikipedia.org/wiki/HTTP_pipelining + Note: HTTP pipelining must also be enabled in Elasticsearch for this to work properly. + + + + + Returns either the fixed maximum set on the connection configuration settings or the number of nodes + + + + + + Returns whether the current delegation over nodes took too long and we should quit. + if is set we'll use that timeout otherwise we default to th value of + which itself defaults to 60 seconds + + + + + Selects next node uri on request state + + bool hint whether the new current node needs to pinged first + + + + Determines whether the stream response is our final stream response: + IF response is success or known error + OR maxRetries is 0 and retried is 0 (maxRetries could change in between retries to 0) + AND sniff on connection fault does not find more nodes (causing maxRetry to grow) + AND maxretries is no retried + + + + + Sniffs when the cluster state is stale, when sniffing returns a 401 return a response for T to return directly + + + + + The querystring that should be appended to the path of the request + + + + + A method that can be set on the request to take ownership of creating the response object. + When set this will be called instead of the internal .Deserialize(); + + + + + Configuration for this specific request, i.e disable sniffing, custom timeouts etcetera. + + + + + The response status code is in the 200 range or is in the allowed list of status codes set on the request. + + + + + The request settings used by the request responsible for this response + + + + + If Success is false this will hold the original exception. + Can be a CLR exception or a mapped server side exception (ElasticsearchServerException) + + + + + The HTTP method used by the request + + + + + The url as requested + + + + + The status code as returned by Elasticsearch + + + + + The number of times to request had to be retried before succeeding on a live node + + + + + Returns timing and stats metric about the current API method invocation. + + + + + The raw byte response, only set when IncludeRawResponse() is set on Connection configuration + + + + + Helper interface used to hide the base members from the fluent API to make it much cleaner + in Visual Studio intellisense. + + Created by Daniel Cazzulino http://www.clariusconsulting.net/blogs/kzu/archive/2008/03/10/58301.aspx + + + + Hides the method. + + + + + Hides the method. + + + + + Hides the method. + + + + + Hides the method. + + + + + Raw operations with elasticsearch + 
+            This file is automatically generated from https://github.com/elasticsearch/elasticsearch-rest-api-spec
+
+ 
+            Generated of commit 
+
+ + + + + Perform any request you want over the configured IConnection synchronously while taking advantage of the cluster failover. + + The type representing the response JSON + the HTTP Method to use + The path of the the url that you would like to hit + The body of the request, string and byte[] are posted as is other types will be serialized to JSON + Optionally configure request specific timeouts, headers + An ElasticsearchResponse of T where T represents the JSON response body + + + + Perform any request you want over the configured IConnection asynchronously while taking advantage of the cluster failover. + + The type representing the response JSON + the HTTP Method to use + The path of the the url that you would like to hit + The body of the request, string and byte[] are posted as is other types will be serialized to JSON + Optionally configure request specific timeouts, headers + A task of ElasticsearchResponse of T where T represents the JSON response body + + + Represents a POST on /_bench/abort/{name} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-benchmark.html + + A benchmark name + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_bench/abort/{name} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-benchmark.html + + A benchmark name + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_bench/abort/{name} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-benchmark.html + + A benchmark name + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_bench/abort/{name} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-benchmark.html + + A benchmark name + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_bulk + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-bulk.html + + The operation definition and data (action-data pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_bulk + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-bulk.html + + The operation definition and data (action-data pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_bulk + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-bulk.html + + The operation definition and data (action-data pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_bulk + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-bulk.html + + The operation definition and data (action-data pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_bulk + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-bulk.html + + Default index for items which don't provide one + The operation definition and data (action-data pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_bulk + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-bulk.html + + Default index for items which don't provide one + The operation definition and data (action-data pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_bulk + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-bulk.html + + Default index for items which don't provide one + The operation definition and data (action-data pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_bulk + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-bulk.html + + Default index for items which don't provide one + The operation definition and data (action-data pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/_bulk + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-bulk.html + + Default index for items which don't provide one + Default document type for items which don't provide one + The operation definition and data (action-data pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/_bulk + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-bulk.html + + Default index for items which don't provide one + Default document type for items which don't provide one + The operation definition and data (action-data pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/_bulk + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-bulk.html + + Default index for items which don't provide one + Default document type for items which don't provide one + The operation definition and data (action-data pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/_bulk + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-bulk.html + + Default index for items which don't provide one + Default document type for items which don't provide one + The operation definition and data (action-data pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /_bulk + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-bulk.html + + The operation definition and data (action-data pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /_bulk + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-bulk.html + + The operation definition and data (action-data pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /_bulk + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-bulk.html + + The operation definition and data (action-data pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /_bulk + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-bulk.html + + The operation definition and data (action-data pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /{index}/_bulk + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-bulk.html + + Default index for items which don't provide one + The operation definition and data (action-data pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /{index}/_bulk + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-bulk.html + + Default index for items which don't provide one + The operation definition and data (action-data pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /{index}/_bulk + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-bulk.html + + Default index for items which don't provide one + The operation definition and data (action-data pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /{index}/_bulk + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-bulk.html + + Default index for items which don't provide one + The operation definition and data (action-data pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /{index}/{type}/_bulk + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-bulk.html + + Default index for items which don't provide one + Default document type for items which don't provide one + The operation definition and data (action-data pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /{index}/{type}/_bulk + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-bulk.html + + Default index for items which don't provide one + Default document type for items which don't provide one + The operation definition and data (action-data pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /{index}/{type}/_bulk + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-bulk.html + + Default index for items which don't provide one + Default document type for items which don't provide one + The operation definition and data (action-data pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /{index}/{type}/_bulk + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-bulk.html + + Default index for items which don't provide one + Default document type for items which don't provide one + The operation definition and data (action-data pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/aliases + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-aliases.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/aliases + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-aliases.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/aliases + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-aliases.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/aliases + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-aliases.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/aliases/{name} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-aliases.html + + A comma-separated list of alias names to return + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/aliases/{name} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-aliases.html + + A comma-separated list of alias names to return + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/aliases/{name} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-aliases.html + + A comma-separated list of alias names to return + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/aliases/{name} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-aliases.html + + A comma-separated list of alias names to return + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/allocation + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-allocation.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/allocation + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-allocation.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/allocation + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-allocation.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/allocation + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-allocation.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/allocation/{node_id} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-allocation.html + + A comma-separated list of node IDs or names to limit the returned information + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/allocation/{node_id} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-allocation.html + + A comma-separated list of node IDs or names to limit the returned information + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/allocation/{node_id} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-allocation.html + + A comma-separated list of node IDs or names to limit the returned information + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/allocation/{node_id} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-allocation.html + + A comma-separated list of node IDs or names to limit the returned information + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/count + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-count.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/count + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-count.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/count + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-count.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/count + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-count.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/count/{index} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-count.html + + A comma-separated list of index names to limit the returned information + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/count/{index} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-count.html + + A comma-separated list of index names to limit the returned information + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/count/{index} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-count.html + + A comma-separated list of index names to limit the returned information + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/count/{index} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-count.html + + A comma-separated list of index names to limit the returned information + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/fielddata + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/cat-fielddata.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/fielddata + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/cat-fielddata.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/fielddata + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/cat-fielddata.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/fielddata + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/cat-fielddata.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/health + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-health.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/health + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-health.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/health + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-health.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/health + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-health.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/indices + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-indices.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/indices + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-indices.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/indices + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-indices.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/indices + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-indices.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/indices/{index} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-indices.html + + A comma-separated list of index names to limit the returned information + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/indices/{index} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-indices.html + + A comma-separated list of index names to limit the returned information + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/indices/{index} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-indices.html + + A comma-separated list of index names to limit the returned information + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/indices/{index} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-indices.html + + A comma-separated list of index names to limit the returned information + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/master + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-master.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/master + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-master.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/master + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-master.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/master + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-master.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/nodes + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-nodes.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/nodes + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-nodes.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/nodes + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-nodes.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/nodes + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-nodes.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/pending_tasks + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-pending-tasks.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/pending_tasks + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-pending-tasks.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/pending_tasks + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-pending-tasks.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/pending_tasks + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-pending-tasks.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/plugins + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/cat-plugins.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/plugins + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/cat-plugins.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/plugins + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/cat-plugins.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/plugins + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/cat-plugins.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/recovery + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-recovery.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/recovery + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-recovery.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/recovery + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-recovery.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/recovery + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-recovery.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/recovery/{index} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-recovery.html + + A comma-separated list of index names to limit the returned information + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/recovery/{index} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-recovery.html + + A comma-separated list of index names to limit the returned information + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/recovery/{index} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-recovery.html + + A comma-separated list of index names to limit the returned information + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/recovery/{index} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-recovery.html + + A comma-separated list of index names to limit the returned information + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/shards + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-shards.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/shards + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-shards.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/shards + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-shards.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/shards + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-shards.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/shards/{index} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-shards.html + + A comma-separated list of index names to limit the returned information + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/shards/{index} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-shards.html + + A comma-separated list of index names to limit the returned information + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/shards/{index} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-shards.html + + A comma-separated list of index names to limit the returned information + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/shards/{index} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-shards.html + + A comma-separated list of index names to limit the returned information + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/thread_pool + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/cat-thread-pool.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/thread_pool + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/cat-thread-pool.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/thread_pool + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/cat-thread-pool.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/thread_pool + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/cat-thread-pool.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a DELETE on /_search/scroll/{scroll_id} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html + + A comma-separated list of scroll IDs to clear + A comma-separated list of scroll IDs to clear if none was specified via the scroll_id parameter + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a DELETE on /_search/scroll/{scroll_id} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html + + A comma-separated list of scroll IDs to clear + A comma-separated list of scroll IDs to clear if none was specified via the scroll_id parameter + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a DELETE on /_search/scroll/{scroll_id} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html + + A comma-separated list of scroll IDs to clear + A comma-separated list of scroll IDs to clear if none was specified via the scroll_id parameter + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a DELETE on /_search/scroll/{scroll_id} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html + + A comma-separated list of scroll IDs to clear + A comma-separated list of scroll IDs to clear if none was specified via the scroll_id parameter + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a DELETE on /_search/scroll + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html + + A comma-separated list of scroll IDs to clear if none was specified via the scroll_id parameter + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a DELETE on /_search/scroll + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html + + A comma-separated list of scroll IDs to clear if none was specified via the scroll_id parameter + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a DELETE on /_search/scroll + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html + + A comma-separated list of scroll IDs to clear if none was specified via the scroll_id parameter + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a DELETE on /_search/scroll + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html + + A comma-separated list of scroll IDs to clear if none was specified via the scroll_id parameter + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cluster/settings + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-update-settings.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cluster/settings + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-update-settings.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cluster/settings + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-update-settings.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cluster/settings + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-update-settings.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cluster/health + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-health.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cluster/health + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-health.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cluster/health + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-health.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cluster/health + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-health.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cluster/health/{index} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-health.html + + Limit the information returned to a specific index + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cluster/health/{index} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-health.html + + Limit the information returned to a specific index + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cluster/health/{index} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-health.html + + Limit the information returned to a specific index + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cluster/health/{index} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-health.html + + Limit the information returned to a specific index + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cluster/pending_tasks + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-pending.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cluster/pending_tasks + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-pending.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cluster/pending_tasks + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-pending.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cluster/pending_tasks + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-pending.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /_cluster/settings + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-update-settings.html + + The settings to be updated. Can be either `transient` or `persistent` (survives cluster restart). + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /_cluster/settings + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-update-settings.html + + The settings to be updated. Can be either `transient` or `persistent` (survives cluster restart). + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /_cluster/settings + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-update-settings.html + + The settings to be updated. Can be either `transient` or `persistent` (survives cluster restart). + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /_cluster/settings + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-update-settings.html + + The settings to be updated. Can be either `transient` or `persistent` (survives cluster restart). + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_cluster/reroute + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-reroute.html + + The definition of `commands` to perform (`move`, `cancel`, `allocate`) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_cluster/reroute + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-reroute.html + + The definition of `commands` to perform (`move`, `cancel`, `allocate`) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_cluster/reroute + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-reroute.html + + The definition of `commands` to perform (`move`, `cancel`, `allocate`) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_cluster/reroute + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-reroute.html + + The definition of `commands` to perform (`move`, `cancel`, `allocate`) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cluster/state + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-state.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cluster/state + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-state.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cluster/state + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-state.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cluster/state + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-state.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cluster/state/{metric} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-state.html + + Limit the information returned to the specified metrics + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cluster/state/{metric} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-state.html + + Limit the information returned to the specified metrics + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cluster/state/{metric} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-state.html + + Limit the information returned to the specified metrics + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cluster/state/{metric} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-state.html + + Limit the information returned to the specified metrics + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cluster/state/{metric}/{index} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-state.html + + Limit the information returned to the specified metrics + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cluster/state/{metric}/{index} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-state.html + + Limit the information returned to the specified metrics + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cluster/state/{metric}/{index} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-state.html + + Limit the information returned to the specified metrics + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cluster/state/{metric}/{index} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-state.html + + Limit the information returned to the specified metrics + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cluster/stats + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-stats.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cluster/stats + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-stats.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cluster/stats + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-stats.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cluster/stats + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-stats.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cluster/stats/nodes/{node_id} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-stats.html + + A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cluster/stats/nodes/{node_id} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-stats.html + + A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cluster/stats/nodes/{node_id} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-stats.html + + A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cluster/stats/nodes/{node_id} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-stats.html + + A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_count + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html + + A query to restrict the results specified with the Query DSL (optional) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_count + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html + + A query to restrict the results specified with the Query DSL (optional) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_count + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html + + A query to restrict the results specified with the Query DSL (optional) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_count + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html + + A query to restrict the results specified with the Query DSL (optional) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_count + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html + + A comma-separated list of indices to restrict the results + A query to restrict the results specified with the Query DSL (optional) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_count + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html + + A comma-separated list of indices to restrict the results + A query to restrict the results specified with the Query DSL (optional) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_count + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html + + A comma-separated list of indices to restrict the results + A query to restrict the results specified with the Query DSL (optional) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_count + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html + + A comma-separated list of indices to restrict the results + A query to restrict the results specified with the Query DSL (optional) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/_count + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html + + A comma-separated list of indices to restrict the results + A comma-separated list of types to restrict the results + A query to restrict the results specified with the Query DSL (optional) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/_count + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html + + A comma-separated list of indices to restrict the results + A comma-separated list of types to restrict the results + A query to restrict the results specified with the Query DSL (optional) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/_count + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html + + A comma-separated list of indices to restrict the results + A comma-separated list of types to restrict the results + A query to restrict the results specified with the Query DSL (optional) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/_count + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html + + A comma-separated list of indices to restrict the results + A comma-separated list of types to restrict the results + A query to restrict the results specified with the Query DSL (optional) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_count + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_count + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_count + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_count + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_count + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html + + A comma-separated list of indices to restrict the results + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_count + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html + + A comma-separated list of indices to restrict the results + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_count + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html + + A comma-separated list of indices to restrict the results + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_count + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html + + A comma-separated list of indices to restrict the results + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/_count + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html + + A comma-separated list of indices to restrict the results + A comma-separated list of types to restrict the results + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/_count + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html + + A comma-separated list of indices to restrict the results + A comma-separated list of types to restrict the results + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/_count + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html + + A comma-separated list of indices to restrict the results + A comma-separated list of types to restrict the results + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/_count + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html + + A comma-separated list of indices to restrict the results + A comma-separated list of types to restrict the results + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/_percolate/count + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being count percolated. + The type of the document being count percolated. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/_percolate/count + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being count percolated. + The type of the document being count percolated. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/_percolate/count + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being count percolated. + The type of the document being count percolated. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/_percolate/count + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being count percolated. + The type of the document being count percolated. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/{id}/_percolate/count + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being count percolated. + The type of the document being count percolated. + Substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/{id}/_percolate/count + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being count percolated. + The type of the document being count percolated. + Substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/{id}/_percolate/count + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being count percolated. + The type of the document being count percolated. + Substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/{id}/_percolate/count + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being count percolated. + The type of the document being count percolated. + Substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/_percolate/count + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being count percolated. + The type of the document being count percolated. + The count percolator request definition using the percolate DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/_percolate/count + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being count percolated. + The type of the document being count percolated. + The count percolator request definition using the percolate DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/_percolate/count + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being count percolated. + The type of the document being count percolated. + The count percolator request definition using the percolate DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/_percolate/count + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being count percolated. + The type of the document being count percolated. + The count percolator request definition using the percolate DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/{id}/_percolate/count + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being count percolated. + The type of the document being count percolated. + Substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster. + The count percolator request definition using the percolate DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/{id}/_percolate/count + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being count percolated. + The type of the document being count percolated. + Substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster. + The count percolator request definition using the percolate DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/{id}/_percolate/count + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being count percolated. + The type of the document being count percolated. + Substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster. + The count percolator request definition using the percolate DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/{id}/_percolate/count + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being count percolated. + The type of the document being count percolated. + Substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster. + The count percolator request definition using the percolate DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a DELETE on /{index}/{type}/{id} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-delete.html + + The name of the index + The type of the document + The document ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a DELETE on /{index}/{type}/{id} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-delete.html + + The name of the index + The type of the document + The document ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a DELETE on /{index}/{type}/{id} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-delete.html + + The name of the index + The type of the document + The document ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a DELETE on /{index}/{type}/{id} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-delete.html + + The name of the index + The type of the document + The document ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a DELETE on /{index}/_query + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-delete-by-query.html + + A comma-separated list of indices to restrict the operation; use `_all` to perform the operation on all indices + A query to restrict the operation specified with the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a DELETE on /{index}/_query + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-delete-by-query.html + + A comma-separated list of indices to restrict the operation; use `_all` to perform the operation on all indices + A query to restrict the operation specified with the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a DELETE on /{index}/_query + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-delete-by-query.html + + A comma-separated list of indices to restrict the operation; use `_all` to perform the operation on all indices + A query to restrict the operation specified with the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a DELETE on /{index}/_query + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-delete-by-query.html + + A comma-separated list of indices to restrict the operation; use `_all` to perform the operation on all indices + A query to restrict the operation specified with the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a DELETE on /{index}/{type}/_query + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-delete-by-query.html + + A comma-separated list of indices to restrict the operation; use `_all` to perform the operation on all indices + A comma-separated list of types to restrict the operation + A query to restrict the operation specified with the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a DELETE on /{index}/{type}/_query + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-delete-by-query.html + + A comma-separated list of indices to restrict the operation; use `_all` to perform the operation on all indices + A comma-separated list of types to restrict the operation + A query to restrict the operation specified with the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a DELETE on /{index}/{type}/_query + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-delete-by-query.html + + A comma-separated list of indices to restrict the operation; use `_all` to perform the operation on all indices + A comma-separated list of types to restrict the operation + A query to restrict the operation specified with the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a DELETE on /{index}/{type}/_query + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-delete-by-query.html + + A comma-separated list of indices to restrict the operation; use `_all` to perform the operation on all indices + A comma-separated list of types to restrict the operation + A query to restrict the operation specified with the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a DELETE on /_scripts/{lang}/{id} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html + + Script language + Script ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a DELETE on /_scripts/{lang}/{id} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html + + Script language + Script ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a DELETE on /_scripts/{lang}/{id} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html + + Script language + Script ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a DELETE on /_scripts/{lang}/{id} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html + + Script language + Script ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a DELETE on /_search/template/{id} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html + + Template ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a DELETE on /_search/template/{id} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html + + Template ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a DELETE on /_search/template/{id} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html + + Template ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a DELETE on /_search/template/{id} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html + + Template ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a HEAD on /{index}/{type}/{id} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-get.html + + The name of the index + The type of the document (use `_all` to fetch the first document matching the ID across all types) + The document ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a HEAD on /{index}/{type}/{id} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-get.html + + The name of the index + The type of the document (use `_all` to fetch the first document matching the ID across all types) + The document ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a HEAD on /{index}/{type}/{id} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-get.html + + The name of the index + The type of the document (use `_all` to fetch the first document matching the ID across all types) + The document ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a HEAD on /{index}/{type}/{id} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-get.html + + The name of the index + The type of the document (use `_all` to fetch the first document matching the ID across all types) + The document ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/{id}/_explain + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-explain.html + + The name of the index + The type of the document + The document ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/{id}/_explain + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-explain.html + + The name of the index + The type of the document + The document ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/{id}/_explain + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-explain.html + + The name of the index + The type of the document + The document ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/{id}/_explain + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-explain.html + + The name of the index + The type of the document + The document ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/{id}/_explain + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-explain.html + + The name of the index + The type of the document + The document ID + The query definition using the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/{id}/_explain + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-explain.html + + The name of the index + The type of the document + The document ID + The query definition using the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/{id}/_explain + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-explain.html + + The name of the index + The type of the document + The document ID + The query definition using the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/{id}/_explain + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-explain.html + + The name of the index + The type of the document + The document ID + The query definition using the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/{id} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-get.html + + The name of the index + The type of the document (use `_all` to fetch the first document matching the ID across all types) + The document ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/{id} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-get.html + + The name of the index + The type of the document (use `_all` to fetch the first document matching the ID across all types) + The document ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/{id} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-get.html + + The name of the index + The type of the document (use `_all` to fetch the first document matching the ID across all types) + The document ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/{id} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-get.html + + The name of the index + The type of the document (use `_all` to fetch the first document matching the ID across all types) + The document ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_scripts/{lang}/{id} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html + + Script language + Script ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_scripts/{lang}/{id} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html + + Script language + Script ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_scripts/{lang}/{id} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html + + Script language + Script ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_scripts/{lang}/{id} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html + + Script language + Script ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/{id}/_source + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-get.html + + The name of the index + The type of the document; use `_all` to fetch the first document matching the ID across all types + The document ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/{id}/_source + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-get.html + + The name of the index + The type of the document; use `_all` to fetch the first document matching the ID across all types + The document ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/{id}/_source + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-get.html + + The name of the index + The type of the document; use `_all` to fetch the first document matching the ID across all types + The document ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/{id}/_source + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-get.html + + The name of the index + The type of the document; use `_all` to fetch the first document matching the ID across all types + The document ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_search/template/{id} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html + + Template ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_search/template/{id} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html + + Template ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_search/template/{id} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html + + Template ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_search/template/{id} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html + + Template ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-index_.html + + The name of the index + The type of the document + The document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-index_.html + + The name of the index + The type of the document + The document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-index_.html + + The name of the index + The type of the document + The document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-index_.html + + The name of the index + The type of the document + The document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/{id} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-index_.html + + The name of the index + The type of the document + Document ID + The document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/{id} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-index_.html + + The name of the index + The type of the document + Document ID + The document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/{id} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-index_.html + + The name of the index + The type of the document + Document ID + The document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/{id} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-index_.html + + The name of the index + The type of the document + Document ID + The document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /{index}/{type} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-index_.html + + The name of the index + The type of the document + The document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /{index}/{type} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-index_.html + + The name of the index + The type of the document + The document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /{index}/{type} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-index_.html + + The name of the index + The type of the document + The document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /{index}/{type} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-index_.html + + The name of the index + The type of the document + The document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /{index}/{type}/{id} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-index_.html + + The name of the index + The type of the document + Document ID + The document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /{index}/{type}/{id} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-index_.html + + The name of the index + The type of the document + Document ID + The document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /{index}/{type}/{id} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-index_.html + + The name of the index + The type of the document + Document ID + The document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /{index}/{type}/{id} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-index_.html + + The name of the index + The type of the document + Document ID + The document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_analyze + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-analyze.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_analyze + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-analyze.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_analyze + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-analyze.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_analyze + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-analyze.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_analyze + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-analyze.html + + The name of the index to scope the operation + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_analyze + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-analyze.html + + The name of the index to scope the operation + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_analyze + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-analyze.html + + The name of the index to scope the operation + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_analyze + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-analyze.html + + The name of the index to scope the operation + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_analyze + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-analyze.html + + The text on which the analysis should be performed + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_analyze + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-analyze.html + + The text on which the analysis should be performed + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_analyze + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-analyze.html + + The text on which the analysis should be performed + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_analyze + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-analyze.html + + The text on which the analysis should be performed + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_analyze + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-analyze.html + + The name of the index to scope the operation + The text on which the analysis should be performed + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_analyze + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-analyze.html + + The name of the index to scope the operation + The text on which the analysis should be performed + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_analyze + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-analyze.html + + The name of the index to scope the operation + The text on which the analysis should be performed + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_analyze + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-analyze.html + + The name of the index to scope the operation + The text on which the analysis should be performed + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_cache/clear + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-clearcache.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_cache/clear + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-clearcache.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_cache/clear + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-clearcache.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_cache/clear + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-clearcache.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_cache/clear + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-clearcache.html + + A comma-separated list of index name to limit the operation + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_cache/clear + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-clearcache.html + + A comma-separated list of index name to limit the operation + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_cache/clear + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-clearcache.html + + A comma-separated list of index name to limit the operation + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_cache/clear + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-clearcache.html + + A comma-separated list of index name to limit the operation + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cache/clear + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-clearcache.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cache/clear + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-clearcache.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cache/clear + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-clearcache.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cache/clear + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-clearcache.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_cache/clear + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-clearcache.html + + A comma-separated list of index name to limit the operation + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_cache/clear + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-clearcache.html + + A comma-separated list of index name to limit the operation + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_cache/clear + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-clearcache.html + + A comma-separated list of index name to limit the operation + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_cache/clear + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-clearcache.html + + A comma-separated list of index name to limit the operation + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_close + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-open-close.html + + The name of the index + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_close + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-open-close.html + + The name of the index + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_close + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-open-close.html + + The name of the index + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_close + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-open-close.html + + The name of the index + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /{index} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-create-index.html + + The name of the index + The configuration for the index (`settings` and `mappings`) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /{index} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-create-index.html + + The name of the index + The configuration for the index (`settings` and `mappings`) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /{index} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-create-index.html + + The name of the index + The configuration for the index (`settings` and `mappings`) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /{index} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-create-index.html + + The name of the index + The configuration for the index (`settings` and `mappings`) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-create-index.html + + The name of the index + The configuration for the index (`settings` and `mappings`) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-create-index.html + + The name of the index + The configuration for the index (`settings` and `mappings`) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-create-index.html + + The name of the index + The configuration for the index (`settings` and `mappings`) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-create-index.html + + The name of the index + The configuration for the index (`settings` and `mappings`) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a DELETE on /{index} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-delete-index.html + + A comma-separated list of indices to delete; use `_all` or `*` string to delete all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a DELETE on /{index} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-delete-index.html + + A comma-separated list of indices to delete; use `_all` or `*` string to delete all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a DELETE on /{index} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-delete-index.html + + A comma-separated list of indices to delete; use `_all` or `*` string to delete all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a DELETE on /{index} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-delete-index.html + + A comma-separated list of indices to delete; use `_all` or `*` string to delete all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a DELETE on /{index}/_alias/{name} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names (supports wildcards); use `_all` for all indices + A comma-separated list of aliases to delete (supports wildcards); use `_all` to delete all aliases for the specified indices. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a DELETE on /{index}/_alias/{name} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names (supports wildcards); use `_all` for all indices + A comma-separated list of aliases to delete (supports wildcards); use `_all` to delete all aliases for the specified indices. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a DELETE on /{index}/_alias/{name} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names (supports wildcards); use `_all` for all indices + A comma-separated list of aliases to delete (supports wildcards); use `_all` to delete all aliases for the specified indices. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a DELETE on /{index}/_alias/{name} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names (supports wildcards); use `_all` for all indices + A comma-separated list of aliases to delete (supports wildcards); use `_all` to delete all aliases for the specified indices. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a DELETE on /{index}/{type}/_mapping + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-delete-mapping.html + + A comma-separated list of index names (supports wildcards); use `_all` for all indices + A comma-separated list of document types to delete (supports wildcards); use `_all` to delete all document types in the specified indices. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a DELETE on /{index}/{type}/_mapping + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-delete-mapping.html + + A comma-separated list of index names (supports wildcards); use `_all` for all indices + A comma-separated list of document types to delete (supports wildcards); use `_all` to delete all document types in the specified indices. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a DELETE on /{index}/{type}/_mapping + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-delete-mapping.html + + A comma-separated list of index names (supports wildcards); use `_all` for all indices + A comma-separated list of document types to delete (supports wildcards); use `_all` to delete all document types in the specified indices. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a DELETE on /{index}/{type}/_mapping + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-delete-mapping.html + + A comma-separated list of index names (supports wildcards); use `_all` for all indices + A comma-separated list of document types to delete (supports wildcards); use `_all` to delete all document types in the specified indices. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a DELETE on /_template/{name} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html + + The name of the template + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a DELETE on /_template/{name} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html + + The name of the template + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a DELETE on /_template/{name} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html + + The name of the template + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a DELETE on /_template/{name} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html + + The name of the template + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a DELETE on /{index}/_warmer/{name} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + A comma-separated list of index names to delete warmers from (supports wildcards); use `_all` to perform the operation on all indices. + A comma-separated list of warmer names to delete (supports wildcards); use `_all` to delete all warmers in the specified indices. You must specify a name either in the uri or in the parameters. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a DELETE on /{index}/_warmer/{name} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + A comma-separated list of index names to delete warmers from (supports wildcards); use `_all` to perform the operation on all indices. + A comma-separated list of warmer names to delete (supports wildcards); use `_all` to delete all warmers in the specified indices. You must specify a name either in the uri or in the parameters. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a DELETE on /{index}/_warmer/{name} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + A comma-separated list of index names to delete warmers from (supports wildcards); use `_all` to perform the operation on all indices. + A comma-separated list of warmer names to delete (supports wildcards); use `_all` to delete all warmers in the specified indices. You must specify a name either in the uri or in the parameters. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a DELETE on /{index}/_warmer/{name} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + A comma-separated list of index names to delete warmers from (supports wildcards); use `_all` to perform the operation on all indices. + A comma-separated list of warmer names to delete (supports wildcards); use `_all` to delete all warmers in the specified indices. You must specify a name either in the uri or in the parameters. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a HEAD on /{index} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-settings.html + + A comma-separated list of indices to check + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a HEAD on /{index} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-settings.html + + A comma-separated list of indices to check + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a HEAD on /{index} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-settings.html + + A comma-separated list of indices to check + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a HEAD on /{index} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-settings.html + + A comma-separated list of indices to check + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a HEAD on /_alias/{name} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of alias names to return + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a HEAD on /_alias/{name} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of alias names to return + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a HEAD on /_alias/{name} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of alias names to return + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a HEAD on /_alias/{name} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of alias names to return + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a HEAD on /{index}/_alias/{name} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names to filter aliases + A comma-separated list of alias names to return + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a HEAD on /{index}/_alias/{name} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names to filter aliases + A comma-separated list of alias names to return + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a HEAD on /{index}/_alias/{name} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names to filter aliases + A comma-separated list of alias names to return + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a HEAD on /{index}/_alias/{name} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names to filter aliases + A comma-separated list of alias names to return + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a HEAD on /{index}/_alias + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names to filter aliases + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a HEAD on /{index}/_alias + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names to filter aliases + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a HEAD on /{index}/_alias + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names to filter aliases + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a HEAD on /{index}/_alias + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names to filter aliases + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a HEAD on /_template/{name} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html + + The name of the template + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a HEAD on /_template/{name} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html + + The name of the template + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a HEAD on /_template/{name} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html + + The name of the template + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a HEAD on /_template/{name} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html + + The name of the template + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a HEAD on /{index}/{type} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-types-exists.html + + A comma-separated list of index names; use `_all` to check the types across all indices + A comma-separated list of document types to check + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a HEAD on /{index}/{type} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-types-exists.html + + A comma-separated list of index names; use `_all` to check the types across all indices + A comma-separated list of document types to check + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a HEAD on /{index}/{type} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-types-exists.html + + A comma-separated list of index names; use `_all` to check the types across all indices + A comma-separated list of document types to check + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a HEAD on /{index}/{type} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-types-exists.html + + A comma-separated list of index names; use `_all` to check the types across all indices + A comma-separated list of document types to check + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_flush + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-flush.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_flush + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-flush.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_flush + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-flush.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_flush + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-flush.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_flush + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-flush.html + + A comma-separated list of index names; use `_all` or empty string for all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_flush + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-flush.html + + A comma-separated list of index names; use `_all` or empty string for all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_flush + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-flush.html + + A comma-separated list of index names; use `_all` or empty string for all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_flush + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-flush.html + + A comma-separated list of index names; use `_all` or empty string for all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_flush + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-flush.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_flush + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-flush.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_flush + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-flush.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_flush + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-flush.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_flush + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-flush.html + + A comma-separated list of index names; use `_all` or empty string for all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_flush + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-flush.html + + A comma-separated list of index names; use `_all` or empty string for all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_flush + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-flush.html + + A comma-separated list of index names; use `_all` or empty string for all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_flush + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-flush.html + + A comma-separated list of index names; use `_all` or empty string for all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_alias + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_alias + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_alias + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_alias + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_alias/{name} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of alias names to return + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_alias/{name} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of alias names to return + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_alias/{name} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of alias names to return + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_alias/{name} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of alias names to return + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_alias/{name} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names to filter aliases + A comma-separated list of alias names to return + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_alias/{name} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names to filter aliases + A comma-separated list of alias names to return + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_alias/{name} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names to filter aliases + A comma-separated list of alias names to return + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_alias/{name} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names to filter aliases + A comma-separated list of alias names to return + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_alias + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names to filter aliases + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_alias + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names to filter aliases + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_alias + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names to filter aliases + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_alias + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names to filter aliases + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_aliases + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_aliases + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_aliases + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_aliases + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_aliases + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names to filter aliases + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_aliases + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names to filter aliases + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_aliases + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names to filter aliases + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_aliases + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names to filter aliases + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_aliases/{name} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names to filter aliases + A comma-separated list of alias names to filter + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_aliases/{name} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names to filter aliases + A comma-separated list of alias names to filter + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_aliases/{name} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names to filter aliases + A comma-separated list of alias names to filter + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_aliases/{name} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names to filter aliases + A comma-separated list of alias names to filter + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_aliases/{name} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of alias names to filter + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_aliases/{name} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of alias names to filter + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_aliases/{name} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of alias names to filter + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_aliases/{name} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of alias names to filter + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_mapping/field/{field} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-field-mapping.html + + A comma-separated list of fields + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_mapping/field/{field} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-field-mapping.html + + A comma-separated list of fields + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_mapping/field/{field} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-field-mapping.html + + A comma-separated list of fields + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_mapping/field/{field} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-field-mapping.html + + A comma-separated list of fields + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_mapping/field/{field} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-field-mapping.html + + A comma-separated list of index names + A comma-separated list of fields + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_mapping/field/{field} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-field-mapping.html + + A comma-separated list of index names + A comma-separated list of fields + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_mapping/field/{field} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-field-mapping.html + + A comma-separated list of index names + A comma-separated list of fields + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_mapping/field/{field} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-field-mapping.html + + A comma-separated list of index names + A comma-separated list of fields + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_mapping/{type}/field/{field} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-field-mapping.html + + A comma-separated list of document types + A comma-separated list of fields + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_mapping/{type}/field/{field} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-field-mapping.html + + A comma-separated list of document types + A comma-separated list of fields + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_mapping/{type}/field/{field} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-field-mapping.html + + A comma-separated list of document types + A comma-separated list of fields + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_mapping/{type}/field/{field} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-field-mapping.html + + A comma-separated list of document types + A comma-separated list of fields + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_mapping/{type}/field/{field} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-field-mapping.html + + A comma-separated list of index names + A comma-separated list of document types + A comma-separated list of fields + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_mapping/{type}/field/{field} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-field-mapping.html + + A comma-separated list of index names + A comma-separated list of document types + A comma-separated list of fields + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_mapping/{type}/field/{field} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-field-mapping.html + + A comma-separated list of index names + A comma-separated list of document types + A comma-separated list of fields + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_mapping/{type}/field/{field} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-field-mapping.html + + A comma-separated list of index names + A comma-separated list of document types + A comma-separated list of fields + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_mapping + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_mapping + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_mapping + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_mapping + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_mapping + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html + + A comma-separated list of index names + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_mapping + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html + + A comma-separated list of index names + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_mapping + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html + + A comma-separated list of index names + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_mapping + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html + + A comma-separated list of index names + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_mapping/{type} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html + + A comma-separated list of document types + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_mapping/{type} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html + + A comma-separated list of document types + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_mapping/{type} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html + + A comma-separated list of document types + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_mapping/{type} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html + + A comma-separated list of document types + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_mapping/{type} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html + + A comma-separated list of index names + A comma-separated list of document types + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_mapping/{type} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html + + A comma-separated list of index names + A comma-separated list of document types + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_mapping/{type} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html + + A comma-separated list of index names + A comma-separated list of document types + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_mapping/{type} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html + + A comma-separated list of index names + A comma-separated list of document types + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_settings + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_settings + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_settings + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_settings + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_settings + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_settings + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_settings + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_settings + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_settings/{name} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + The name of the settings that should be included + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_settings/{name} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + The name of the settings that should be included + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_settings/{name} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + The name of the settings that should be included + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_settings/{name} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + The name of the settings that should be included + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_settings/{name} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html + + The name of the settings that should be included + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_settings/{name} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html + + The name of the settings that should be included + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_settings/{name} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html + + The name of the settings that should be included + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_settings/{name} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html + + The name of the settings that should be included + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_template + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_template + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_template + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_template + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_template/{name} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html + + The name of the template + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_template/{name} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html + + The name of the template + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_template/{name} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html + + The name of the template + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_template/{name} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html + + The name of the template + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_warmer + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_warmer + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_warmer + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_warmer + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_warmer + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + A comma-separated list of index names to restrict the operation; use `_all` to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_warmer + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + A comma-separated list of index names to restrict the operation; use `_all` to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_warmer + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + A comma-separated list of index names to restrict the operation; use `_all` to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_warmer + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + A comma-separated list of index names to restrict the operation; use `_all` to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_warmer/{name} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + A comma-separated list of index names to restrict the operation; use `_all` to perform the operation on all indices + The name of the warmer (supports wildcards); leave empty to get all warmers + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_warmer/{name} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + A comma-separated list of index names to restrict the operation; use `_all` to perform the operation on all indices + The name of the warmer (supports wildcards); leave empty to get all warmers + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_warmer/{name} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + A comma-separated list of index names to restrict the operation; use `_all` to perform the operation on all indices + The name of the warmer (supports wildcards); leave empty to get all warmers + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_warmer/{name} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + A comma-separated list of index names to restrict the operation; use `_all` to perform the operation on all indices + The name of the warmer (supports wildcards); leave empty to get all warmers + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_warmer/{name} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + The name of the warmer (supports wildcards); leave empty to get all warmers + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_warmer/{name} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + The name of the warmer (supports wildcards); leave empty to get all warmers + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_warmer/{name} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + The name of the warmer (supports wildcards); leave empty to get all warmers + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_warmer/{name} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + The name of the warmer (supports wildcards); leave empty to get all warmers + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/_warmer/{name} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + A comma-separated list of index names to restrict the operation; use `_all` to perform the operation on all indices + A comma-separated list of document types to restrict the operation; leave empty to perform the operation on all types + The name of the warmer (supports wildcards); leave empty to get all warmers + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/_warmer/{name} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + A comma-separated list of index names to restrict the operation; use `_all` to perform the operation on all indices + A comma-separated list of document types to restrict the operation; leave empty to perform the operation on all types + The name of the warmer (supports wildcards); leave empty to get all warmers + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/_warmer/{name} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + A comma-separated list of index names to restrict the operation; use `_all` to perform the operation on all indices + A comma-separated list of document types to restrict the operation; leave empty to perform the operation on all types + The name of the warmer (supports wildcards); leave empty to get all warmers + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/_warmer/{name} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + A comma-separated list of index names to restrict the operation; use `_all` to perform the operation on all indices + A comma-separated list of document types to restrict the operation; leave empty to perform the operation on all types + The name of the warmer (supports wildcards); leave empty to get all warmers + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_open + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-open-close.html + + The name of the index + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_open + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-open-close.html + + The name of the index + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_open + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-open-close.html + + The name of the index + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_open + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-open-close.html + + The name of the index + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_optimize + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-optimize.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_optimize + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-optimize.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_optimize + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-optimize.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_optimize + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-optimize.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_optimize + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-optimize.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_optimize + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-optimize.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_optimize + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-optimize.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_optimize + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-optimize.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_optimize + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-optimize.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_optimize + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-optimize.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_optimize + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-optimize.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_optimize + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-optimize.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_optimize + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-optimize.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_optimize + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-optimize.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_optimize + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-optimize.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_optimize + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-optimize.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /{index}/_alias/{name} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names the alias should point to (supports wildcards); use `_all` or omit to perform the operation on all indices. + The name of the alias to be created or updated + The settings for the alias, such as `routing` or `filter` + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /{index}/_alias/{name} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names the alias should point to (supports wildcards); use `_all` or omit to perform the operation on all indices. + The name of the alias to be created or updated + The settings for the alias, such as `routing` or `filter` + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /{index}/_alias/{name} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names the alias should point to (supports wildcards); use `_all` or omit to perform the operation on all indices. + The name of the alias to be created or updated + The settings for the alias, such as `routing` or `filter` + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /{index}/_alias/{name} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names the alias should point to (supports wildcards); use `_all` or omit to perform the operation on all indices. + The name of the alias to be created or updated + The settings for the alias, such as `routing` or `filter` + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /_alias/{name} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + The name of the alias to be created or updated + The settings for the alias, such as `routing` or `filter` + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /_alias/{name} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + The name of the alias to be created or updated + The settings for the alias, such as `routing` or `filter` + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /_alias/{name} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + The name of the alias to be created or updated + The settings for the alias, such as `routing` or `filter` + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /_alias/{name} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + The name of the alias to be created or updated + The settings for the alias, such as `routing` or `filter` + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_alias/{name} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names the alias should point to (supports wildcards); use `_all` or omit to perform the operation on all indices. + The name of the alias to be created or updated + The settings for the alias, such as `routing` or `filter` + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_alias/{name} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names the alias should point to (supports wildcards); use `_all` or omit to perform the operation on all indices. + The name of the alias to be created or updated + The settings for the alias, such as `routing` or `filter` + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_alias/{name} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names the alias should point to (supports wildcards); use `_all` or omit to perform the operation on all indices. + The name of the alias to be created or updated + The settings for the alias, such as `routing` or `filter` + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_alias/{name} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names the alias should point to (supports wildcards); use `_all` or omit to perform the operation on all indices. + The name of the alias to be created or updated + The settings for the alias, such as `routing` or `filter` + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_alias/{name} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + The name of the alias to be created or updated + The settings for the alias, such as `routing` or `filter` + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_alias/{name} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + The name of the alias to be created or updated + The settings for the alias, such as `routing` or `filter` + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_alias/{name} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + The name of the alias to be created or updated + The settings for the alias, such as `routing` or `filter` + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_alias/{name} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + The name of the alias to be created or updated + The settings for the alias, such as `routing` or `filter` + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /{index}/{type}/_mapping + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-put-mapping.html + + A comma-separated list of index names the mapping should be added to (supports wildcards); use `_all` or omit to add the mapping on all indices. + The name of the document type + The mapping definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /{index}/{type}/_mapping + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-put-mapping.html + + A comma-separated list of index names the mapping should be added to (supports wildcards); use `_all` or omit to add the mapping on all indices. + The name of the document type + The mapping definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /{index}/{type}/_mapping + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-put-mapping.html + + A comma-separated list of index names the mapping should be added to (supports wildcards); use `_all` or omit to add the mapping on all indices. + The name of the document type + The mapping definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /{index}/{type}/_mapping + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-put-mapping.html + + A comma-separated list of index names the mapping should be added to (supports wildcards); use `_all` or omit to add the mapping on all indices. + The name of the document type + The mapping definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /_mapping/{type} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-put-mapping.html + + The name of the document type + The mapping definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /_mapping/{type} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-put-mapping.html + + The name of the document type + The mapping definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /_mapping/{type} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-put-mapping.html + + The name of the document type + The mapping definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /_mapping/{type} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-put-mapping.html + + The name of the document type + The mapping definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/_mapping + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-put-mapping.html + + A comma-separated list of index names the mapping should be added to (supports wildcards); use `_all` or omit to add the mapping on all indices. + The name of the document type + The mapping definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/_mapping + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-put-mapping.html + + A comma-separated list of index names the mapping should be added to (supports wildcards); use `_all` or omit to add the mapping on all indices. + The name of the document type + The mapping definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/_mapping + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-put-mapping.html + + A comma-separated list of index names the mapping should be added to (supports wildcards); use `_all` or omit to add the mapping on all indices. + The name of the document type + The mapping definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/_mapping + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-put-mapping.html + + A comma-separated list of index names the mapping should be added to (supports wildcards); use `_all` or omit to add the mapping on all indices. + The name of the document type + The mapping definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_mapping/{type} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-put-mapping.html + + The name of the document type + The mapping definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_mapping/{type} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-put-mapping.html + + The name of the document type + The mapping definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_mapping/{type} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-put-mapping.html + + The name of the document type + The mapping definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_mapping/{type} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-put-mapping.html + + The name of the document type + The mapping definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /_settings + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-update-settings.html + + The index settings to be updated + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /_settings + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-update-settings.html + + The index settings to be updated + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /_settings + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-update-settings.html + + The index settings to be updated + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /_settings + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-update-settings.html + + The index settings to be updated + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /{index}/_settings + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-update-settings.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + The index settings to be updated + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /{index}/_settings + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-update-settings.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + The index settings to be updated + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /{index}/_settings + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-update-settings.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + The index settings to be updated + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /{index}/_settings + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-update-settings.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + The index settings to be updated + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /_template/{name} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html + + The name of the template + The template definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /_template/{name} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html + + The name of the template + The template definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /_template/{name} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html + + The name of the template + The template definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /_template/{name} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html + + The name of the template + The template definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_template/{name} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html + + The name of the template + The template definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_template/{name} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html + + The name of the template + The template definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_template/{name} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html + + The name of the template + The template definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_template/{name} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html + + The name of the template + The template definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /_warmer/{name} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + The name of the warmer + The search request definition for the warmer (query, filters, facets, sorting, etc) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /_warmer/{name} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + The name of the warmer + The search request definition for the warmer (query, filters, facets, sorting, etc) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /_warmer/{name} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + The name of the warmer + The search request definition for the warmer (query, filters, facets, sorting, etc) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /_warmer/{name} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + The name of the warmer + The search request definition for the warmer (query, filters, facets, sorting, etc) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /{index}/_warmer/{name} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + A comma-separated list of index names to register the warmer for; use `_all` or omit to perform the operation on all indices + The name of the warmer + The search request definition for the warmer (query, filters, facets, sorting, etc) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /{index}/_warmer/{name} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + A comma-separated list of index names to register the warmer for; use `_all` or omit to perform the operation on all indices + The name of the warmer + The search request definition for the warmer (query, filters, facets, sorting, etc) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /{index}/_warmer/{name} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + A comma-separated list of index names to register the warmer for; use `_all` or omit to perform the operation on all indices + The name of the warmer + The search request definition for the warmer (query, filters, facets, sorting, etc) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /{index}/_warmer/{name} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + A comma-separated list of index names to register the warmer for; use `_all` or omit to perform the operation on all indices + The name of the warmer + The search request definition for the warmer (query, filters, facets, sorting, etc) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /{index}/{type}/_warmer/{name} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + A comma-separated list of index names to register the warmer for; use `_all` or omit to perform the operation on all indices + A comma-separated list of document types to register the warmer for; leave empty to perform the operation on all types + The name of the warmer + The search request definition for the warmer (query, filters, facets, sorting, etc) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /{index}/{type}/_warmer/{name} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + A comma-separated list of index names to register the warmer for; use `_all` or omit to perform the operation on all indices + A comma-separated list of document types to register the warmer for; leave empty to perform the operation on all types + The name of the warmer + The search request definition for the warmer (query, filters, facets, sorting, etc) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /{index}/{type}/_warmer/{name} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + A comma-separated list of index names to register the warmer for; use `_all` or omit to perform the operation on all indices + A comma-separated list of document types to register the warmer for; leave empty to perform the operation on all types + The name of the warmer + The search request definition for the warmer (query, filters, facets, sorting, etc) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /{index}/{type}/_warmer/{name} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + A comma-separated list of index names to register the warmer for; use `_all` or omit to perform the operation on all indices + A comma-separated list of document types to register the warmer for; leave empty to perform the operation on all types + The name of the warmer + The search request definition for the warmer (query, filters, facets, sorting, etc) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_warmer/{name} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + The name of the warmer + The search request definition for the warmer (query, filters, facets, sorting, etc) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_warmer/{name} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + The name of the warmer + The search request definition for the warmer (query, filters, facets, sorting, etc) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_warmer/{name} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + The name of the warmer + The search request definition for the warmer (query, filters, facets, sorting, etc) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_warmer/{name} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + The name of the warmer + The search request definition for the warmer (query, filters, facets, sorting, etc) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_warmer/{name} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + A comma-separated list of index names to register the warmer for; use `_all` or omit to perform the operation on all indices + The name of the warmer + The search request definition for the warmer (query, filters, facets, sorting, etc) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_warmer/{name} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + A comma-separated list of index names to register the warmer for; use `_all` or omit to perform the operation on all indices + The name of the warmer + The search request definition for the warmer (query, filters, facets, sorting, etc) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_warmer/{name} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + A comma-separated list of index names to register the warmer for; use `_all` or omit to perform the operation on all indices + The name of the warmer + The search request definition for the warmer (query, filters, facets, sorting, etc) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_warmer/{name} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + A comma-separated list of index names to register the warmer for; use `_all` or omit to perform the operation on all indices + The name of the warmer + The search request definition for the warmer (query, filters, facets, sorting, etc) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/_warmer/{name} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + A comma-separated list of index names to register the warmer for; use `_all` or omit to perform the operation on all indices + A comma-separated list of document types to register the warmer for; leave empty to perform the operation on all types + The name of the warmer + The search request definition for the warmer (query, filters, facets, sorting, etc) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/_warmer/{name} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + A comma-separated list of index names to register the warmer for; use `_all` or omit to perform the operation on all indices + A comma-separated list of document types to register the warmer for; leave empty to perform the operation on all types + The name of the warmer + The search request definition for the warmer (query, filters, facets, sorting, etc) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/_warmer/{name} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + A comma-separated list of index names to register the warmer for; use `_all` or omit to perform the operation on all indices + A comma-separated list of document types to register the warmer for; leave empty to perform the operation on all types + The name of the warmer + The search request definition for the warmer (query, filters, facets, sorting, etc) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/_warmer/{name} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + A comma-separated list of index names to register the warmer for; use `_all` or omit to perform the operation on all indices + A comma-separated list of document types to register the warmer for; leave empty to perform the operation on all types + The name of the warmer + The search request definition for the warmer (query, filters, facets, sorting, etc) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_recovery + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/indices-recovery.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_recovery + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/indices-recovery.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_recovery + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/indices-recovery.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_recovery + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/indices-recovery.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_recovery + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/indices-recovery.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_recovery + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/indices-recovery.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_recovery + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/indices-recovery.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_recovery + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/indices-recovery.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_refresh + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-refresh.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_refresh + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-refresh.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_refresh + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-refresh.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_refresh + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-refresh.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_refresh + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-refresh.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_refresh + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-refresh.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_refresh + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-refresh.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_refresh + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-refresh.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_refresh + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-refresh.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_refresh + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-refresh.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_refresh + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-refresh.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_refresh + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-refresh.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_refresh + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-refresh.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_refresh + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-refresh.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_refresh + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-refresh.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_refresh + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-refresh.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_segments + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-segments.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_segments + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-segments.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_segments + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-segments.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_segments + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-segments.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_segments + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-segments.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_segments + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-segments.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_segments + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-segments.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_segments + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-segments.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_stats + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-stats.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_stats + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-stats.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_stats + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-stats.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_stats + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-stats.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_stats/{metric} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-stats.html + + Limit the information returned the specific metrics. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_stats/{metric} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-stats.html + + Limit the information returned the specific metrics. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_stats/{metric} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-stats.html + + Limit the information returned the specific metrics. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_stats/{metric} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-stats.html + + Limit the information returned the specific metrics. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_stats + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-stats.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_stats + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-stats.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_stats + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-stats.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_stats + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-stats.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_stats/{metric} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-stats.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + Limit the information returned the specific metrics. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_stats/{metric} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-stats.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + Limit the information returned the specific metrics. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_stats/{metric} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-stats.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + Limit the information returned the specific metrics. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_stats/{metric} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-stats.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + Limit the information returned the specific metrics. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_status + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-status.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_status + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-status.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_status + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-status.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_status + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-status.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_status + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-status.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_status + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-status.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_status + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-status.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_status + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-status.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_aliases + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + The definition of `actions` to perform + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_aliases + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + The definition of `actions` to perform + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_aliases + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + The definition of `actions` to perform + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_aliases + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + The definition of `actions` to perform + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_validate/query + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_validate/query + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_validate/query + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_validate/query + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_validate/query + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html + + A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_validate/query + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html + + A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_validate/query + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html + + A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_validate/query + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html + + A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/_validate/query + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html + + A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices + A comma-separated list of document types to restrict the operation; leave empty to perform the operation on all types + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/_validate/query + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html + + A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices + A comma-separated list of document types to restrict the operation; leave empty to perform the operation on all types + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/_validate/query + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html + + A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices + A comma-separated list of document types to restrict the operation; leave empty to perform the operation on all types + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/_validate/query + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html + + A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices + A comma-separated list of document types to restrict the operation; leave empty to perform the operation on all types + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_validate/query + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html + + The query definition specified with the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_validate/query + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html + + The query definition specified with the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_validate/query + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html + + The query definition specified with the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_validate/query + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html + + The query definition specified with the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_validate/query + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html + + A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices + The query definition specified with the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_validate/query + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html + + A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices + The query definition specified with the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_validate/query + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html + + A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices + The query definition specified with the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_validate/query + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html + + A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices + The query definition specified with the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/_validate/query + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html + + A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices + A comma-separated list of document types to restrict the operation; leave empty to perform the operation on all types + The query definition specified with the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/_validate/query + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html + + A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices + A comma-separated list of document types to restrict the operation; leave empty to perform the operation on all types + The query definition specified with the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/_validate/query + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html + + A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices + A comma-separated list of document types to restrict the operation; leave empty to perform the operation on all types + The query definition specified with the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/_validate/query + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html + + A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices + A comma-separated list of document types to restrict the operation; leave empty to perform the operation on all types + The query definition specified with the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on / + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/ + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on / + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/ + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on / + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/ + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on / + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/ + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_bench + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-benchmark.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_bench + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-benchmark.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_bench + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-benchmark.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_bench + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-benchmark.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_bench + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-benchmark.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_bench + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-benchmark.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_bench + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-benchmark.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_bench + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-benchmark.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/_bench + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-benchmark.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + The name of the document type + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/_bench + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-benchmark.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + The name of the document type + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/_bench + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-benchmark.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + The name of the document type + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/_bench + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-benchmark.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + The name of the document type + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_mget + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-get.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_mget + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-get.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_mget + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-get.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_mget + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-get.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_mget + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-get.html + + The name of the index + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_mget + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-get.html + + The name of the index + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_mget + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-get.html + + The name of the index + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_mget + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-get.html + + The name of the index + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/_mget + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-get.html + + The name of the index + The type of the document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/_mget + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-get.html + + The name of the index + The type of the document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/_mget + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-get.html + + The name of the index + The type of the document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/_mget + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-get.html + + The name of the index + The type of the document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_mget + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-get.html + + Document identifiers; can be either `docs` (containing full document information) or `ids` (when index and type is provided in the URL. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_mget + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-get.html + + Document identifiers; can be either `docs` (containing full document information) or `ids` (when index and type is provided in the URL. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_mget + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-get.html + + Document identifiers; can be either `docs` (containing full document information) or `ids` (when index and type is provided in the URL. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_mget + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-get.html + + Document identifiers; can be either `docs` (containing full document information) or `ids` (when index and type is provided in the URL. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_mget + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-get.html + + The name of the index + Document identifiers; can be either `docs` (containing full document information) or `ids` (when index and type is provided in the URL. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_mget + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-get.html + + The name of the index + Document identifiers; can be either `docs` (containing full document information) or `ids` (when index and type is provided in the URL. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_mget + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-get.html + + The name of the index + Document identifiers; can be either `docs` (containing full document information) or `ids` (when index and type is provided in the URL. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_mget + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-get.html + + The name of the index + Document identifiers; can be either `docs` (containing full document information) or `ids` (when index and type is provided in the URL. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/_mget + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-get.html + + The name of the index + The type of the document + Document identifiers; can be either `docs` (containing full document information) or `ids` (when index and type is provided in the URL. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/_mget + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-get.html + + The name of the index + The type of the document + Document identifiers; can be either `docs` (containing full document information) or `ids` (when index and type is provided in the URL. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/_mget + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-get.html + + The name of the index + The type of the document + Document identifiers; can be either `docs` (containing full document information) or `ids` (when index and type is provided in the URL. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/_mget + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-get.html + + The name of the index + The type of the document + Document identifiers; can be either `docs` (containing full document information) or `ids` (when index and type is provided in the URL. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/{id}/_mlt + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-more-like-this.html + + The name of the index + The type of the document (use `_all` to fetch the first document matching the ID across all types) + The document ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/{id}/_mlt + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-more-like-this.html + + The name of the index + The type of the document (use `_all` to fetch the first document matching the ID across all types) + The document ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/{id}/_mlt + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-more-like-this.html + + The name of the index + The type of the document (use `_all` to fetch the first document matching the ID across all types) + The document ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/{id}/_mlt + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-more-like-this.html + + The name of the index + The type of the document (use `_all` to fetch the first document matching the ID across all types) + The document ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/{id}/_mlt + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-more-like-this.html + + The name of the index + The type of the document (use `_all` to fetch the first document matching the ID across all types) + The document ID + A specific search request definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/{id}/_mlt + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-more-like-this.html + + The name of the index + The type of the document (use `_all` to fetch the first document matching the ID across all types) + The document ID + A specific search request definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/{id}/_mlt + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-more-like-this.html + + The name of the index + The type of the document (use `_all` to fetch the first document matching the ID across all types) + The document ID + A specific search request definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/{id}/_mlt + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-more-like-this.html + + The name of the index + The type of the document (use `_all` to fetch the first document matching the ID across all types) + The document ID + A specific search request definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_mpercolate + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_mpercolate + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_mpercolate + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_mpercolate + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_mpercolate + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being count percolated to use as default + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_mpercolate + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being count percolated to use as default + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_mpercolate + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being count percolated to use as default + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_mpercolate + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being count percolated to use as default + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/_mpercolate + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being count percolated to use as default + The type of the document being percolated to use as default. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/_mpercolate + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being count percolated to use as default + The type of the document being percolated to use as default. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/_mpercolate + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being count percolated to use as default + The type of the document being percolated to use as default. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/_mpercolate + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being count percolated to use as default + The type of the document being percolated to use as default. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_mpercolate + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The percolate request definitions (header & body pair), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_mpercolate + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The percolate request definitions (header & body pair), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_mpercolate + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The percolate request definitions (header & body pair), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_mpercolate + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The percolate request definitions (header & body pair), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_mpercolate + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being count percolated to use as default + The percolate request definitions (header & body pair), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_mpercolate + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being count percolated to use as default + The percolate request definitions (header & body pair), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_mpercolate + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being count percolated to use as default + The percolate request definitions (header & body pair), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_mpercolate + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being count percolated to use as default + The percolate request definitions (header & body pair), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/_mpercolate + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being count percolated to use as default + The type of the document being percolated to use as default. + The percolate request definitions (header & body pair), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/_mpercolate + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being count percolated to use as default + The type of the document being percolated to use as default. + The percolate request definitions (header & body pair), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/_mpercolate + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being count percolated to use as default + The type of the document being percolated to use as default. + The percolate request definitions (header & body pair), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/_mpercolate + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being count percolated to use as default + The type of the document being percolated to use as default. + The percolate request definitions (header & body pair), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_msearch + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-multi-search.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_msearch + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-multi-search.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_msearch + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-multi-search.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_msearch + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-multi-search.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_msearch + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-multi-search.html + + A comma-separated list of index names to use as default + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_msearch + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-multi-search.html + + A comma-separated list of index names to use as default + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_msearch + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-multi-search.html + + A comma-separated list of index names to use as default + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_msearch + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-multi-search.html + + A comma-separated list of index names to use as default + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/_msearch + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-multi-search.html + + A comma-separated list of index names to use as default + A comma-separated list of document types to use as default + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/_msearch + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-multi-search.html + + A comma-separated list of index names to use as default + A comma-separated list of document types to use as default + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/_msearch + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-multi-search.html + + A comma-separated list of index names to use as default + A comma-separated list of document types to use as default + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/_msearch + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-multi-search.html + + A comma-separated list of index names to use as default + A comma-separated list of document types to use as default + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_msearch + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-multi-search.html + + The request definitions (metadata-search request definition pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_msearch + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-multi-search.html + + The request definitions (metadata-search request definition pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_msearch + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-multi-search.html + + The request definitions (metadata-search request definition pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_msearch + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-multi-search.html + + The request definitions (metadata-search request definition pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_msearch + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-multi-search.html + + A comma-separated list of index names to use as default + The request definitions (metadata-search request definition pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_msearch + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-multi-search.html + + A comma-separated list of index names to use as default + The request definitions (metadata-search request definition pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_msearch + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-multi-search.html + + A comma-separated list of index names to use as default + The request definitions (metadata-search request definition pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_msearch + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-multi-search.html + + A comma-separated list of index names to use as default + The request definitions (metadata-search request definition pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/_msearch + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-multi-search.html + + A comma-separated list of index names to use as default + A comma-separated list of document types to use as default + The request definitions (metadata-search request definition pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/_msearch + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-multi-search.html + + A comma-separated list of index names to use as default + A comma-separated list of document types to use as default + The request definitions (metadata-search request definition pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/_msearch + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-multi-search.html + + A comma-separated list of index names to use as default + A comma-separated list of document types to use as default + The request definitions (metadata-search request definition pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/_msearch + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-multi-search.html + + A comma-separated list of index names to use as default + A comma-separated list of document types to use as default + The request definitions (metadata-search request definition pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_mtermvectors + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_mtermvectors + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_mtermvectors + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_mtermvectors + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_mtermvectors + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html + + The index in which the document resides. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_mtermvectors + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html + + The index in which the document resides. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_mtermvectors + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html + + The index in which the document resides. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_mtermvectors + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html + + The index in which the document resides. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/_mtermvectors + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html + + The index in which the document resides. + The type of the document. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/_mtermvectors + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html + + The index in which the document resides. + The type of the document. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/_mtermvectors + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html + + The index in which the document resides. + The type of the document. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/_mtermvectors + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html + + The index in which the document resides. + The type of the document. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_mtermvectors + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html + + Define ids, parameters or a list of parameters per document here. You must at least provide a list of document ids. See documentation. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_mtermvectors + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html + + Define ids, parameters or a list of parameters per document here. You must at least provide a list of document ids. See documentation. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_mtermvectors + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html + + Define ids, parameters or a list of parameters per document here. You must at least provide a list of document ids. See documentation. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_mtermvectors + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html + + Define ids, parameters or a list of parameters per document here. You must at least provide a list of document ids. See documentation. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_mtermvectors + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html + + The index in which the document resides. + Define ids, parameters or a list of parameters per document here. You must at least provide a list of document ids. See documentation. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_mtermvectors + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html + + The index in which the document resides. + Define ids, parameters or a list of parameters per document here. You must at least provide a list of document ids. See documentation. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_mtermvectors + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html + + The index in which the document resides. + Define ids, parameters or a list of parameters per document here. You must at least provide a list of document ids. See documentation. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_mtermvectors + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html + + The index in which the document resides. + Define ids, parameters or a list of parameters per document here. You must at least provide a list of document ids. See documentation. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/_mtermvectors + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html + + The index in which the document resides. + The type of the document. + Define ids, parameters or a list of parameters per document here. You must at least provide a list of document ids. See documentation. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/_mtermvectors + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html + + The index in which the document resides. + The type of the document. + Define ids, parameters or a list of parameters per document here. You must at least provide a list of document ids. See documentation. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/_mtermvectors + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html + + The index in which the document resides. + The type of the document. + Define ids, parameters or a list of parameters per document here. You must at least provide a list of document ids. See documentation. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/_mtermvectors + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html + + The index in which the document resides. + The type of the document. + Define ids, parameters or a list of parameters per document here. You must at least provide a list of document ids. See documentation. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cluster/nodes/hotthreads + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-hot-threads.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cluster/nodes/hotthreads + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-hot-threads.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cluster/nodes/hotthreads + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-hot-threads.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cluster/nodes/hotthreads + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-hot-threads.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cluster/nodes/{node_id}/hotthreads + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-hot-threads.html + + A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cluster/nodes/{node_id}/hotthreads + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-hot-threads.html + + A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cluster/nodes/{node_id}/hotthreads + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-hot-threads.html + + A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cluster/nodes/{node_id}/hotthreads + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-hot-threads.html + + A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_nodes + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-info.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_nodes + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-info.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_nodes + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-info.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_nodes + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-info.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_nodes/{node_id} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-info.html + + A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_nodes/{node_id} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-info.html + + A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_nodes/{node_id} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-info.html + + A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_nodes/{node_id} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-info.html + + A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_nodes/{metric} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-info.html + + A comma-separated list of metrics you wish returned. Leave empty to return all. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_nodes/{metric} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-info.html + + A comma-separated list of metrics you wish returned. Leave empty to return all. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_nodes/{metric} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-info.html + + A comma-separated list of metrics you wish returned. Leave empty to return all. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_nodes/{metric} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-info.html + + A comma-separated list of metrics you wish returned. Leave empty to return all. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_nodes/{node_id}/{metric} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-info.html + + A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes + A comma-separated list of metrics you wish returned. Leave empty to return all. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_nodes/{node_id}/{metric} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-info.html + + A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes + A comma-separated list of metrics you wish returned. Leave empty to return all. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_nodes/{node_id}/{metric} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-info.html + + A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes + A comma-separated list of metrics you wish returned. Leave empty to return all. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_nodes/{node_id}/{metric} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-info.html + + A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes + A comma-separated list of metrics you wish returned. Leave empty to return all. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_shutdown + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-shutdown.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_shutdown + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-shutdown.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_shutdown + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-shutdown.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_shutdown + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-shutdown.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_cluster/nodes/{node_id}/_shutdown + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-shutdown.html + + A comma-separated list of node IDs or names to perform the operation on; use `_local` to perform the operation on the node you're connected to, leave empty to perform the operation on all nodes + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_cluster/nodes/{node_id}/_shutdown + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-shutdown.html + + A comma-separated list of node IDs or names to perform the operation on; use `_local` to perform the operation on the node you're connected to, leave empty to perform the operation on all nodes + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_cluster/nodes/{node_id}/_shutdown + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-shutdown.html + + A comma-separated list of node IDs or names to perform the operation on; use `_local` to perform the operation on the node you're connected to, leave empty to perform the operation on all nodes + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_cluster/nodes/{node_id}/_shutdown + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-shutdown.html + + A comma-separated list of node IDs or names to perform the operation on; use `_local` to perform the operation on the node you're connected to, leave empty to perform the operation on all nodes + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_nodes/stats + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-stats.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_nodes/stats + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-stats.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_nodes/stats + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-stats.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_nodes/stats + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-stats.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_nodes/{node_id}/stats + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-stats.html + + A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_nodes/{node_id}/stats + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-stats.html + + A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_nodes/{node_id}/stats + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-stats.html + + A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_nodes/{node_id}/stats + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-stats.html + + A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_nodes/stats/{metric} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-stats.html + + Limit the information returned to the specified metrics + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_nodes/stats/{metric} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-stats.html + + Limit the information returned to the specified metrics + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_nodes/stats/{metric} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-stats.html + + Limit the information returned to the specified metrics + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_nodes/stats/{metric} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-stats.html + + Limit the information returned to the specified metrics + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_nodes/{node_id}/stats/{metric} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-stats.html + + A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes + Limit the information returned to the specified metrics + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_nodes/{node_id}/stats/{metric} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-stats.html + + A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes + Limit the information returned to the specified metrics + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_nodes/{node_id}/stats/{metric} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-stats.html + + A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes + Limit the information returned to the specified metrics + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_nodes/{node_id}/stats/{metric} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-stats.html + + A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes + Limit the information returned to the specified metrics + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_nodes/stats/{metric}/{index_metric} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-stats.html + + Limit the information returned to the specified metrics + Limit the information returned for `indices` metric to the specific index metrics. Isn't used if `indices` (or `all`) metric isn't specified. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_nodes/stats/{metric}/{index_metric} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-stats.html + + Limit the information returned to the specified metrics + Limit the information returned for `indices` metric to the specific index metrics. Isn't used if `indices` (or `all`) metric isn't specified. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_nodes/stats/{metric}/{index_metric} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-stats.html + + Limit the information returned to the specified metrics + Limit the information returned for `indices` metric to the specific index metrics. Isn't used if `indices` (or `all`) metric isn't specified. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_nodes/stats/{metric}/{index_metric} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-stats.html + + Limit the information returned to the specified metrics + Limit the information returned for `indices` metric to the specific index metrics. Isn't used if `indices` (or `all`) metric isn't specified. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_nodes/{node_id}/stats/{metric}/{index_metric} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-stats.html + + A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes + Limit the information returned to the specified metrics + Limit the information returned for `indices` metric to the specific index metrics. Isn't used if `indices` (or `all`) metric isn't specified. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_nodes/{node_id}/stats/{metric}/{index_metric} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-stats.html + + A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes + Limit the information returned to the specified metrics + Limit the information returned for `indices` metric to the specific index metrics. Isn't used if `indices` (or `all`) metric isn't specified. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_nodes/{node_id}/stats/{metric}/{index_metric} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-stats.html + + A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes + Limit the information returned to the specified metrics + Limit the information returned for `indices` metric to the specific index metrics. Isn't used if `indices` (or `all`) metric isn't specified. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_nodes/{node_id}/stats/{metric}/{index_metric} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-stats.html + + A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes + Limit the information returned to the specified metrics + Limit the information returned for `indices` metric to the specific index metrics. Isn't used if `indices` (or `all`) metric isn't specified. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/_percolate + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being percolated. + The type of the document being percolated. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/_percolate + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being percolated. + The type of the document being percolated. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/_percolate + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being percolated. + The type of the document being percolated. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/_percolate + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being percolated. + The type of the document being percolated. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/{id}/_percolate + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being percolated. + The type of the document being percolated. + Substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/{id}/_percolate + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being percolated. + The type of the document being percolated. + Substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/{id}/_percolate + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being percolated. + The type of the document being percolated. + Substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/{id}/_percolate + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being percolated. + The type of the document being percolated. + Substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/_percolate + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being percolated. + The type of the document being percolated. + The percolator request definition using the percolate DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/_percolate + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being percolated. + The type of the document being percolated. + The percolator request definition using the percolate DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/_percolate + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being percolated. + The type of the document being percolated. + The percolator request definition using the percolate DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/_percolate + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being percolated. + The type of the document being percolated. + The percolator request definition using the percolate DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/{id}/_percolate + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being percolated. + The type of the document being percolated. + Substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster. + The percolator request definition using the percolate DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/{id}/_percolate + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being percolated. + The type of the document being percolated. + Substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster. + The percolator request definition using the percolate DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/{id}/_percolate + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being percolated. + The type of the document being percolated. + Substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster. + The percolator request definition using the percolate DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/{id}/_percolate + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being percolated. + The type of the document being percolated. + Substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster. + The percolator request definition using the percolate DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a HEAD on / + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/ + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a HEAD on / + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/ + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a HEAD on / + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/ + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a HEAD on / + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/ + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /_scripts/{lang}/{id} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html + + Script language + Script ID + The document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /_scripts/{lang}/{id} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html + + Script language + Script ID + The document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /_scripts/{lang}/{id} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html + + Script language + Script ID + The document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /_scripts/{lang}/{id} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html + + Script language + Script ID + The document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_scripts/{lang}/{id} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html + + Script language + Script ID + The document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_scripts/{lang}/{id} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html + + Script language + Script ID + The document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_scripts/{lang}/{id} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html + + Script language + Script ID + The document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_scripts/{lang}/{id} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html + + Script language + Script ID + The document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /_search/template/{id} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html + + Template ID + The document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /_search/template/{id} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html + + Template ID + The document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /_search/template/{id} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html + + Template ID + The document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /_search/template/{id} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html + + Template ID + The document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_search/template/{id} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html + + Template ID + The document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_search/template/{id} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html + + Template ID + The document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_search/template/{id} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html + + Template ID + The document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_search/template/{id} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html + + Template ID + The document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_search/scroll + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_search/scroll + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_search/scroll + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_search/scroll + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_search/scroll/{scroll_id} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html + + The scroll ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_search/scroll/{scroll_id} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html + + The scroll ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_search/scroll/{scroll_id} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html + + The scroll ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_search/scroll/{scroll_id} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html + + The scroll ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_search/scroll + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html + + The scroll ID if not passed by URL or query parameter. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_search/scroll + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html + + The scroll ID if not passed by URL or query parameter. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_search/scroll + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html + + The scroll ID if not passed by URL or query parameter. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_search/scroll + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html + + The scroll ID if not passed by URL or query parameter. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_search/scroll/{scroll_id} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html + + The scroll ID + The scroll ID if not passed by URL or query parameter. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_search/scroll/{scroll_id} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html + + The scroll ID + The scroll ID if not passed by URL or query parameter. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_search/scroll/{scroll_id} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html + + The scroll ID + The scroll ID if not passed by URL or query parameter. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_search/scroll/{scroll_id} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html + + The scroll ID + The scroll ID if not passed by URL or query parameter. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_search + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_search + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_search + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_search + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_search + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_search + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_search + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_search + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/_search + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices + A comma-separated list of document types to search; leave empty to perform the operation on all types + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/_search + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices + A comma-separated list of document types to search; leave empty to perform the operation on all types + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/_search + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices + A comma-separated list of document types to search; leave empty to perform the operation on all types + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/_search + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices + A comma-separated list of document types to search; leave empty to perform the operation on all types + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_search + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + The search definition using the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_search + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + The search definition using the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_search + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + The search definition using the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_search + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + The search definition using the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_search + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices + The search definition using the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_search + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices + The search definition using the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_search + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices + The search definition using the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_search + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices + The search definition using the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/_search + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices + A comma-separated list of document types to search; leave empty to perform the operation on all types + The search definition using the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/_search + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices + A comma-separated list of document types to search; leave empty to perform the operation on all types + The search definition using the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/_search + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices + A comma-separated list of document types to search; leave empty to perform the operation on all types + The search definition using the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/_search + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices + A comma-separated list of document types to search; leave empty to perform the operation on all types + The search definition using the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_search_shards + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-shards.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_search_shards + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-shards.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_search_shards + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-shards.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_search_shards + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-shards.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_search_shards + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-shards.html + + The name of the index + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_search_shards + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-shards.html + + The name of the index + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_search_shards + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-shards.html + + The name of the index + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_search_shards + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-shards.html + + The name of the index + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/_search_shards + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-shards.html + + The name of the index + The type of the document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/_search_shards + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-shards.html + + The name of the index + The type of the document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/_search_shards + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-shards.html + + The name of the index + The type of the document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/_search_shards + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-shards.html + + The name of the index + The type of the document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_search_shards + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-shards.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_search_shards + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-shards.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_search_shards + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-shards.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_search_shards + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-shards.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_search_shards + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-shards.html + + The name of the index + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_search_shards + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-shards.html + + The name of the index + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_search_shards + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-shards.html + + The name of the index + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_search_shards + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-shards.html + + The name of the index + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/_search_shards + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-shards.html + + The name of the index + The type of the document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/_search_shards + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-shards.html + + The name of the index + The type of the document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/_search_shards + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-shards.html + + The name of the index + The type of the document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/_search_shards + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-shards.html + + The name of the index + The type of the document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_search/template + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-template.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_search/template + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-template.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_search/template + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-template.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_search/template + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-template.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_search/template + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-template.html + + A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_search/template + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-template.html + + A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_search/template + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-template.html + + A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_search/template + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-template.html + + A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/_search/template + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-template.html + + A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices + A comma-separated list of document types to search; leave empty to perform the operation on all types + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/_search/template + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-template.html + + A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices + A comma-separated list of document types to search; leave empty to perform the operation on all types + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/_search/template + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-template.html + + A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices + A comma-separated list of document types to search; leave empty to perform the operation on all types + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/_search/template + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-template.html + + A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices + A comma-separated list of document types to search; leave empty to perform the operation on all types + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_search/template + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-template.html + + The search definition template and its params + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_search/template + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-template.html + + The search definition template and its params + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_search/template + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-template.html + + The search definition template and its params + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_search/template + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-template.html + + The search definition template and its params + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_search/template + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-template.html + + A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices + The search definition template and its params + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_search/template + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-template.html + + A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices + The search definition template and its params + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_search/template + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-template.html + + A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices + The search definition template and its params + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_search/template + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-template.html + + A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices + The search definition template and its params + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/_search/template + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-template.html + + A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices + A comma-separated list of document types to search; leave empty to perform the operation on all types + The search definition template and its params + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/_search/template + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-template.html + + A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices + A comma-separated list of document types to search; leave empty to perform the operation on all types + The search definition template and its params + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/_search/template + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-template.html + + A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices + A comma-separated list of document types to search; leave empty to perform the operation on all types + The search definition template and its params + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/_search/template + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-template.html + + A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices + A comma-separated list of document types to search; leave empty to perform the operation on all types + The search definition template and its params + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /_snapshot/{repository}/{snapshot} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A repository name + A snapshot name + The snapshot definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /_snapshot/{repository}/{snapshot} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A repository name + A snapshot name + The snapshot definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /_snapshot/{repository}/{snapshot} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A repository name + A snapshot name + The snapshot definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /_snapshot/{repository}/{snapshot} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A repository name + A snapshot name + The snapshot definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_snapshot/{repository}/{snapshot} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A repository name + A snapshot name + The snapshot definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_snapshot/{repository}/{snapshot} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A repository name + A snapshot name + The snapshot definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_snapshot/{repository}/{snapshot} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A repository name + A snapshot name + The snapshot definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_snapshot/{repository}/{snapshot} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A repository name + A snapshot name + The snapshot definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /_snapshot/{repository} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A repository name + The repository definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /_snapshot/{repository} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A repository name + The repository definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /_snapshot/{repository} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A repository name + The repository definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /_snapshot/{repository} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A repository name + The repository definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_snapshot/{repository} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A repository name + The repository definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_snapshot/{repository} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A repository name + The repository definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_snapshot/{repository} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A repository name + The repository definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_snapshot/{repository} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A repository name + The repository definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a DELETE on /_snapshot/{repository}/{snapshot} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A repository name + A snapshot name + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a DELETE on /_snapshot/{repository}/{snapshot} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A repository name + A snapshot name + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a DELETE on /_snapshot/{repository}/{snapshot} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A repository name + A snapshot name + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a DELETE on /_snapshot/{repository}/{snapshot} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A repository name + A snapshot name + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a DELETE on /_snapshot/{repository} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A comma-separated list of repository names + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a DELETE on /_snapshot/{repository} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A comma-separated list of repository names + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a DELETE on /_snapshot/{repository} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A comma-separated list of repository names + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a DELETE on /_snapshot/{repository} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A comma-separated list of repository names + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_snapshot/{repository}/{snapshot} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A repository name + A comma-separated list of snapshot names + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_snapshot/{repository}/{snapshot} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A repository name + A comma-separated list of snapshot names + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_snapshot/{repository}/{snapshot} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A repository name + A comma-separated list of snapshot names + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_snapshot/{repository}/{snapshot} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A repository name + A comma-separated list of snapshot names + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_snapshot + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_snapshot + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_snapshot + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_snapshot + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_snapshot/{repository} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A comma-separated list of repository names + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_snapshot/{repository} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A comma-separated list of repository names + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_snapshot/{repository} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A comma-separated list of repository names + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_snapshot/{repository} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A comma-separated list of repository names + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_snapshot/{repository}/{snapshot}/_restore + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A repository name + A snapshot name + Details of what to restore + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_snapshot/{repository}/{snapshot}/_restore + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A repository name + A snapshot name + Details of what to restore + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_snapshot/{repository}/{snapshot}/_restore + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A repository name + A snapshot name + Details of what to restore + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_snapshot/{repository}/{snapshot}/_restore + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A repository name + A snapshot name + Details of what to restore + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_snapshot/_status + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-snapshots.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_snapshot/_status + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-snapshots.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_snapshot/_status + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-snapshots.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_snapshot/_status + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-snapshots.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_snapshot/{repository}/_status + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-snapshots.html + + A repository name + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_snapshot/{repository}/_status + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-snapshots.html + + A repository name + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_snapshot/{repository}/_status + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-snapshots.html + + A repository name + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_snapshot/{repository}/_status + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-snapshots.html + + A repository name + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_snapshot/{repository}/{snapshot}/_status + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-snapshots.html + + A repository name + A comma-separated list of snapshot names + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_snapshot/{repository}/{snapshot}/_status + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-snapshots.html + + A repository name + A comma-separated list of snapshot names + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_snapshot/{repository}/{snapshot}/_status + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-snapshots.html + + A repository name + A comma-separated list of snapshot names + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_snapshot/{repository}/{snapshot}/_status + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-snapshots.html + + A repository name + A comma-separated list of snapshot names + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_suggest + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + The request definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_suggest + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + The request definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_suggest + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + The request definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_suggest + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + The request definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_suggest + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices + The request definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_suggest + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices + The request definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_suggest + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices + The request definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_suggest + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices + The request definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_suggest + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_suggest + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_suggest + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_suggest + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_suggest + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_suggest + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_suggest + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_suggest + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/{id}/_termvector + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-termvectors.html + + The index in which the document resides. + The type of the document. + The id of the document. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/{id}/_termvector + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-termvectors.html + + The index in which the document resides. + The type of the document. + The id of the document. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/{id}/_termvector + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-termvectors.html + + The index in which the document resides. + The type of the document. + The id of the document. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/{id}/_termvector + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-termvectors.html + + The index in which the document resides. + The type of the document. + The id of the document. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/{id}/_termvector + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-termvectors.html + + The index in which the document resides. + The type of the document. + The id of the document. + Define parameters. See documentation. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/{id}/_termvector + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-termvectors.html + + The index in which the document resides. + The type of the document. + The id of the document. + Define parameters. See documentation. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/{id}/_termvector + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-termvectors.html + + The index in which the document resides. + The type of the document. + The id of the document. + Define parameters. See documentation. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/{id}/_termvector + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-termvectors.html + + The index in which the document resides. + The type of the document. + The id of the document. + Define parameters. See documentation. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/{id}/_update + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-update.html + + The name of the index + The type of the document + Document ID + The request definition using either `script` or partial `doc` + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/{id}/_update + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-update.html + + The name of the index + The type of the document + Document ID + The request definition using either `script` or partial `doc` + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/{id}/_update + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-update.html + + The name of the index + The type of the document + Document ID + The request definition using either `script` or partial `doc` + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/{id}/_update + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-update.html + + The name of the index + The type of the document + Document ID + The request definition using either `script` or partial `doc` + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Request parameters descriptor for IndicesDeleteAlias + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html
+
+ + + + + Used by the raw client to compose querystring parameters in a matter that still exposes some xmldocs + You can always pass a simple NameValueCollection if you want. + + + + + Explicit timestamp for the document + + + Specify timeout for connection to master + + + Request parameters descriptor for IndicesPutAlias + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html
+
+ + + + Explicit timestamp for the document + + + Specify timeout for connection to master + + + Request parameters descriptor for IndicesRecoveryForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/indices-recovery.html
+
+ + + + Whether to display detailed information about shard recovery + + + Display only those recoveries that are currently on-going + + + Whether to return time and byte values in human-readable format. + + + Request parameters descriptor for IndicesExistsTemplateForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html
+
+ + + + Return local information, do not retrieve the state from master node (default: false) + + + Request parameters descriptor for IndicesGetFieldMappingForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-field-mapping.html
+
+ + + + Whether the default mapping values should be returned as well + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Return local information, do not retrieve the state from master node (default: false) + + + Request parameters descriptor for MpercolateGet + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html
+
+ + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Request parameters descriptor for IndicesExistsType + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-types-exists.html
+
+ + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Return local information, do not retrieve the state from master node (default: false) + + + Request parameters descriptor for IndicesExistsAliasForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html
+
+ + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Return local information, do not retrieve the state from master node (default: false) + + + + ConnectionConfiguration allows you to control how ElasticsearchClient behaves and where/how it connects + to elasticsearch + + + + + The timeout in milliseconds to use for ping calls that are issues to check whether a node is up or not. + + + + + Limits the total runtime including retries separately from + 
+            When not specified defaults to  which itself defaults to 60seconds
+
+ + + + + This signals that we do not want to send initial pings to unknown/previously dead nodes + and just send the call straightaway + + + + + Instead of following a c/go like error checking on response.IsValid always throw an ElasticsearchServerException + on the client when a call resulted in an exception on the elasticsearch server. + Reasons for such exceptions could be search parser errors, index missing exceptions + + + + + Sniff the cluster state immediatly on startup + + + + + Force a new sniff for the cluster state everytime a connection dies + + + + + Force a new sniff for the cluster when the cluster state information is older than + the specified timespan + + + + + Append these query string parameters automatically to every request + + + + + Connection status handler that will be called everytime the connection receives anything. + + + + + + + + + + Basic access authorization credentials to specify with all requests. + + TODO: Rename to BasicAuthenticationCredentials in 2.0 + + + + Enable compressed responses from elasticsearch (NOTE that that nodes need to be configured to allow this) + http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/modules-http.html + + + + + Enable Trace signals to the IConnection that it should put debug information on the Trace. + + + + + By enabling metrics more metadata is returned per API call about requests (ping, sniff, failover) and general stats + + + + + Instead of following a c/go like error checking on response.IsValid always throw an ElasticsearchServerException + on the client when a call resulted in an exception on the elasticsearch server. + Reasons for such exceptions could be search parser errors, index missing exceptions + + + + + When a node is used for the very first time or when it's used for the first time after it has been marked dead + a ping with a very low timeout is send to the node to make sure that when it's still dead it reports it as fast as possible. + You can disable these pings globally here if you rather have it fail on the possible slower original request + + + + + This NameValueCollection will be appended to every url NEST calls, great if you need to pass i.e an API key. + + + + + Timeout in milliseconds when the .NET webrequest should abort the request, note that you can set this to a high value here, + and specify the timeout in various calls on Elasticsearch's side. + + time out in milliseconds + + + + This is a separate timeout for Ping() requests. A ping should fail as fast as possible. + + The ping timeout in milliseconds defaults to 200 + + + + Sets the default dead timeout factor when a node has been marked dead. + + Some connection pools may use a flat timeout whilst others take this factor and increase it exponentially + + + + + Sets the maximum time a node can be marked dead. + Different implementations of IConnectionPool may choose a different default. + + The timeout in milliseconds + + + + Limits the total runtime including retries separately from + 
+            When not specified defaults to  which itself defaults to 60seconds
+
+ + + + + Semaphore asynchronous connections automatically by giving + it a maximum concurrent connections. + + defaults to 0 (unbounded) + + + + If your connection has to go through proxy use this method to specify the proxy url + + + + + Append ?pretty=true to requests, this helps to debug send and received json. + + + + + Make sure the reponse bytes are always available on the ElasticsearchResponse object + Note: that depending on the registered serializer this may cause the respond to be read in memory first + + + + + Global callback for every response that NEST receives, useful for custom logging. + + + + + Basic access authentication credentials to specify with all requests. + + + + + Basic access authentication credentials to specify with all requests. + + + + + Allows for requests to be pipelined. http://en.wikipedia.org/wiki/HTTP_pipelining + Note: HTTP pipelining must also be enabled in Elasticsearch for this to work properly. + + + + + Enable compressed responses from elasticsearch (NOTE that that nodes need to be configured to allow this) + http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/modules-http.html + + + + + Enable Trace signals to the IConnection that it should put debug information on the Trace. + + + + + This NameValueCollection will be appended to every url NEST calls, great if you need to pass i.e an API key. + + + + + + + + If your connection has to go through proxy use this method to specify the proxy url + + + + + + Append ?pretty=true to requests, this helps to debug send and received json. + + + + + + Make sure the reponse bytes are always available on the ElasticsearchResponse object + Note: that depending on the registered serializer this may cause the respond to be read in memory first + + + + + + Semaphore asynchronous connections automatically by giving + it a maximum concurrent connections. Great to prevent + out of memory exceptions + + defaults to 20 + + + + + Global callback for every response that NEST receives, useful for custom logging. + + + + + ConnectionConfiguration allows you to control how ElasticsearchClient behaves and where/how it connects + to elasticsearch + + The root of the elasticsearch node we want to connect to. Defaults to http://localhost:9200 + + + + ConnectionConfiguration allows you to control how ElasticsearchClient behaves and where/how it connects + to elasticsearch + + A connection pool implementation that'll tell the client what nodes are available + + + + Gets the next live Uri to perform the request on + + pass the original seed when retrying, this guarantees that the nodes are walked in a + predictable manner even when called in a multithreaded context + The seed this call started on + + + + + Mark the specified Uri as dead + + + + + Bring the specified uri back to life. + + + + + + Update the node list manually, usually done by ITransport when sniffing was needed. + + + hint that the node we recieved the sniff from should not be pinged + + + + Returns the default maximum retries for the connection pool implementation. + Most implementation default to number of nodes, note that this can be overidden + in the connection settings + + + + + Signals that this implemenation can accept new nodes + + + + + Returns whether the current delegation over nodes took too long and we should quit. + if is set we'll use that timeout otherwise we default to th value of + which itself defaults to 60 seconds + + + + + Returns either the fixed maximum set on the connection configuration settings or the number of nodes + + + + + Selects next node uri on request state + + bool hint whether the new current node needs to pinged first + + + + This property returns the mapped elasticsearch server exception + + + + + The raw byte response, only set when IncludeRawResponse() is set on Connection configuration + + + + + If the response is succesful or has a known error (400-500 range) + The client should not retry this call + + + + + Raw operations with elasticsearch + + + Low level client that exposes all of elasticsearch API endpoints but leaves you in charge of building request and handling the response + + + + Represents a POST on /_bench/abort/{name} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-benchmark.html + + A benchmark name + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_bench/abort/{name} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-benchmark.html + + A benchmark name + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_bench/abort/{name} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-benchmark.html + + A benchmark name + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_bench/abort/{name} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-benchmark.html + + A benchmark name + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_bulk + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-bulk.html + + The operation definition and data (action-data pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_bulk + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-bulk.html + + The operation definition and data (action-data pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_bulk + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-bulk.html + + The operation definition and data (action-data pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_bulk + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-bulk.html + + The operation definition and data (action-data pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_bulk + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-bulk.html + + Default index for items which don't provide one + The operation definition and data (action-data pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_bulk + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-bulk.html + + Default index for items which don't provide one + The operation definition and data (action-data pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_bulk + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-bulk.html + + Default index for items which don't provide one + The operation definition and data (action-data pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_bulk + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-bulk.html + + Default index for items which don't provide one + The operation definition and data (action-data pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/_bulk + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-bulk.html + + Default index for items which don't provide one + Default document type for items which don't provide one + The operation definition and data (action-data pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/_bulk + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-bulk.html + + Default index for items which don't provide one + Default document type for items which don't provide one + The operation definition and data (action-data pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/_bulk + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-bulk.html + + Default index for items which don't provide one + Default document type for items which don't provide one + The operation definition and data (action-data pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/_bulk + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-bulk.html + + Default index for items which don't provide one + Default document type for items which don't provide one + The operation definition and data (action-data pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /_bulk + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-bulk.html + + The operation definition and data (action-data pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /_bulk + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-bulk.html + + The operation definition and data (action-data pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /_bulk + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-bulk.html + + The operation definition and data (action-data pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /_bulk + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-bulk.html + + The operation definition and data (action-data pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /{index}/_bulk + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-bulk.html + + Default index for items which don't provide one + The operation definition and data (action-data pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /{index}/_bulk + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-bulk.html + + Default index for items which don't provide one + The operation definition and data (action-data pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /{index}/_bulk + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-bulk.html + + Default index for items which don't provide one + The operation definition and data (action-data pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /{index}/_bulk + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-bulk.html + + Default index for items which don't provide one + The operation definition and data (action-data pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /{index}/{type}/_bulk + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-bulk.html + + Default index for items which don't provide one + Default document type for items which don't provide one + The operation definition and data (action-data pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /{index}/{type}/_bulk + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-bulk.html + + Default index for items which don't provide one + Default document type for items which don't provide one + The operation definition and data (action-data pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /{index}/{type}/_bulk + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-bulk.html + + Default index for items which don't provide one + Default document type for items which don't provide one + The operation definition and data (action-data pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /{index}/{type}/_bulk + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-bulk.html + + Default index for items which don't provide one + Default document type for items which don't provide one + The operation definition and data (action-data pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/aliases + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-aliases.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/aliases + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-aliases.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/aliases + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-aliases.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/aliases + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-aliases.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/aliases/{name} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-aliases.html + + A comma-separated list of alias names to return + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/aliases/{name} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-aliases.html + + A comma-separated list of alias names to return + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/aliases/{name} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-aliases.html + + A comma-separated list of alias names to return + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/aliases/{name} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-aliases.html + + A comma-separated list of alias names to return + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/allocation + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-allocation.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/allocation + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-allocation.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/allocation + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-allocation.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/allocation + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-allocation.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/allocation/{node_id} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-allocation.html + + A comma-separated list of node IDs or names to limit the returned information + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/allocation/{node_id} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-allocation.html + + A comma-separated list of node IDs or names to limit the returned information + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/allocation/{node_id} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-allocation.html + + A comma-separated list of node IDs or names to limit the returned information + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/allocation/{node_id} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-allocation.html + + A comma-separated list of node IDs or names to limit the returned information + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/count + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-count.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/count + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-count.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/count + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-count.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/count + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-count.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/count/{index} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-count.html + + A comma-separated list of index names to limit the returned information + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/count/{index} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-count.html + + A comma-separated list of index names to limit the returned information + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/count/{index} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-count.html + + A comma-separated list of index names to limit the returned information + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/count/{index} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-count.html + + A comma-separated list of index names to limit the returned information + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/fielddata + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/cat-fielddata.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/fielddata + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/cat-fielddata.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/fielddata + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/cat-fielddata.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/fielddata + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/cat-fielddata.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/health + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-health.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/health + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-health.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/health + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-health.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/health + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-health.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/indices + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-indices.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/indices + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-indices.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/indices + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-indices.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/indices + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-indices.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/indices/{index} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-indices.html + + A comma-separated list of index names to limit the returned information + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/indices/{index} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-indices.html + + A comma-separated list of index names to limit the returned information + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/indices/{index} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-indices.html + + A comma-separated list of index names to limit the returned information + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/indices/{index} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-indices.html + + A comma-separated list of index names to limit the returned information + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/master + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-master.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/master + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-master.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/master + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-master.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/master + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-master.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/nodes + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-nodes.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/nodes + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-nodes.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/nodes + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-nodes.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/nodes + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-nodes.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/pending_tasks + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-pending-tasks.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/pending_tasks + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-pending-tasks.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/pending_tasks + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-pending-tasks.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/pending_tasks + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-pending-tasks.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/plugins + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/cat-plugins.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/plugins + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/cat-plugins.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/plugins + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/cat-plugins.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/plugins + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/cat-plugins.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/recovery + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-recovery.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/recovery + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-recovery.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/recovery + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-recovery.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/recovery + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-recovery.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/recovery/{index} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-recovery.html + + A comma-separated list of index names to limit the returned information + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/recovery/{index} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-recovery.html + + A comma-separated list of index names to limit the returned information + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/recovery/{index} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-recovery.html + + A comma-separated list of index names to limit the returned information + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/recovery/{index} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-recovery.html + + A comma-separated list of index names to limit the returned information + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/shards + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-shards.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/shards + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-shards.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/shards + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-shards.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/shards + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-shards.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/shards/{index} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-shards.html + + A comma-separated list of index names to limit the returned information + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/shards/{index} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-shards.html + + A comma-separated list of index names to limit the returned information + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/shards/{index} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-shards.html + + A comma-separated list of index names to limit the returned information + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/shards/{index} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-shards.html + + A comma-separated list of index names to limit the returned information + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/thread_pool + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/cat-thread-pool.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/thread_pool + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/cat-thread-pool.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cat/thread_pool + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/cat-thread-pool.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cat/thread_pool + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/cat-thread-pool.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a DELETE on /_search/scroll/{scroll_id} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html + + A comma-separated list of scroll IDs to clear + A comma-separated list of scroll IDs to clear if none was specified via the scroll_id parameter + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a DELETE on /_search/scroll/{scroll_id} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html + + A comma-separated list of scroll IDs to clear + A comma-separated list of scroll IDs to clear if none was specified via the scroll_id parameter + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a DELETE on /_search/scroll/{scroll_id} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html + + A comma-separated list of scroll IDs to clear + A comma-separated list of scroll IDs to clear if none was specified via the scroll_id parameter + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a DELETE on /_search/scroll/{scroll_id} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html + + A comma-separated list of scroll IDs to clear + A comma-separated list of scroll IDs to clear if none was specified via the scroll_id parameter + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a DELETE on /_search/scroll + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html + + A comma-separated list of scroll IDs to clear if none was specified via the scroll_id parameter + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a DELETE on /_search/scroll + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html + + A comma-separated list of scroll IDs to clear if none was specified via the scroll_id parameter + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a DELETE on /_search/scroll + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html + + A comma-separated list of scroll IDs to clear if none was specified via the scroll_id parameter + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a DELETE on /_search/scroll + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html + + A comma-separated list of scroll IDs to clear if none was specified via the scroll_id parameter + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cluster/settings + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-update-settings.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cluster/settings + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-update-settings.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cluster/settings + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-update-settings.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cluster/settings + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-update-settings.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cluster/health + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-health.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cluster/health + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-health.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cluster/health + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-health.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cluster/health + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-health.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cluster/health/{index} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-health.html + + Limit the information returned to a specific index + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cluster/health/{index} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-health.html + + Limit the information returned to a specific index + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cluster/health/{index} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-health.html + + Limit the information returned to a specific index + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cluster/health/{index} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-health.html + + Limit the information returned to a specific index + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cluster/pending_tasks + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-pending.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cluster/pending_tasks + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-pending.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cluster/pending_tasks + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-pending.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cluster/pending_tasks + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-pending.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /_cluster/settings + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-update-settings.html + + The settings to be updated. Can be either `transient` or `persistent` (survives cluster restart). + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /_cluster/settings + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-update-settings.html + + The settings to be updated. Can be either `transient` or `persistent` (survives cluster restart). + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /_cluster/settings + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-update-settings.html + + The settings to be updated. Can be either `transient` or `persistent` (survives cluster restart). + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /_cluster/settings + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-update-settings.html + + The settings to be updated. Can be either `transient` or `persistent` (survives cluster restart). + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_cluster/reroute + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-reroute.html + + The definition of `commands` to perform (`move`, `cancel`, `allocate`) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_cluster/reroute + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-reroute.html + + The definition of `commands` to perform (`move`, `cancel`, `allocate`) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_cluster/reroute + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-reroute.html + + The definition of `commands` to perform (`move`, `cancel`, `allocate`) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_cluster/reroute + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-reroute.html + + The definition of `commands` to perform (`move`, `cancel`, `allocate`) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cluster/state + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-state.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cluster/state + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-state.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cluster/state + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-state.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cluster/state + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-state.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cluster/state/{metric} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-state.html + + Limit the information returned to the specified metrics + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cluster/state/{metric} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-state.html + + Limit the information returned to the specified metrics + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cluster/state/{metric} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-state.html + + Limit the information returned to the specified metrics + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cluster/state/{metric} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-state.html + + Limit the information returned to the specified metrics + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cluster/state/{metric}/{index} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-state.html + + Limit the information returned to the specified metrics + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cluster/state/{metric}/{index} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-state.html + + Limit the information returned to the specified metrics + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cluster/state/{metric}/{index} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-state.html + + Limit the information returned to the specified metrics + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cluster/state/{metric}/{index} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-state.html + + Limit the information returned to the specified metrics + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cluster/stats + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-stats.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cluster/stats + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-stats.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cluster/stats + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-stats.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cluster/stats + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-stats.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cluster/stats/nodes/{node_id} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-stats.html + + A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cluster/stats/nodes/{node_id} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-stats.html + + A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cluster/stats/nodes/{node_id} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-stats.html + + A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cluster/stats/nodes/{node_id} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-stats.html + + A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_count + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html + + A query to restrict the results specified with the Query DSL (optional) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_count + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html + + A query to restrict the results specified with the Query DSL (optional) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_count + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html + + A query to restrict the results specified with the Query DSL (optional) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_count + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html + + A query to restrict the results specified with the Query DSL (optional) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_count + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html + + A comma-separated list of indices to restrict the results + A query to restrict the results specified with the Query DSL (optional) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_count + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html + + A comma-separated list of indices to restrict the results + A query to restrict the results specified with the Query DSL (optional) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_count + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html + + A comma-separated list of indices to restrict the results + A query to restrict the results specified with the Query DSL (optional) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_count + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html + + A comma-separated list of indices to restrict the results + A query to restrict the results specified with the Query DSL (optional) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/_count + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html + + A comma-separated list of indices to restrict the results + A comma-separated list of types to restrict the results + A query to restrict the results specified with the Query DSL (optional) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/_count + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html + + A comma-separated list of indices to restrict the results + A comma-separated list of types to restrict the results + A query to restrict the results specified with the Query DSL (optional) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/_count + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html + + A comma-separated list of indices to restrict the results + A comma-separated list of types to restrict the results + A query to restrict the results specified with the Query DSL (optional) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/_count + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html + + A comma-separated list of indices to restrict the results + A comma-separated list of types to restrict the results + A query to restrict the results specified with the Query DSL (optional) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_count + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_count + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_count + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_count + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_count + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html + + A comma-separated list of indices to restrict the results + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_count + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html + + A comma-separated list of indices to restrict the results + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_count + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html + + A comma-separated list of indices to restrict the results + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_count + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html + + A comma-separated list of indices to restrict the results + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/_count + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html + + A comma-separated list of indices to restrict the results + A comma-separated list of types to restrict the results + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/_count + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html + + A comma-separated list of indices to restrict the results + A comma-separated list of types to restrict the results + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/_count + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html + + A comma-separated list of indices to restrict the results + A comma-separated list of types to restrict the results + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/_count + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html + + A comma-separated list of indices to restrict the results + A comma-separated list of types to restrict the results + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/_percolate/count + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being count percolated. + The type of the document being count percolated. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/_percolate/count + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being count percolated. + The type of the document being count percolated. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/_percolate/count + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being count percolated. + The type of the document being count percolated. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/_percolate/count + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being count percolated. + The type of the document being count percolated. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/{id}/_percolate/count + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being count percolated. + The type of the document being count percolated. + Substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/{id}/_percolate/count + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being count percolated. + The type of the document being count percolated. + Substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/{id}/_percolate/count + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being count percolated. + The type of the document being count percolated. + Substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/{id}/_percolate/count + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being count percolated. + The type of the document being count percolated. + Substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/_percolate/count + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being count percolated. + The type of the document being count percolated. + The count percolator request definition using the percolate DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/_percolate/count + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being count percolated. + The type of the document being count percolated. + The count percolator request definition using the percolate DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/_percolate/count + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being count percolated. + The type of the document being count percolated. + The count percolator request definition using the percolate DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/_percolate/count + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being count percolated. + The type of the document being count percolated. + The count percolator request definition using the percolate DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/{id}/_percolate/count + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being count percolated. + The type of the document being count percolated. + Substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster. + The count percolator request definition using the percolate DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/{id}/_percolate/count + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being count percolated. + The type of the document being count percolated. + Substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster. + The count percolator request definition using the percolate DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/{id}/_percolate/count + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being count percolated. + The type of the document being count percolated. + Substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster. + The count percolator request definition using the percolate DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/{id}/_percolate/count + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being count percolated. + The type of the document being count percolated. + Substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster. + The count percolator request definition using the percolate DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a DELETE on /{index}/{type}/{id} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-delete.html + + The name of the index + The type of the document + The document ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a DELETE on /{index}/{type}/{id} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-delete.html + + The name of the index + The type of the document + The document ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a DELETE on /{index}/{type}/{id} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-delete.html + + The name of the index + The type of the document + The document ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a DELETE on /{index}/{type}/{id} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-delete.html + + The name of the index + The type of the document + The document ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a DELETE on /{index}/_query + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-delete-by-query.html + + A comma-separated list of indices to restrict the operation; use `_all` to perform the operation on all indices + A query to restrict the operation specified with the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a DELETE on /{index}/_query + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-delete-by-query.html + + A comma-separated list of indices to restrict the operation; use `_all` to perform the operation on all indices + A query to restrict the operation specified with the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a DELETE on /{index}/_query + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-delete-by-query.html + + A comma-separated list of indices to restrict the operation; use `_all` to perform the operation on all indices + A query to restrict the operation specified with the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a DELETE on /{index}/_query + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-delete-by-query.html + + A comma-separated list of indices to restrict the operation; use `_all` to perform the operation on all indices + A query to restrict the operation specified with the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a DELETE on /{index}/{type}/_query + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-delete-by-query.html + + A comma-separated list of indices to restrict the operation; use `_all` to perform the operation on all indices + A comma-separated list of types to restrict the operation + A query to restrict the operation specified with the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a DELETE on /{index}/{type}/_query + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-delete-by-query.html + + A comma-separated list of indices to restrict the operation; use `_all` to perform the operation on all indices + A comma-separated list of types to restrict the operation + A query to restrict the operation specified with the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a DELETE on /{index}/{type}/_query + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-delete-by-query.html + + A comma-separated list of indices to restrict the operation; use `_all` to perform the operation on all indices + A comma-separated list of types to restrict the operation + A query to restrict the operation specified with the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a DELETE on /{index}/{type}/_query + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-delete-by-query.html + + A comma-separated list of indices to restrict the operation; use `_all` to perform the operation on all indices + A comma-separated list of types to restrict the operation + A query to restrict the operation specified with the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a DELETE on /_scripts/{lang}/{id} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html + + Script language + Script ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a DELETE on /_scripts/{lang}/{id} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html + + Script language + Script ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a DELETE on /_scripts/{lang}/{id} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html + + Script language + Script ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a DELETE on /_scripts/{lang}/{id} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html + + Script language + Script ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a DELETE on /_search/template/{id} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html + + Template ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a DELETE on /_search/template/{id} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html + + Template ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a DELETE on /_search/template/{id} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html + + Template ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a DELETE on /_search/template/{id} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html + + Template ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a HEAD on /{index}/{type}/{id} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-get.html + + The name of the index + The type of the document (use `_all` to fetch the first document matching the ID across all types) + The document ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a HEAD on /{index}/{type}/{id} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-get.html + + The name of the index + The type of the document (use `_all` to fetch the first document matching the ID across all types) + The document ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a HEAD on /{index}/{type}/{id} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-get.html + + The name of the index + The type of the document (use `_all` to fetch the first document matching the ID across all types) + The document ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a HEAD on /{index}/{type}/{id} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-get.html + + The name of the index + The type of the document (use `_all` to fetch the first document matching the ID across all types) + The document ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/{id}/_explain + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-explain.html + + The name of the index + The type of the document + The document ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/{id}/_explain + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-explain.html + + The name of the index + The type of the document + The document ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/{id}/_explain + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-explain.html + + The name of the index + The type of the document + The document ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/{id}/_explain + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-explain.html + + The name of the index + The type of the document + The document ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/{id}/_explain + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-explain.html + + The name of the index + The type of the document + The document ID + The query definition using the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/{id}/_explain + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-explain.html + + The name of the index + The type of the document + The document ID + The query definition using the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/{id}/_explain + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-explain.html + + The name of the index + The type of the document + The document ID + The query definition using the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/{id}/_explain + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-explain.html + + The name of the index + The type of the document + The document ID + The query definition using the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/{id} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-get.html + + The name of the index + The type of the document (use `_all` to fetch the first document matching the ID across all types) + The document ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/{id} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-get.html + + The name of the index + The type of the document (use `_all` to fetch the first document matching the ID across all types) + The document ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/{id} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-get.html + + The name of the index + The type of the document (use `_all` to fetch the first document matching the ID across all types) + The document ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/{id} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-get.html + + The name of the index + The type of the document (use `_all` to fetch the first document matching the ID across all types) + The document ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_scripts/{lang}/{id} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html + + Script language + Script ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_scripts/{lang}/{id} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html + + Script language + Script ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_scripts/{lang}/{id} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html + + Script language + Script ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_scripts/{lang}/{id} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html + + Script language + Script ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/{id}/_source + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-get.html + + The name of the index + The type of the document; use `_all` to fetch the first document matching the ID across all types + The document ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/{id}/_source + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-get.html + + The name of the index + The type of the document; use `_all` to fetch the first document matching the ID across all types + The document ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/{id}/_source + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-get.html + + The name of the index + The type of the document; use `_all` to fetch the first document matching the ID across all types + The document ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/{id}/_source + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-get.html + + The name of the index + The type of the document; use `_all` to fetch the first document matching the ID across all types + The document ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_search/template/{id} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html + + Template ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_search/template/{id} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html + + Template ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_search/template/{id} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html + + Template ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_search/template/{id} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html + + Template ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-index_.html + + The name of the index + The type of the document + The document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-index_.html + + The name of the index + The type of the document + The document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-index_.html + + The name of the index + The type of the document + The document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-index_.html + + The name of the index + The type of the document + The document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/{id} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-index_.html + + The name of the index + The type of the document + Document ID + The document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/{id} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-index_.html + + The name of the index + The type of the document + Document ID + The document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/{id} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-index_.html + + The name of the index + The type of the document + Document ID + The document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/{id} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-index_.html + + The name of the index + The type of the document + Document ID + The document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /{index}/{type} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-index_.html + + The name of the index + The type of the document + The document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /{index}/{type} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-index_.html + + The name of the index + The type of the document + The document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /{index}/{type} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-index_.html + + The name of the index + The type of the document + The document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /{index}/{type} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-index_.html + + The name of the index + The type of the document + The document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /{index}/{type}/{id} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-index_.html + + The name of the index + The type of the document + Document ID + The document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /{index}/{type}/{id} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-index_.html + + The name of the index + The type of the document + Document ID + The document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /{index}/{type}/{id} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-index_.html + + The name of the index + The type of the document + Document ID + The document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /{index}/{type}/{id} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-index_.html + + The name of the index + The type of the document + Document ID + The document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_analyze + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-analyze.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_analyze + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-analyze.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_analyze + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-analyze.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_analyze + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-analyze.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_analyze + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-analyze.html + + The name of the index to scope the operation + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_analyze + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-analyze.html + + The name of the index to scope the operation + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_analyze + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-analyze.html + + The name of the index to scope the operation + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_analyze + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-analyze.html + + The name of the index to scope the operation + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_analyze + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-analyze.html + + The text on which the analysis should be performed + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_analyze + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-analyze.html + + The text on which the analysis should be performed + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_analyze + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-analyze.html + + The text on which the analysis should be performed + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_analyze + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-analyze.html + + The text on which the analysis should be performed + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_analyze + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-analyze.html + + The name of the index to scope the operation + The text on which the analysis should be performed + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_analyze + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-analyze.html + + The name of the index to scope the operation + The text on which the analysis should be performed + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_analyze + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-analyze.html + + The name of the index to scope the operation + The text on which the analysis should be performed + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_analyze + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-analyze.html + + The name of the index to scope the operation + The text on which the analysis should be performed + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_cache/clear + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-clearcache.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_cache/clear + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-clearcache.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_cache/clear + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-clearcache.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_cache/clear + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-clearcache.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_cache/clear + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-clearcache.html + + A comma-separated list of index name to limit the operation + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_cache/clear + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-clearcache.html + + A comma-separated list of index name to limit the operation + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_cache/clear + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-clearcache.html + + A comma-separated list of index name to limit the operation + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_cache/clear + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-clearcache.html + + A comma-separated list of index name to limit the operation + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cache/clear + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-clearcache.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cache/clear + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-clearcache.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cache/clear + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-clearcache.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cache/clear + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-clearcache.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_cache/clear + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-clearcache.html + + A comma-separated list of index name to limit the operation + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_cache/clear + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-clearcache.html + + A comma-separated list of index name to limit the operation + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_cache/clear + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-clearcache.html + + A comma-separated list of index name to limit the operation + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_cache/clear + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-clearcache.html + + A comma-separated list of index name to limit the operation + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_close + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-open-close.html + + The name of the index + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_close + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-open-close.html + + The name of the index + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_close + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-open-close.html + + The name of the index + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_close + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-open-close.html + + The name of the index + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /{index} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-create-index.html + + The name of the index + The configuration for the index (`settings` and `mappings`) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /{index} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-create-index.html + + The name of the index + The configuration for the index (`settings` and `mappings`) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /{index} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-create-index.html + + The name of the index + The configuration for the index (`settings` and `mappings`) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /{index} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-create-index.html + + The name of the index + The configuration for the index (`settings` and `mappings`) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-create-index.html + + The name of the index + The configuration for the index (`settings` and `mappings`) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-create-index.html + + The name of the index + The configuration for the index (`settings` and `mappings`) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-create-index.html + + The name of the index + The configuration for the index (`settings` and `mappings`) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-create-index.html + + The name of the index + The configuration for the index (`settings` and `mappings`) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a DELETE on /{index} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-delete-index.html + + A comma-separated list of indices to delete; use `_all` or `*` string to delete all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a DELETE on /{index} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-delete-index.html + + A comma-separated list of indices to delete; use `_all` or `*` string to delete all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a DELETE on /{index} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-delete-index.html + + A comma-separated list of indices to delete; use `_all` or `*` string to delete all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a DELETE on /{index} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-delete-index.html + + A comma-separated list of indices to delete; use `_all` or `*` string to delete all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a DELETE on /{index}/_alias/{name} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names (supports wildcards); use `_all` for all indices + A comma-separated list of aliases to delete (supports wildcards); use `_all` to delete all aliases for the specified indices. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a DELETE on /{index}/_alias/{name} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names (supports wildcards); use `_all` for all indices + A comma-separated list of aliases to delete (supports wildcards); use `_all` to delete all aliases for the specified indices. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a DELETE on /{index}/_alias/{name} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names (supports wildcards); use `_all` for all indices + A comma-separated list of aliases to delete (supports wildcards); use `_all` to delete all aliases for the specified indices. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a DELETE on /{index}/_alias/{name} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names (supports wildcards); use `_all` for all indices + A comma-separated list of aliases to delete (supports wildcards); use `_all` to delete all aliases for the specified indices. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a DELETE on /{index}/{type}/_mapping + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-delete-mapping.html + + A comma-separated list of index names (supports wildcards); use `_all` for all indices + A comma-separated list of document types to delete (supports wildcards); use `_all` to delete all document types in the specified indices. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a DELETE on /{index}/{type}/_mapping + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-delete-mapping.html + + A comma-separated list of index names (supports wildcards); use `_all` for all indices + A comma-separated list of document types to delete (supports wildcards); use `_all` to delete all document types in the specified indices. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a DELETE on /{index}/{type}/_mapping + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-delete-mapping.html + + A comma-separated list of index names (supports wildcards); use `_all` for all indices + A comma-separated list of document types to delete (supports wildcards); use `_all` to delete all document types in the specified indices. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a DELETE on /{index}/{type}/_mapping + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-delete-mapping.html + + A comma-separated list of index names (supports wildcards); use `_all` for all indices + A comma-separated list of document types to delete (supports wildcards); use `_all` to delete all document types in the specified indices. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a DELETE on /_template/{name} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html + + The name of the template + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a DELETE on /_template/{name} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html + + The name of the template + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a DELETE on /_template/{name} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html + + The name of the template + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a DELETE on /_template/{name} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html + + The name of the template + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a DELETE on /{index}/_warmer/{name} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + A comma-separated list of index names to delete warmers from (supports wildcards); use `_all` to perform the operation on all indices. + A comma-separated list of warmer names to delete (supports wildcards); use `_all` to delete all warmers in the specified indices. You must specify a name either in the uri or in the parameters. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a DELETE on /{index}/_warmer/{name} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + A comma-separated list of index names to delete warmers from (supports wildcards); use `_all` to perform the operation on all indices. + A comma-separated list of warmer names to delete (supports wildcards); use `_all` to delete all warmers in the specified indices. You must specify a name either in the uri or in the parameters. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a DELETE on /{index}/_warmer/{name} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + A comma-separated list of index names to delete warmers from (supports wildcards); use `_all` to perform the operation on all indices. + A comma-separated list of warmer names to delete (supports wildcards); use `_all` to delete all warmers in the specified indices. You must specify a name either in the uri or in the parameters. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a DELETE on /{index}/_warmer/{name} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + A comma-separated list of index names to delete warmers from (supports wildcards); use `_all` to perform the operation on all indices. + A comma-separated list of warmer names to delete (supports wildcards); use `_all` to delete all warmers in the specified indices. You must specify a name either in the uri or in the parameters. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a HEAD on /{index} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-settings.html + + A comma-separated list of indices to check + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a HEAD on /{index} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-settings.html + + A comma-separated list of indices to check + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a HEAD on /{index} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-settings.html + + A comma-separated list of indices to check + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a HEAD on /{index} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-settings.html + + A comma-separated list of indices to check + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a HEAD on /_alias/{name} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of alias names to return + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a HEAD on /_alias/{name} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of alias names to return + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a HEAD on /_alias/{name} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of alias names to return + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a HEAD on /_alias/{name} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of alias names to return + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a HEAD on /{index}/_alias/{name} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names to filter aliases + A comma-separated list of alias names to return + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a HEAD on /{index}/_alias/{name} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names to filter aliases + A comma-separated list of alias names to return + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a HEAD on /{index}/_alias/{name} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names to filter aliases + A comma-separated list of alias names to return + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a HEAD on /{index}/_alias/{name} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names to filter aliases + A comma-separated list of alias names to return + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a HEAD on /{index}/_alias + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names to filter aliases + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a HEAD on /{index}/_alias + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names to filter aliases + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a HEAD on /{index}/_alias + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names to filter aliases + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a HEAD on /{index}/_alias + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names to filter aliases + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a HEAD on /_template/{name} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html + + The name of the template + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a HEAD on /_template/{name} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html + + The name of the template + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a HEAD on /_template/{name} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html + + The name of the template + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a HEAD on /_template/{name} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html + + The name of the template + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a HEAD on /{index}/{type} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-types-exists.html + + A comma-separated list of index names; use `_all` to check the types across all indices + A comma-separated list of document types to check + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a HEAD on /{index}/{type} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-types-exists.html + + A comma-separated list of index names; use `_all` to check the types across all indices + A comma-separated list of document types to check + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a HEAD on /{index}/{type} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-types-exists.html + + A comma-separated list of index names; use `_all` to check the types across all indices + A comma-separated list of document types to check + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a HEAD on /{index}/{type} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-types-exists.html + + A comma-separated list of index names; use `_all` to check the types across all indices + A comma-separated list of document types to check + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_flush + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-flush.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_flush + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-flush.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_flush + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-flush.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_flush + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-flush.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_flush + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-flush.html + + A comma-separated list of index names; use `_all` or empty string for all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_flush + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-flush.html + + A comma-separated list of index names; use `_all` or empty string for all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_flush + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-flush.html + + A comma-separated list of index names; use `_all` or empty string for all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_flush + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-flush.html + + A comma-separated list of index names; use `_all` or empty string for all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_flush + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-flush.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_flush + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-flush.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_flush + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-flush.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_flush + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-flush.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_flush + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-flush.html + + A comma-separated list of index names; use `_all` or empty string for all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_flush + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-flush.html + + A comma-separated list of index names; use `_all` or empty string for all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_flush + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-flush.html + + A comma-separated list of index names; use `_all` or empty string for all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_flush + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-flush.html + + A comma-separated list of index names; use `_all` or empty string for all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_alias + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_alias + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_alias + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_alias + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_alias/{name} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of alias names to return + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_alias/{name} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of alias names to return + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_alias/{name} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of alias names to return + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_alias/{name} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of alias names to return + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_alias/{name} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names to filter aliases + A comma-separated list of alias names to return + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_alias/{name} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names to filter aliases + A comma-separated list of alias names to return + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_alias/{name} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names to filter aliases + A comma-separated list of alias names to return + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_alias/{name} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names to filter aliases + A comma-separated list of alias names to return + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_alias + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names to filter aliases + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_alias + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names to filter aliases + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_alias + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names to filter aliases + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_alias + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names to filter aliases + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_aliases + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_aliases + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_aliases + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_aliases + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_aliases + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names to filter aliases + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_aliases + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names to filter aliases + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_aliases + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names to filter aliases + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_aliases + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names to filter aliases + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_aliases/{name} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names to filter aliases + A comma-separated list of alias names to filter + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_aliases/{name} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names to filter aliases + A comma-separated list of alias names to filter + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_aliases/{name} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names to filter aliases + A comma-separated list of alias names to filter + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_aliases/{name} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names to filter aliases + A comma-separated list of alias names to filter + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_aliases/{name} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of alias names to filter + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_aliases/{name} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of alias names to filter + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_aliases/{name} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of alias names to filter + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_aliases/{name} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of alias names to filter + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_mapping/field/{field} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-field-mapping.html + + A comma-separated list of fields + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_mapping/field/{field} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-field-mapping.html + + A comma-separated list of fields + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_mapping/field/{field} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-field-mapping.html + + A comma-separated list of fields + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_mapping/field/{field} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-field-mapping.html + + A comma-separated list of fields + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_mapping/field/{field} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-field-mapping.html + + A comma-separated list of index names + A comma-separated list of fields + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_mapping/field/{field} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-field-mapping.html + + A comma-separated list of index names + A comma-separated list of fields + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_mapping/field/{field} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-field-mapping.html + + A comma-separated list of index names + A comma-separated list of fields + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_mapping/field/{field} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-field-mapping.html + + A comma-separated list of index names + A comma-separated list of fields + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_mapping/{type}/field/{field} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-field-mapping.html + + A comma-separated list of document types + A comma-separated list of fields + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_mapping/{type}/field/{field} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-field-mapping.html + + A comma-separated list of document types + A comma-separated list of fields + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_mapping/{type}/field/{field} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-field-mapping.html + + A comma-separated list of document types + A comma-separated list of fields + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_mapping/{type}/field/{field} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-field-mapping.html + + A comma-separated list of document types + A comma-separated list of fields + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_mapping/{type}/field/{field} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-field-mapping.html + + A comma-separated list of index names + A comma-separated list of document types + A comma-separated list of fields + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_mapping/{type}/field/{field} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-field-mapping.html + + A comma-separated list of index names + A comma-separated list of document types + A comma-separated list of fields + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_mapping/{type}/field/{field} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-field-mapping.html + + A comma-separated list of index names + A comma-separated list of document types + A comma-separated list of fields + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_mapping/{type}/field/{field} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-field-mapping.html + + A comma-separated list of index names + A comma-separated list of document types + A comma-separated list of fields + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_mapping + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_mapping + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_mapping + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_mapping + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_mapping + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html + + A comma-separated list of index names + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_mapping + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html + + A comma-separated list of index names + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_mapping + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html + + A comma-separated list of index names + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_mapping + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html + + A comma-separated list of index names + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_mapping/{type} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html + + A comma-separated list of document types + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_mapping/{type} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html + + A comma-separated list of document types + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_mapping/{type} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html + + A comma-separated list of document types + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_mapping/{type} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html + + A comma-separated list of document types + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_mapping/{type} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html + + A comma-separated list of index names + A comma-separated list of document types + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_mapping/{type} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html + + A comma-separated list of index names + A comma-separated list of document types + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_mapping/{type} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html + + A comma-separated list of index names + A comma-separated list of document types + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_mapping/{type} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html + + A comma-separated list of index names + A comma-separated list of document types + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_settings + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_settings + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_settings + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_settings + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_settings + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_settings + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_settings + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_settings + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_settings/{name} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + The name of the settings that should be included + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_settings/{name} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + The name of the settings that should be included + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_settings/{name} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + The name of the settings that should be included + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_settings/{name} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + The name of the settings that should be included + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_settings/{name} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html + + The name of the settings that should be included + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_settings/{name} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html + + The name of the settings that should be included + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_settings/{name} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html + + The name of the settings that should be included + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_settings/{name} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html + + The name of the settings that should be included + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_template + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_template + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_template + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_template + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_template/{name} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html + + The name of the template + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_template/{name} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html + + The name of the template + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_template/{name} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html + + The name of the template + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_template/{name} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html + + The name of the template + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_warmer + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_warmer + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_warmer + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_warmer + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_warmer + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + A comma-separated list of index names to restrict the operation; use `_all` to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_warmer + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + A comma-separated list of index names to restrict the operation; use `_all` to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_warmer + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + A comma-separated list of index names to restrict the operation; use `_all` to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_warmer + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + A comma-separated list of index names to restrict the operation; use `_all` to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_warmer/{name} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + A comma-separated list of index names to restrict the operation; use `_all` to perform the operation on all indices + The name of the warmer (supports wildcards); leave empty to get all warmers + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_warmer/{name} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + A comma-separated list of index names to restrict the operation; use `_all` to perform the operation on all indices + The name of the warmer (supports wildcards); leave empty to get all warmers + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_warmer/{name} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + A comma-separated list of index names to restrict the operation; use `_all` to perform the operation on all indices + The name of the warmer (supports wildcards); leave empty to get all warmers + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_warmer/{name} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + A comma-separated list of index names to restrict the operation; use `_all` to perform the operation on all indices + The name of the warmer (supports wildcards); leave empty to get all warmers + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_warmer/{name} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + The name of the warmer (supports wildcards); leave empty to get all warmers + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_warmer/{name} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + The name of the warmer (supports wildcards); leave empty to get all warmers + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_warmer/{name} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + The name of the warmer (supports wildcards); leave empty to get all warmers + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_warmer/{name} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + The name of the warmer (supports wildcards); leave empty to get all warmers + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/_warmer/{name} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + A comma-separated list of index names to restrict the operation; use `_all` to perform the operation on all indices + A comma-separated list of document types to restrict the operation; leave empty to perform the operation on all types + The name of the warmer (supports wildcards); leave empty to get all warmers + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/_warmer/{name} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + A comma-separated list of index names to restrict the operation; use `_all` to perform the operation on all indices + A comma-separated list of document types to restrict the operation; leave empty to perform the operation on all types + The name of the warmer (supports wildcards); leave empty to get all warmers + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/_warmer/{name} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + A comma-separated list of index names to restrict the operation; use `_all` to perform the operation on all indices + A comma-separated list of document types to restrict the operation; leave empty to perform the operation on all types + The name of the warmer (supports wildcards); leave empty to get all warmers + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/_warmer/{name} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + A comma-separated list of index names to restrict the operation; use `_all` to perform the operation on all indices + A comma-separated list of document types to restrict the operation; leave empty to perform the operation on all types + The name of the warmer (supports wildcards); leave empty to get all warmers + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_open + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-open-close.html + + The name of the index + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_open + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-open-close.html + + The name of the index + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_open + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-open-close.html + + The name of the index + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_open + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-open-close.html + + The name of the index + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_optimize + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-optimize.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_optimize + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-optimize.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_optimize + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-optimize.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_optimize + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-optimize.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_optimize + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-optimize.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_optimize + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-optimize.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_optimize + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-optimize.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_optimize + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-optimize.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_optimize + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-optimize.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_optimize + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-optimize.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_optimize + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-optimize.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_optimize + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-optimize.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_optimize + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-optimize.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_optimize + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-optimize.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_optimize + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-optimize.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_optimize + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-optimize.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /{index}/_alias/{name} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names the alias should point to (supports wildcards); use `_all` or omit to perform the operation on all indices. + The name of the alias to be created or updated + The settings for the alias, such as `routing` or `filter` + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /{index}/_alias/{name} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names the alias should point to (supports wildcards); use `_all` or omit to perform the operation on all indices. + The name of the alias to be created or updated + The settings for the alias, such as `routing` or `filter` + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /{index}/_alias/{name} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names the alias should point to (supports wildcards); use `_all` or omit to perform the operation on all indices. + The name of the alias to be created or updated + The settings for the alias, such as `routing` or `filter` + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /{index}/_alias/{name} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names the alias should point to (supports wildcards); use `_all` or omit to perform the operation on all indices. + The name of the alias to be created or updated + The settings for the alias, such as `routing` or `filter` + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /_alias/{name} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + The name of the alias to be created or updated + The settings for the alias, such as `routing` or `filter` + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /_alias/{name} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + The name of the alias to be created or updated + The settings for the alias, such as `routing` or `filter` + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /_alias/{name} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + The name of the alias to be created or updated + The settings for the alias, such as `routing` or `filter` + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /_alias/{name} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + The name of the alias to be created or updated + The settings for the alias, such as `routing` or `filter` + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_alias/{name} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names the alias should point to (supports wildcards); use `_all` or omit to perform the operation on all indices. + The name of the alias to be created or updated + The settings for the alias, such as `routing` or `filter` + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_alias/{name} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names the alias should point to (supports wildcards); use `_all` or omit to perform the operation on all indices. + The name of the alias to be created or updated + The settings for the alias, such as `routing` or `filter` + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_alias/{name} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names the alias should point to (supports wildcards); use `_all` or omit to perform the operation on all indices. + The name of the alias to be created or updated + The settings for the alias, such as `routing` or `filter` + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_alias/{name} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + A comma-separated list of index names the alias should point to (supports wildcards); use `_all` or omit to perform the operation on all indices. + The name of the alias to be created or updated + The settings for the alias, such as `routing` or `filter` + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_alias/{name} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + The name of the alias to be created or updated + The settings for the alias, such as `routing` or `filter` + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_alias/{name} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + The name of the alias to be created or updated + The settings for the alias, such as `routing` or `filter` + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_alias/{name} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + The name of the alias to be created or updated + The settings for the alias, such as `routing` or `filter` + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_alias/{name} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + The name of the alias to be created or updated + The settings for the alias, such as `routing` or `filter` + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /{index}/{type}/_mapping + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-put-mapping.html + + A comma-separated list of index names the mapping should be added to (supports wildcards); use `_all` or omit to add the mapping on all indices. + The name of the document type + The mapping definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /{index}/{type}/_mapping + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-put-mapping.html + + A comma-separated list of index names the mapping should be added to (supports wildcards); use `_all` or omit to add the mapping on all indices. + The name of the document type + The mapping definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /{index}/{type}/_mapping + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-put-mapping.html + + A comma-separated list of index names the mapping should be added to (supports wildcards); use `_all` or omit to add the mapping on all indices. + The name of the document type + The mapping definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /{index}/{type}/_mapping + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-put-mapping.html + + A comma-separated list of index names the mapping should be added to (supports wildcards); use `_all` or omit to add the mapping on all indices. + The name of the document type + The mapping definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /_mapping/{type} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-put-mapping.html + + The name of the document type + The mapping definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /_mapping/{type} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-put-mapping.html + + The name of the document type + The mapping definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /_mapping/{type} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-put-mapping.html + + The name of the document type + The mapping definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /_mapping/{type} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-put-mapping.html + + The name of the document type + The mapping definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/_mapping + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-put-mapping.html + + A comma-separated list of index names the mapping should be added to (supports wildcards); use `_all` or omit to add the mapping on all indices. + The name of the document type + The mapping definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/_mapping + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-put-mapping.html + + A comma-separated list of index names the mapping should be added to (supports wildcards); use `_all` or omit to add the mapping on all indices. + The name of the document type + The mapping definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/_mapping + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-put-mapping.html + + A comma-separated list of index names the mapping should be added to (supports wildcards); use `_all` or omit to add the mapping on all indices. + The name of the document type + The mapping definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/_mapping + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-put-mapping.html + + A comma-separated list of index names the mapping should be added to (supports wildcards); use `_all` or omit to add the mapping on all indices. + The name of the document type + The mapping definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_mapping/{type} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-put-mapping.html + + The name of the document type + The mapping definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_mapping/{type} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-put-mapping.html + + The name of the document type + The mapping definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_mapping/{type} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-put-mapping.html + + The name of the document type + The mapping definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_mapping/{type} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-put-mapping.html + + The name of the document type + The mapping definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /_settings + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-update-settings.html + + The index settings to be updated + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /_settings + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-update-settings.html + + The index settings to be updated + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /_settings + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-update-settings.html + + The index settings to be updated + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /_settings + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-update-settings.html + + The index settings to be updated + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /{index}/_settings + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-update-settings.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + The index settings to be updated + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /{index}/_settings + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-update-settings.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + The index settings to be updated + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /{index}/_settings + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-update-settings.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + The index settings to be updated + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /{index}/_settings + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-update-settings.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + The index settings to be updated + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /_template/{name} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html + + The name of the template + The template definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /_template/{name} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html + + The name of the template + The template definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /_template/{name} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html + + The name of the template + The template definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /_template/{name} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html + + The name of the template + The template definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_template/{name} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html + + The name of the template + The template definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_template/{name} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html + + The name of the template + The template definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_template/{name} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html + + The name of the template + The template definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_template/{name} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html + + The name of the template + The template definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /_warmer/{name} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + The name of the warmer + The search request definition for the warmer (query, filters, facets, sorting, etc) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /_warmer/{name} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + The name of the warmer + The search request definition for the warmer (query, filters, facets, sorting, etc) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /_warmer/{name} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + The name of the warmer + The search request definition for the warmer (query, filters, facets, sorting, etc) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /_warmer/{name} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + The name of the warmer + The search request definition for the warmer (query, filters, facets, sorting, etc) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /{index}/_warmer/{name} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + A comma-separated list of index names to register the warmer for; use `_all` or omit to perform the operation on all indices + The name of the warmer + The search request definition for the warmer (query, filters, facets, sorting, etc) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /{index}/_warmer/{name} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + A comma-separated list of index names to register the warmer for; use `_all` or omit to perform the operation on all indices + The name of the warmer + The search request definition for the warmer (query, filters, facets, sorting, etc) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /{index}/_warmer/{name} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + A comma-separated list of index names to register the warmer for; use `_all` or omit to perform the operation on all indices + The name of the warmer + The search request definition for the warmer (query, filters, facets, sorting, etc) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /{index}/_warmer/{name} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + A comma-separated list of index names to register the warmer for; use `_all` or omit to perform the operation on all indices + The name of the warmer + The search request definition for the warmer (query, filters, facets, sorting, etc) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /{index}/{type}/_warmer/{name} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + A comma-separated list of index names to register the warmer for; use `_all` or omit to perform the operation on all indices + A comma-separated list of document types to register the warmer for; leave empty to perform the operation on all types + The name of the warmer + The search request definition for the warmer (query, filters, facets, sorting, etc) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /{index}/{type}/_warmer/{name} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + A comma-separated list of index names to register the warmer for; use `_all` or omit to perform the operation on all indices + A comma-separated list of document types to register the warmer for; leave empty to perform the operation on all types + The name of the warmer + The search request definition for the warmer (query, filters, facets, sorting, etc) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /{index}/{type}/_warmer/{name} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + A comma-separated list of index names to register the warmer for; use `_all` or omit to perform the operation on all indices + A comma-separated list of document types to register the warmer for; leave empty to perform the operation on all types + The name of the warmer + The search request definition for the warmer (query, filters, facets, sorting, etc) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /{index}/{type}/_warmer/{name} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + A comma-separated list of index names to register the warmer for; use `_all` or omit to perform the operation on all indices + A comma-separated list of document types to register the warmer for; leave empty to perform the operation on all types + The name of the warmer + The search request definition for the warmer (query, filters, facets, sorting, etc) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_warmer/{name} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + The name of the warmer + The search request definition for the warmer (query, filters, facets, sorting, etc) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_warmer/{name} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + The name of the warmer + The search request definition for the warmer (query, filters, facets, sorting, etc) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_warmer/{name} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + The name of the warmer + The search request definition for the warmer (query, filters, facets, sorting, etc) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_warmer/{name} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + The name of the warmer + The search request definition for the warmer (query, filters, facets, sorting, etc) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_warmer/{name} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + A comma-separated list of index names to register the warmer for; use `_all` or omit to perform the operation on all indices + The name of the warmer + The search request definition for the warmer (query, filters, facets, sorting, etc) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_warmer/{name} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + A comma-separated list of index names to register the warmer for; use `_all` or omit to perform the operation on all indices + The name of the warmer + The search request definition for the warmer (query, filters, facets, sorting, etc) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_warmer/{name} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + A comma-separated list of index names to register the warmer for; use `_all` or omit to perform the operation on all indices + The name of the warmer + The search request definition for the warmer (query, filters, facets, sorting, etc) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_warmer/{name} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + A comma-separated list of index names to register the warmer for; use `_all` or omit to perform the operation on all indices + The name of the warmer + The search request definition for the warmer (query, filters, facets, sorting, etc) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/_warmer/{name} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + A comma-separated list of index names to register the warmer for; use `_all` or omit to perform the operation on all indices + A comma-separated list of document types to register the warmer for; leave empty to perform the operation on all types + The name of the warmer + The search request definition for the warmer (query, filters, facets, sorting, etc) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/_warmer/{name} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + A comma-separated list of index names to register the warmer for; use `_all` or omit to perform the operation on all indices + A comma-separated list of document types to register the warmer for; leave empty to perform the operation on all types + The name of the warmer + The search request definition for the warmer (query, filters, facets, sorting, etc) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/_warmer/{name} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + A comma-separated list of index names to register the warmer for; use `_all` or omit to perform the operation on all indices + A comma-separated list of document types to register the warmer for; leave empty to perform the operation on all types + The name of the warmer + The search request definition for the warmer (query, filters, facets, sorting, etc) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/_warmer/{name} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html + + A comma-separated list of index names to register the warmer for; use `_all` or omit to perform the operation on all indices + A comma-separated list of document types to register the warmer for; leave empty to perform the operation on all types + The name of the warmer + The search request definition for the warmer (query, filters, facets, sorting, etc) + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_recovery + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/indices-recovery.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_recovery + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/indices-recovery.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_recovery + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/indices-recovery.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_recovery + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/indices-recovery.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_recovery + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/indices-recovery.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_recovery + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/indices-recovery.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_recovery + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/indices-recovery.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_recovery + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/indices-recovery.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_refresh + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-refresh.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_refresh + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-refresh.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_refresh + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-refresh.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_refresh + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-refresh.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_refresh + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-refresh.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_refresh + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-refresh.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_refresh + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-refresh.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_refresh + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-refresh.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_refresh + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-refresh.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_refresh + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-refresh.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_refresh + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-refresh.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_refresh + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-refresh.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_refresh + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-refresh.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_refresh + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-refresh.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_refresh + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-refresh.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_refresh + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-refresh.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_segments + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-segments.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_segments + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-segments.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_segments + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-segments.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_segments + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-segments.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_segments + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-segments.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_segments + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-segments.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_segments + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-segments.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_segments + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-segments.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_stats + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-stats.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_stats + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-stats.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_stats + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-stats.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_stats + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-stats.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_stats/{metric} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-stats.html + + Limit the information returned the specific metrics. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_stats/{metric} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-stats.html + + Limit the information returned the specific metrics. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_stats/{metric} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-stats.html + + Limit the information returned the specific metrics. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_stats/{metric} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-stats.html + + Limit the information returned the specific metrics. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_stats + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-stats.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_stats + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-stats.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_stats + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-stats.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_stats + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-stats.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_stats/{metric} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-stats.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + Limit the information returned the specific metrics. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_stats/{metric} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-stats.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + Limit the information returned the specific metrics. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_stats/{metric} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-stats.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + Limit the information returned the specific metrics. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_stats/{metric} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-stats.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + Limit the information returned the specific metrics. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_status + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-status.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_status + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-status.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_status + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-status.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_status + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-status.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_status + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-status.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_status + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-status.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_status + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-status.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_status + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-status.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_aliases + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + The definition of `actions` to perform + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_aliases + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + The definition of `actions` to perform + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_aliases + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + The definition of `actions` to perform + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_aliases + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html + + The definition of `actions` to perform + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_validate/query + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_validate/query + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_validate/query + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_validate/query + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_validate/query + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html + + A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_validate/query + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html + + A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_validate/query + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html + + A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_validate/query + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html + + A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/_validate/query + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html + + A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices + A comma-separated list of document types to restrict the operation; leave empty to perform the operation on all types + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/_validate/query + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html + + A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices + A comma-separated list of document types to restrict the operation; leave empty to perform the operation on all types + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/_validate/query + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html + + A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices + A comma-separated list of document types to restrict the operation; leave empty to perform the operation on all types + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/_validate/query + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html + + A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices + A comma-separated list of document types to restrict the operation; leave empty to perform the operation on all types + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_validate/query + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html + + The query definition specified with the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_validate/query + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html + + The query definition specified with the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_validate/query + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html + + The query definition specified with the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_validate/query + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html + + The query definition specified with the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_validate/query + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html + + A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices + The query definition specified with the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_validate/query + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html + + A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices + The query definition specified with the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_validate/query + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html + + A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices + The query definition specified with the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_validate/query + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html + + A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices + The query definition specified with the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/_validate/query + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html + + A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices + A comma-separated list of document types to restrict the operation; leave empty to perform the operation on all types + The query definition specified with the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/_validate/query + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html + + A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices + A comma-separated list of document types to restrict the operation; leave empty to perform the operation on all types + The query definition specified with the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/_validate/query + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html + + A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices + A comma-separated list of document types to restrict the operation; leave empty to perform the operation on all types + The query definition specified with the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/_validate/query + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html + + A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices + A comma-separated list of document types to restrict the operation; leave empty to perform the operation on all types + The query definition specified with the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on / + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/ + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on / + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/ + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on / + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/ + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on / + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/ + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_bench + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-benchmark.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_bench + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-benchmark.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_bench + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-benchmark.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_bench + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-benchmark.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_bench + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-benchmark.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_bench + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-benchmark.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_bench + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-benchmark.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_bench + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-benchmark.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/_bench + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-benchmark.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + The name of the document type + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/_bench + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-benchmark.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + The name of the document type + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/_bench + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-benchmark.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + The name of the document type + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/_bench + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-benchmark.html + + A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices + The name of the document type + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_mget + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-get.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_mget + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-get.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_mget + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-get.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_mget + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-get.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_mget + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-get.html + + The name of the index + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_mget + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-get.html + + The name of the index + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_mget + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-get.html + + The name of the index + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_mget + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-get.html + + The name of the index + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/_mget + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-get.html + + The name of the index + The type of the document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/_mget + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-get.html + + The name of the index + The type of the document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/_mget + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-get.html + + The name of the index + The type of the document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/_mget + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-get.html + + The name of the index + The type of the document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_mget + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-get.html + + Document identifiers; can be either `docs` (containing full document information) or `ids` (when index and type is provided in the URL. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_mget + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-get.html + + Document identifiers; can be either `docs` (containing full document information) or `ids` (when index and type is provided in the URL. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_mget + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-get.html + + Document identifiers; can be either `docs` (containing full document information) or `ids` (when index and type is provided in the URL. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_mget + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-get.html + + Document identifiers; can be either `docs` (containing full document information) or `ids` (when index and type is provided in the URL. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_mget + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-get.html + + The name of the index + Document identifiers; can be either `docs` (containing full document information) or `ids` (when index and type is provided in the URL. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_mget + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-get.html + + The name of the index + Document identifiers; can be either `docs` (containing full document information) or `ids` (when index and type is provided in the URL. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_mget + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-get.html + + The name of the index + Document identifiers; can be either `docs` (containing full document information) or `ids` (when index and type is provided in the URL. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_mget + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-get.html + + The name of the index + Document identifiers; can be either `docs` (containing full document information) or `ids` (when index and type is provided in the URL. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/_mget + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-get.html + + The name of the index + The type of the document + Document identifiers; can be either `docs` (containing full document information) or `ids` (when index and type is provided in the URL. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/_mget + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-get.html + + The name of the index + The type of the document + Document identifiers; can be either `docs` (containing full document information) or `ids` (when index and type is provided in the URL. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/_mget + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-get.html + + The name of the index + The type of the document + Document identifiers; can be either `docs` (containing full document information) or `ids` (when index and type is provided in the URL. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/_mget + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-get.html + + The name of the index + The type of the document + Document identifiers; can be either `docs` (containing full document information) or `ids` (when index and type is provided in the URL. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/{id}/_mlt + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-more-like-this.html + + The name of the index + The type of the document (use `_all` to fetch the first document matching the ID across all types) + The document ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/{id}/_mlt + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-more-like-this.html + + The name of the index + The type of the document (use `_all` to fetch the first document matching the ID across all types) + The document ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/{id}/_mlt + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-more-like-this.html + + The name of the index + The type of the document (use `_all` to fetch the first document matching the ID across all types) + The document ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/{id}/_mlt + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-more-like-this.html + + The name of the index + The type of the document (use `_all` to fetch the first document matching the ID across all types) + The document ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/{id}/_mlt + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-more-like-this.html + + The name of the index + The type of the document (use `_all` to fetch the first document matching the ID across all types) + The document ID + A specific search request definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/{id}/_mlt + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-more-like-this.html + + The name of the index + The type of the document (use `_all` to fetch the first document matching the ID across all types) + The document ID + A specific search request definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/{id}/_mlt + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-more-like-this.html + + The name of the index + The type of the document (use `_all` to fetch the first document matching the ID across all types) + The document ID + A specific search request definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/{id}/_mlt + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-more-like-this.html + + The name of the index + The type of the document (use `_all` to fetch the first document matching the ID across all types) + The document ID + A specific search request definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_mpercolate + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_mpercolate + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_mpercolate + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_mpercolate + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_mpercolate + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being count percolated to use as default + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_mpercolate + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being count percolated to use as default + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_mpercolate + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being count percolated to use as default + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_mpercolate + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being count percolated to use as default + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/_mpercolate + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being count percolated to use as default + The type of the document being percolated to use as default. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/_mpercolate + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being count percolated to use as default + The type of the document being percolated to use as default. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/_mpercolate + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being count percolated to use as default + The type of the document being percolated to use as default. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/_mpercolate + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being count percolated to use as default + The type of the document being percolated to use as default. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_mpercolate + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The percolate request definitions (header & body pair), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_mpercolate + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The percolate request definitions (header & body pair), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_mpercolate + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The percolate request definitions (header & body pair), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_mpercolate + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The percolate request definitions (header & body pair), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_mpercolate + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being count percolated to use as default + The percolate request definitions (header & body pair), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_mpercolate + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being count percolated to use as default + The percolate request definitions (header & body pair), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_mpercolate + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being count percolated to use as default + The percolate request definitions (header & body pair), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_mpercolate + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being count percolated to use as default + The percolate request definitions (header & body pair), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/_mpercolate + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being count percolated to use as default + The type of the document being percolated to use as default. + The percolate request definitions (header & body pair), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/_mpercolate + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being count percolated to use as default + The type of the document being percolated to use as default. + The percolate request definitions (header & body pair), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/_mpercolate + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being count percolated to use as default + The type of the document being percolated to use as default. + The percolate request definitions (header & body pair), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/_mpercolate + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being count percolated to use as default + The type of the document being percolated to use as default. + The percolate request definitions (header & body pair), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_msearch + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-multi-search.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_msearch + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-multi-search.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_msearch + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-multi-search.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_msearch + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-multi-search.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_msearch + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-multi-search.html + + A comma-separated list of index names to use as default + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_msearch + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-multi-search.html + + A comma-separated list of index names to use as default + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_msearch + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-multi-search.html + + A comma-separated list of index names to use as default + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_msearch + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-multi-search.html + + A comma-separated list of index names to use as default + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/_msearch + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-multi-search.html + + A comma-separated list of index names to use as default + A comma-separated list of document types to use as default + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/_msearch + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-multi-search.html + + A comma-separated list of index names to use as default + A comma-separated list of document types to use as default + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/_msearch + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-multi-search.html + + A comma-separated list of index names to use as default + A comma-separated list of document types to use as default + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/_msearch + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-multi-search.html + + A comma-separated list of index names to use as default + A comma-separated list of document types to use as default + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_msearch + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-multi-search.html + + The request definitions (metadata-search request definition pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_msearch + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-multi-search.html + + The request definitions (metadata-search request definition pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_msearch + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-multi-search.html + + The request definitions (metadata-search request definition pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_msearch + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-multi-search.html + + The request definitions (metadata-search request definition pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_msearch + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-multi-search.html + + A comma-separated list of index names to use as default + The request definitions (metadata-search request definition pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_msearch + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-multi-search.html + + A comma-separated list of index names to use as default + The request definitions (metadata-search request definition pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_msearch + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-multi-search.html + + A comma-separated list of index names to use as default + The request definitions (metadata-search request definition pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_msearch + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-multi-search.html + + A comma-separated list of index names to use as default + The request definitions (metadata-search request definition pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/_msearch + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-multi-search.html + + A comma-separated list of index names to use as default + A comma-separated list of document types to use as default + The request definitions (metadata-search request definition pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/_msearch + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-multi-search.html + + A comma-separated list of index names to use as default + A comma-separated list of document types to use as default + The request definitions (metadata-search request definition pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/_msearch + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-multi-search.html + + A comma-separated list of index names to use as default + A comma-separated list of document types to use as default + The request definitions (metadata-search request definition pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/_msearch + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-multi-search.html + + A comma-separated list of index names to use as default + A comma-separated list of document types to use as default + The request definitions (metadata-search request definition pairs), separated by newlines + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_mtermvectors + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_mtermvectors + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_mtermvectors + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_mtermvectors + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_mtermvectors + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html + + The index in which the document resides. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_mtermvectors + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html + + The index in which the document resides. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_mtermvectors + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html + + The index in which the document resides. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_mtermvectors + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html + + The index in which the document resides. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/_mtermvectors + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html + + The index in which the document resides. + The type of the document. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/_mtermvectors + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html + + The index in which the document resides. + The type of the document. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/_mtermvectors + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html + + The index in which the document resides. + The type of the document. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/_mtermvectors + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html + + The index in which the document resides. + The type of the document. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_mtermvectors + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html + + Define ids, parameters or a list of parameters per document here. You must at least provide a list of document ids. See documentation. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_mtermvectors + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html + + Define ids, parameters or a list of parameters per document here. You must at least provide a list of document ids. See documentation. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_mtermvectors + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html + + Define ids, parameters or a list of parameters per document here. You must at least provide a list of document ids. See documentation. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_mtermvectors + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html + + Define ids, parameters or a list of parameters per document here. You must at least provide a list of document ids. See documentation. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_mtermvectors + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html + + The index in which the document resides. + Define ids, parameters or a list of parameters per document here. You must at least provide a list of document ids. See documentation. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_mtermvectors + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html + + The index in which the document resides. + Define ids, parameters or a list of parameters per document here. You must at least provide a list of document ids. See documentation. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_mtermvectors + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html + + The index in which the document resides. + Define ids, parameters or a list of parameters per document here. You must at least provide a list of document ids. See documentation. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_mtermvectors + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html + + The index in which the document resides. + Define ids, parameters or a list of parameters per document here. You must at least provide a list of document ids. See documentation. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/_mtermvectors + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html + + The index in which the document resides. + The type of the document. + Define ids, parameters or a list of parameters per document here. You must at least provide a list of document ids. See documentation. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/_mtermvectors + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html + + The index in which the document resides. + The type of the document. + Define ids, parameters or a list of parameters per document here. You must at least provide a list of document ids. See documentation. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/_mtermvectors + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html + + The index in which the document resides. + The type of the document. + Define ids, parameters or a list of parameters per document here. You must at least provide a list of document ids. See documentation. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/_mtermvectors + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html + + The index in which the document resides. + The type of the document. + Define ids, parameters or a list of parameters per document here. You must at least provide a list of document ids. See documentation. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cluster/nodes/hotthreads + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-hot-threads.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cluster/nodes/hotthreads + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-hot-threads.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cluster/nodes/hotthreads + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-hot-threads.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cluster/nodes/hotthreads + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-hot-threads.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cluster/nodes/{node_id}/hotthreads + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-hot-threads.html + + A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cluster/nodes/{node_id}/hotthreads + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-hot-threads.html + + A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_cluster/nodes/{node_id}/hotthreads + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-hot-threads.html + + A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_cluster/nodes/{node_id}/hotthreads + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-hot-threads.html + + A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_nodes + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-info.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_nodes + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-info.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_nodes + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-info.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_nodes + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-info.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_nodes/{node_id} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-info.html + + A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_nodes/{node_id} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-info.html + + A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_nodes/{node_id} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-info.html + + A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_nodes/{node_id} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-info.html + + A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_nodes/{metric} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-info.html + + A comma-separated list of metrics you wish returned. Leave empty to return all. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_nodes/{metric} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-info.html + + A comma-separated list of metrics you wish returned. Leave empty to return all. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_nodes/{metric} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-info.html + + A comma-separated list of metrics you wish returned. Leave empty to return all. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_nodes/{metric} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-info.html + + A comma-separated list of metrics you wish returned. Leave empty to return all. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_nodes/{node_id}/{metric} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-info.html + + A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes + A comma-separated list of metrics you wish returned. Leave empty to return all. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_nodes/{node_id}/{metric} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-info.html + + A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes + A comma-separated list of metrics you wish returned. Leave empty to return all. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_nodes/{node_id}/{metric} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-info.html + + A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes + A comma-separated list of metrics you wish returned. Leave empty to return all. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_nodes/{node_id}/{metric} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-info.html + + A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes + A comma-separated list of metrics you wish returned. Leave empty to return all. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_shutdown + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-shutdown.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_shutdown + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-shutdown.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_shutdown + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-shutdown.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_shutdown + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-shutdown.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_cluster/nodes/{node_id}/_shutdown + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-shutdown.html + + A comma-separated list of node IDs or names to perform the operation on; use `_local` to perform the operation on the node you're connected to, leave empty to perform the operation on all nodes + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_cluster/nodes/{node_id}/_shutdown + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-shutdown.html + + A comma-separated list of node IDs or names to perform the operation on; use `_local` to perform the operation on the node you're connected to, leave empty to perform the operation on all nodes + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_cluster/nodes/{node_id}/_shutdown + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-shutdown.html + + A comma-separated list of node IDs or names to perform the operation on; use `_local` to perform the operation on the node you're connected to, leave empty to perform the operation on all nodes + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_cluster/nodes/{node_id}/_shutdown + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-shutdown.html + + A comma-separated list of node IDs or names to perform the operation on; use `_local` to perform the operation on the node you're connected to, leave empty to perform the operation on all nodes + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_nodes/stats + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-stats.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_nodes/stats + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-stats.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_nodes/stats + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-stats.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_nodes/stats + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-stats.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_nodes/{node_id}/stats + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-stats.html + + A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_nodes/{node_id}/stats + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-stats.html + + A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_nodes/{node_id}/stats + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-stats.html + + A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_nodes/{node_id}/stats + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-stats.html + + A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_nodes/stats/{metric} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-stats.html + + Limit the information returned to the specified metrics + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_nodes/stats/{metric} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-stats.html + + Limit the information returned to the specified metrics + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_nodes/stats/{metric} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-stats.html + + Limit the information returned to the specified metrics + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_nodes/stats/{metric} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-stats.html + + Limit the information returned to the specified metrics + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_nodes/{node_id}/stats/{metric} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-stats.html + + A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes + Limit the information returned to the specified metrics + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_nodes/{node_id}/stats/{metric} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-stats.html + + A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes + Limit the information returned to the specified metrics + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_nodes/{node_id}/stats/{metric} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-stats.html + + A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes + Limit the information returned to the specified metrics + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_nodes/{node_id}/stats/{metric} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-stats.html + + A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes + Limit the information returned to the specified metrics + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_nodes/stats/{metric}/{index_metric} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-stats.html + + Limit the information returned to the specified metrics + Limit the information returned for `indices` metric to the specific index metrics. Isn't used if `indices` (or `all`) metric isn't specified. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_nodes/stats/{metric}/{index_metric} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-stats.html + + Limit the information returned to the specified metrics + Limit the information returned for `indices` metric to the specific index metrics. Isn't used if `indices` (or `all`) metric isn't specified. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_nodes/stats/{metric}/{index_metric} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-stats.html + + Limit the information returned to the specified metrics + Limit the information returned for `indices` metric to the specific index metrics. Isn't used if `indices` (or `all`) metric isn't specified. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_nodes/stats/{metric}/{index_metric} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-stats.html + + Limit the information returned to the specified metrics + Limit the information returned for `indices` metric to the specific index metrics. Isn't used if `indices` (or `all`) metric isn't specified. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_nodes/{node_id}/stats/{metric}/{index_metric} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-stats.html + + A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes + Limit the information returned to the specified metrics + Limit the information returned for `indices` metric to the specific index metrics. Isn't used if `indices` (or `all`) metric isn't specified. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_nodes/{node_id}/stats/{metric}/{index_metric} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-stats.html + + A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes + Limit the information returned to the specified metrics + Limit the information returned for `indices` metric to the specific index metrics. Isn't used if `indices` (or `all`) metric isn't specified. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_nodes/{node_id}/stats/{metric}/{index_metric} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-stats.html + + A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes + Limit the information returned to the specified metrics + Limit the information returned for `indices` metric to the specific index metrics. Isn't used if `indices` (or `all`) metric isn't specified. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_nodes/{node_id}/stats/{metric}/{index_metric} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-stats.html + + A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes + Limit the information returned to the specified metrics + Limit the information returned for `indices` metric to the specific index metrics. Isn't used if `indices` (or `all`) metric isn't specified. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/_percolate + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being percolated. + The type of the document being percolated. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/_percolate + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being percolated. + The type of the document being percolated. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/_percolate + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being percolated. + The type of the document being percolated. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/_percolate + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being percolated. + The type of the document being percolated. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/{id}/_percolate + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being percolated. + The type of the document being percolated. + Substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/{id}/_percolate + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being percolated. + The type of the document being percolated. + Substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/{id}/_percolate + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being percolated. + The type of the document being percolated. + Substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/{id}/_percolate + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being percolated. + The type of the document being percolated. + Substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/_percolate + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being percolated. + The type of the document being percolated. + The percolator request definition using the percolate DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/_percolate + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being percolated. + The type of the document being percolated. + The percolator request definition using the percolate DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/_percolate + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being percolated. + The type of the document being percolated. + The percolator request definition using the percolate DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/_percolate + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being percolated. + The type of the document being percolated. + The percolator request definition using the percolate DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/{id}/_percolate + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being percolated. + The type of the document being percolated. + Substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster. + The percolator request definition using the percolate DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/{id}/_percolate + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being percolated. + The type of the document being percolated. + Substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster. + The percolator request definition using the percolate DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/{id}/_percolate + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being percolated. + The type of the document being percolated. + Substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster. + The percolator request definition using the percolate DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/{id}/_percolate + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html + + The index of the document being percolated. + The type of the document being percolated. + Substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster. + The percolator request definition using the percolate DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a HEAD on / + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/ + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a HEAD on / + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/ + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a HEAD on / + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/ + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a HEAD on / + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/ + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /_scripts/{lang}/{id} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html + + Script language + Script ID + The document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /_scripts/{lang}/{id} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html + + Script language + Script ID + The document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /_scripts/{lang}/{id} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html + + Script language + Script ID + The document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /_scripts/{lang}/{id} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html + + Script language + Script ID + The document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_scripts/{lang}/{id} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html + + Script language + Script ID + The document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_scripts/{lang}/{id} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html + + Script language + Script ID + The document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_scripts/{lang}/{id} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html + + Script language + Script ID + The document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_scripts/{lang}/{id} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html + + Script language + Script ID + The document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /_search/template/{id} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html + + Template ID + The document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /_search/template/{id} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html + + Template ID + The document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /_search/template/{id} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html + + Template ID + The document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /_search/template/{id} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html + + Template ID + The document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_search/template/{id} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html + + Template ID + The document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_search/template/{id} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html + + Template ID + The document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_search/template/{id} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html + + Template ID + The document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_search/template/{id} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html + + Template ID + The document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_search/scroll + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_search/scroll + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_search/scroll + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_search/scroll + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_search/scroll/{scroll_id} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html + + The scroll ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_search/scroll/{scroll_id} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html + + The scroll ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_search/scroll/{scroll_id} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html + + The scroll ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_search/scroll/{scroll_id} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html + + The scroll ID + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_search/scroll + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html + + The scroll ID if not passed by URL or query parameter. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_search/scroll + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html + + The scroll ID if not passed by URL or query parameter. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_search/scroll + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html + + The scroll ID if not passed by URL or query parameter. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_search/scroll + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html + + The scroll ID if not passed by URL or query parameter. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_search/scroll/{scroll_id} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html + + The scroll ID + The scroll ID if not passed by URL or query parameter. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_search/scroll/{scroll_id} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html + + The scroll ID + The scroll ID if not passed by URL or query parameter. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_search/scroll/{scroll_id} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html + + The scroll ID + The scroll ID if not passed by URL or query parameter. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_search/scroll/{scroll_id} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html + + The scroll ID + The scroll ID if not passed by URL or query parameter. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_search + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_search + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_search + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_search + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_search + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_search + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_search + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_search + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/_search + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices + A comma-separated list of document types to search; leave empty to perform the operation on all types + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/_search + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices + A comma-separated list of document types to search; leave empty to perform the operation on all types + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/_search + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices + A comma-separated list of document types to search; leave empty to perform the operation on all types + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/_search + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices + A comma-separated list of document types to search; leave empty to perform the operation on all types + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_search + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + The search definition using the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_search + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + The search definition using the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_search + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + The search definition using the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_search + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + The search definition using the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_search + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices + The search definition using the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_search + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices + The search definition using the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_search + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices + The search definition using the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_search + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices + The search definition using the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/_search + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices + A comma-separated list of document types to search; leave empty to perform the operation on all types + The search definition using the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/_search + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices + A comma-separated list of document types to search; leave empty to perform the operation on all types + The search definition using the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/_search + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices + A comma-separated list of document types to search; leave empty to perform the operation on all types + The search definition using the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/_search + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices + A comma-separated list of document types to search; leave empty to perform the operation on all types + The search definition using the Query DSL + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_search_shards + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-shards.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_search_shards + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-shards.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_search_shards + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-shards.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_search_shards + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-shards.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_search_shards + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-shards.html + + The name of the index + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_search_shards + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-shards.html + + The name of the index + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_search_shards + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-shards.html + + The name of the index + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_search_shards + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-shards.html + + The name of the index + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/_search_shards + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-shards.html + + The name of the index + The type of the document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/_search_shards + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-shards.html + + The name of the index + The type of the document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/_search_shards + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-shards.html + + The name of the index + The type of the document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/_search_shards + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-shards.html + + The name of the index + The type of the document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_search_shards + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-shards.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_search_shards + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-shards.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_search_shards + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-shards.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_search_shards + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-shards.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_search_shards + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-shards.html + + The name of the index + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_search_shards + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-shards.html + + The name of the index + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_search_shards + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-shards.html + + The name of the index + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_search_shards + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-shards.html + + The name of the index + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/_search_shards + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-shards.html + + The name of the index + The type of the document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/_search_shards + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-shards.html + + The name of the index + The type of the document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/_search_shards + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-shards.html + + The name of the index + The type of the document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/_search_shards + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-shards.html + + The name of the index + The type of the document + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_search/template + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-template.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_search/template + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-template.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_search/template + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-template.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_search/template + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-template.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_search/template + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-template.html + + A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_search/template + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-template.html + + A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_search/template + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-template.html + + A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_search/template + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-template.html + + A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/_search/template + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-template.html + + A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices + A comma-separated list of document types to search; leave empty to perform the operation on all types + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/_search/template + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-template.html + + A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices + A comma-separated list of document types to search; leave empty to perform the operation on all types + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/_search/template + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-template.html + + A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices + A comma-separated list of document types to search; leave empty to perform the operation on all types + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/_search/template + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-template.html + + A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices + A comma-separated list of document types to search; leave empty to perform the operation on all types + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_search/template + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-template.html + + The search definition template and its params + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_search/template + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-template.html + + The search definition template and its params + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_search/template + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-template.html + + The search definition template and its params + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_search/template + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-template.html + + The search definition template and its params + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_search/template + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-template.html + + A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices + The search definition template and its params + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_search/template + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-template.html + + A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices + The search definition template and its params + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_search/template + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-template.html + + A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices + The search definition template and its params + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_search/template + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-template.html + + A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices + The search definition template and its params + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/_search/template + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-template.html + + A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices + A comma-separated list of document types to search; leave empty to perform the operation on all types + The search definition template and its params + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/_search/template + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-template.html + + A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices + A comma-separated list of document types to search; leave empty to perform the operation on all types + The search definition template and its params + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/_search/template + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-template.html + + A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices + A comma-separated list of document types to search; leave empty to perform the operation on all types + The search definition template and its params + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/_search/template + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-template.html + + A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices + A comma-separated list of document types to search; leave empty to perform the operation on all types + The search definition template and its params + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /_snapshot/{repository}/{snapshot} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A repository name + A snapshot name + The snapshot definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /_snapshot/{repository}/{snapshot} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A repository name + A snapshot name + The snapshot definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /_snapshot/{repository}/{snapshot} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A repository name + A snapshot name + The snapshot definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /_snapshot/{repository}/{snapshot} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A repository name + A snapshot name + The snapshot definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_snapshot/{repository}/{snapshot} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A repository name + A snapshot name + The snapshot definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_snapshot/{repository}/{snapshot} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A repository name + A snapshot name + The snapshot definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_snapshot/{repository}/{snapshot} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A repository name + A snapshot name + The snapshot definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_snapshot/{repository}/{snapshot} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A repository name + A snapshot name + The snapshot definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /_snapshot/{repository} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A repository name + The repository definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /_snapshot/{repository} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A repository name + The repository definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a PUT on /_snapshot/{repository} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A repository name + The repository definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a PUT on /_snapshot/{repository} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A repository name + The repository definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_snapshot/{repository} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A repository name + The repository definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_snapshot/{repository} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A repository name + The repository definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_snapshot/{repository} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A repository name + The repository definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_snapshot/{repository} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A repository name + The repository definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a DELETE on /_snapshot/{repository}/{snapshot} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A repository name + A snapshot name + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a DELETE on /_snapshot/{repository}/{snapshot} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A repository name + A snapshot name + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a DELETE on /_snapshot/{repository}/{snapshot} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A repository name + A snapshot name + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a DELETE on /_snapshot/{repository}/{snapshot} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A repository name + A snapshot name + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a DELETE on /_snapshot/{repository} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A comma-separated list of repository names + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a DELETE on /_snapshot/{repository} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A comma-separated list of repository names + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a DELETE on /_snapshot/{repository} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A comma-separated list of repository names + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a DELETE on /_snapshot/{repository} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A comma-separated list of repository names + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_snapshot/{repository}/{snapshot} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A repository name + A comma-separated list of snapshot names + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_snapshot/{repository}/{snapshot} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A repository name + A comma-separated list of snapshot names + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_snapshot/{repository}/{snapshot} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A repository name + A comma-separated list of snapshot names + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_snapshot/{repository}/{snapshot} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A repository name + A comma-separated list of snapshot names + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_snapshot + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_snapshot + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_snapshot + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_snapshot + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_snapshot/{repository} + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A comma-separated list of repository names + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_snapshot/{repository} + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A comma-separated list of repository names + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_snapshot/{repository} + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A comma-separated list of repository names + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_snapshot/{repository} + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A comma-separated list of repository names + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_snapshot/{repository}/{snapshot}/_restore + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A repository name + A snapshot name + Details of what to restore + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_snapshot/{repository}/{snapshot}/_restore + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A repository name + A snapshot name + Details of what to restore + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_snapshot/{repository}/{snapshot}/_restore + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A repository name + A snapshot name + Details of what to restore + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_snapshot/{repository}/{snapshot}/_restore + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html + + A repository name + A snapshot name + Details of what to restore + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_snapshot/_status + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-snapshots.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_snapshot/_status + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-snapshots.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_snapshot/_status + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-snapshots.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_snapshot/_status + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-snapshots.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_snapshot/{repository}/_status + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-snapshots.html + + A repository name + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_snapshot/{repository}/_status + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-snapshots.html + + A repository name + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_snapshot/{repository}/_status + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-snapshots.html + + A repository name + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_snapshot/{repository}/_status + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-snapshots.html + + A repository name + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_snapshot/{repository}/{snapshot}/_status + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-snapshots.html + + A repository name + A comma-separated list of snapshot names + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_snapshot/{repository}/{snapshot}/_status + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-snapshots.html + + A repository name + A comma-separated list of snapshot names + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_snapshot/{repository}/{snapshot}/_status + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-snapshots.html + + A repository name + A comma-separated list of snapshot names + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_snapshot/{repository}/{snapshot}/_status + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-snapshots.html + + A repository name + A comma-separated list of snapshot names + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_suggest + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + The request definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_suggest + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + The request definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /_suggest + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + The request definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /_suggest + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + The request definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_suggest + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices + The request definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_suggest + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices + The request definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/_suggest + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices + The request definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/_suggest + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices + The request definition + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_suggest + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_suggest + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /_suggest + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /_suggest + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_suggest + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_suggest + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/_suggest + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/_suggest + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html + + A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/{id}/_termvector + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-termvectors.html + + The index in which the document resides. + The type of the document. + The id of the document. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/{id}/_termvector + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-termvectors.html + + The index in which the document resides. + The type of the document. + The id of the document. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a GET on /{index}/{type}/{id}/_termvector + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-termvectors.html + + The index in which the document resides. + The type of the document. + The id of the document. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a GET on /{index}/{type}/{id}/_termvector + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-termvectors.html + + The index in which the document resides. + The type of the document. + The id of the document. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/{id}/_termvector + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-termvectors.html + + The index in which the document resides. + The type of the document. + The id of the document. + Define parameters. See documentation. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/{id}/_termvector + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-termvectors.html + + The index in which the document resides. + The type of the document. + The id of the document. + Define parameters. See documentation. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/{id}/_termvector + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-termvectors.html + + The index in which the document resides. + The type of the document. + The id of the document. + Define parameters. See documentation. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/{id}/_termvector + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-termvectors.html + + The index in which the document resides. + The type of the document. + The id of the document. + Define parameters. See documentation. + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/{id}/_update + Returns: ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-update.html + + The name of the index + The type of the document + Document ID + The request definition using either `script` or partial `doc` + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/{id}/_update + Returns: A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-update.html + + The name of the index + The type of the document + Document ID + The request definition using either `script` or partial `doc` + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + A task that'll return an ElasticsearchResponse<T> holding the reponse body deserialized as T. + - If T is of type byte[] deserialization will be shortcircuited + - If T is of type VoidResponse the response stream will be ignored completely + + + + Represents a POST on /{index}/{type}/{id}/_update + Returns: ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-update.html + + The name of the index + The type of the document + Document ID + The request definition using either `script` or partial `doc` + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + ElasticsearchResponse<T> holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + Represents a POST on /{index}/{type}/{id}/_update + Returns: Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-update.html + + The name of the index + The type of the document + Document ID + The request definition using either `script` or partial `doc` + + Optional function to specify any additional request parameters + Querystring values, connection configuration specific to this request, deserialization state. + + Task that'll return an ElasticsearchResponse<T$gt; holding the response body deserialized as DynamicDictionary + - Dynamic dictionary is a special dynamic type that allows json to be traversed safely + - i.e result.Response.hits.hits[0].property.nested["nested_deeper"] + - can be safely dispatched to a nullable type even if intermediate properties do not exist + + + + + Instantiate a new low level elasticsearch client + + Specify how and where the client connects to elasticsearch, defaults to a static single node connectionpool + to http://localhost:9200 + + Provide an alternative connection handler + Provide a custom transport implementation that coordinates between IConnectionPool, IConnection and ISerializer + Provide a custom serializer + + + + Perform any request you want over the configured IConnection synchronously while taking advantage of the cluster failover. + + The type representing the response JSON + the HTTP Method to use + The path of the the url that you would like to hit + The body of the request, string and byte[] are posted as is other types will be serialized to JSON + Optionally configure request specific timeouts, headers + An ElasticsearchResponse of T where T represents the JSON response body + + + + Perform any request you want over the configured IConnection asynchronously while taking advantage of the cluster failover. + + The type representing the response JSON + the HTTP Method to use + The path of the the url that you would like to hit + The body of the request, string and byte[] are posted as is other types will be serialized to JSON + Optionally configure request specific timeouts, headers + A task of ElasticsearchResponse of T where T represents the JSON response body + + + + A dictionary that supports dynamic access. + + + + + Creates a dynamic dictionary from an instance. + + An instance, that the dynamic dictionary should be created from. + An instance. + + + + Provides the implementation for operations that set member values. Classes derived from the class can override this method to specify dynamic behavior for operations such as setting a value for a property. + + true if the operation is successful; otherwise, false. If this method returns false, the run-time binder of the language determines the behavior. (In most cases, a language-specific run-time exception is thrown.) + Provides information about the object that called the dynamic operation. The binder.Name property provides the name of the member to which the value is being assigned. For example, for the statement sampleObject.SampleProperty = "Test", where sampleObject is an instance of the class derived from the class, binder.Name returns "SampleProperty". The binder.IgnoreCase property specifies whether the member name is case-sensitive.The value to set to the member. For example, for sampleObject.SampleProperty = "Test", where sampleObject is an instance of the class derived from the class, the is "Test". + + + + Provides the implementation for operations that get member values. Classes derived from the class can override this method to specify dynamic behavior for operations such as getting a value for a property. + + true if the operation is successful; otherwise, false. If this method returns false, the run-time binder of the language determines the behavior. (In most cases, a run-time exception is thrown.) + Provides information about the object that called the dynamic operation. The binder.Name property provides the name of the member on which the dynamic operation is performed. For example, for the Console.WriteLine(sampleObject.SampleProperty) statement, where sampleObject is an instance of the class derived from the class, binder.Name returns "SampleProperty". The binder.IgnoreCase property specifies whether the member name is case-sensitive.The result of the get operation. For example, if the method is called for a property, you can assign the property value to . + + + + Returns the enumeration of all dynamic member names. + + A that contains dynamic member names. + + + + Returns the enumeration of all dynamic member names. + + A that contains dynamic member names. + + + + Returns the enumeration of all dynamic member names. + + A that contains dynamic member names. + + + + Indicates whether the current is equal to another object of the same type. + + if the current instance is equal to the parameter; otherwise, . + An instance to compare with this instance. + + + + Determines whether the specified is equal to this instance. + + The to compare with this instance. + if the specified is equal to this instance; otherwise, . + + + + Returns an enumerator that iterates through the collection. + + A that can be used to iterate through the collection. + + + + Returns a hash code for this . + + A hash code for this , suitable for use in hashing algorithms and data structures like a hash table. + + + + Adds an element with the provided key and value to the . + + The object to use as the key of the element to add. + The object to use as the value of the element to add. + + + + Adds an item to the . + + The object to add to the . + + + + Determines whether the contains an element with the specified key. + + if the contains an element with the key; otherwise, . + + The key to locate in the . + + + + Gets the value associated with the specified key. + + if the contains an element with the specified key; otherwise, . + The key whose value to get. + When this method returns, the value associated with the specified key, if the key is found; otherwise, the default value for the type of the parameter. This parameter is passed uninitialized. + + + + Removes all items from the . + + + + + Determines whether the contains a specific value. + + if is found in the ; otherwise, . + + The object to locate in the . + + + + Copies the elements of the to an , starting at a particular index. + + The one-dimensional that is the destination of the elements copied from the . The must have zero-based indexing. + The zero-based index in at which copying begins. + + + + Removes the element with the specified key from the . + + if the element is successfully removed; otherwise, . + The key of the element to remove. + + + + Removes the first occurrence of a specific object from the . + + if was successfully removed from the ; otherwise, . + The object to remove from the . + + + + Returns an empty dynamic dictionary. + + A instance. + + + + Gets or sets the with the specified name. + + A instance containing a value. + + + + Gets an containing the keys of the . + + An containing the keys of the . + + + + Gets the number of elements contained in the . + + The number of elements contained in the . + + + + Gets a value indicating whether the is read-only. + + Always returns . + + + + Gets an containing the values in the . + + An containing the values in the . + + + + Initializes a new instance of the class. + + The value to store in the instance + + + + Returns a default value if Value is null + + When no default value is supplied, required to supply the default type + Optional parameter for default value, if not given it returns default of type T + If value is not null, value is returned, else default value is returned + + + + Attempts to convert the value to type of T, failing to do so will return the defaultValue. + + When no default value is supplied, required to supply the default type + Optional parameter for default value, if not given it returns default of type T + If value is not null, value is returned, else default value is returned + + + + Indicates whether the current object is equal to another object of the same type. + + true if the current object is equal to the parameter; otherwise, false. + + An to compare with this instance. + + + + Determines whether the specified is equal to the current . + + true if the specified is equal to the current ; otherwise, false. + The to compare with the current . + + + + Serves as a hash function for a particular type. + + A hash code for the current instance. + + + + Provides implementation for binary operations. Classes derived from the class can override this method to specify dynamic behavior for operations such as addition and multiplication. + + true if the operation is successful; otherwise, false. If this method returns false, the run-time binder of the language determines the behavior. (In most cases, a language-specific run-time exception is thrown.) + Provides information about the binary operation. The binder.Operation property returns an object. For example, for the sum = first + second statement, where first and second are derived from the DynamicObject class, binder.Operation returns ExpressionType.Add.The right operand for the binary operation. For example, for the sum = first + second statement, where first and second are derived from the DynamicObject class, is equal to second.The result of the binary operation. + + + + Provides implementation for type conversion operations. Classes derived from the class can override this method to specify dynamic behavior for operations that convert an object from one type to another. + + true if the operation is successful; otherwise, false. If this method returns false, the run-time binder of the language determines the behavior. (In most cases, a language-specific run-time exception is thrown.) + Provides information about the conversion operation. The binder.Type property provides the type to which the object must be converted. For example, for the statement (String)sampleObject in C# (CType(sampleObject, Type) in Visual Basic), where sampleObject is an instance of the class derived from the class, binder.Type returns the type. The binder.Explicit property provides information about the kind of conversion that occurs. It returns true for explicit conversion and false for implicit conversion.The result of the type conversion operation. + + + + Returns the for this instance. + + + The enumerated constant that is the of the class or value type that implements this interface. + + 2 + + + + Converts the value of this instance to an equivalent Boolean value using the specified culture-specific formatting information. + + + A Boolean value equivalent to the value of this instance. + + An interface implementation that supplies culture-specific formatting information. 2 + + + + Converts the value of this instance to an equivalent Unicode character using the specified culture-specific formatting information. + + + A Unicode character equivalent to the value of this instance. + + An interface implementation that supplies culture-specific formatting information. 2 + + + + Converts the value of this instance to an equivalent 8-bit signed integer using the specified culture-specific formatting information. + + + An 8-bit signed integer equivalent to the value of this instance. + + An interface implementation that supplies culture-specific formatting information. 2 + + + + Converts the value of this instance to an equivalent 8-bit unsigned integer using the specified culture-specific formatting information. + + + An 8-bit unsigned integer equivalent to the value of this instance. + + An interface implementation that supplies culture-specific formatting information. 2 + + + + Converts the value of this instance to an equivalent 16-bit signed integer using the specified culture-specific formatting information. + + + An 16-bit signed integer equivalent to the value of this instance. + + An interface implementation that supplies culture-specific formatting information. 2 + + + + Converts the value of this instance to an equivalent 16-bit unsigned integer using the specified culture-specific formatting information. + + + An 16-bit unsigned integer equivalent to the value of this instance. + + An interface implementation that supplies culture-specific formatting information. 2 + + + + Converts the value of this instance to an equivalent 32-bit signed integer using the specified culture-specific formatting information. + + + An 32-bit signed integer equivalent to the value of this instance. + + An interface implementation that supplies culture-specific formatting information. 2 + + + + Converts the value of this instance to an equivalent 32-bit unsigned integer using the specified culture-specific formatting information. + + + An 32-bit unsigned integer equivalent to the value of this instance. + + An interface implementation that supplies culture-specific formatting information. 2 + + + + Converts the value of this instance to an equivalent 64-bit signed integer using the specified culture-specific formatting information. + + + An 64-bit signed integer equivalent to the value of this instance. + + An interface implementation that supplies culture-specific formatting information. 2 + + + + Converts the value of this instance to an equivalent 64-bit unsigned integer using the specified culture-specific formatting information. + + + An 64-bit unsigned integer equivalent to the value of this instance. + + An interface implementation that supplies culture-specific formatting information. 2 + + + + Converts the value of this instance to an equivalent single-precision floating-point number using the specified culture-specific formatting information. + + + A single-precision floating-point number equivalent to the value of this instance. + + An interface implementation that supplies culture-specific formatting information. 2 + + + + Converts the value of this instance to an equivalent double-precision floating-point number using the specified culture-specific formatting information. + + + A double-precision floating-point number equivalent to the value of this instance. + + An interface implementation that supplies culture-specific formatting information. 2 + + + + Converts the value of this instance to an equivalent number using the specified culture-specific formatting information. + + + A number equivalent to the value of this instance. + + An interface implementation that supplies culture-specific formatting information. 2 + + + + Converts the value of this instance to an equivalent using the specified culture-specific formatting information. + + + A instance equivalent to the value of this instance. + + An interface implementation that supplies culture-specific formatting information. 2 + + + + Converts the value of this instance to an equivalent using the specified culture-specific formatting information. + + + A instance equivalent to the value of this instance. + + An interface implementation that supplies culture-specific formatting information. 2 + + + + Converts the value of this instance to an of the specified that has an equivalent value, using the specified culture-specific formatting information. + + + An instance of type whose value is equivalent to the value of this instance. + + The to which the value of this instance is converted. An interface implementation that supplies culture-specific formatting information. 2 + + + + Gets a value indicating whether this instance has value. + + true if this instance has value; otherwise, false. + is considered as not being a value. + + + + Gets the inner value + + + + + Thrown when a request has depleeded its max retry setting + + + + + Thrown when a sniff operation itself caused a maxrety exception + + + + + Thrown when a ping operation itself caused a maxrety exception + + + + Request parameters descriptor for AbortBenchmark + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-benchmark.html
+
+ + + + Request parameters descriptor for Bulk + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-bulk.html
+
+ + + + Explicit write consistency setting for the operation + + + Refresh the index after performing the operation + + + Explicitely set the replication type + + + Specific routing value + + + Explicit operation timeout + + + Default document type for items which don't provide one + + + Request parameters descriptor for CatAliases + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-aliases.html
+
+ + + + Return local information, do not retrieve the state from master node (default: false) + + + Explicit operation timeout for connection to master node + + + Comma-separated list of column names to display + + + Return help information + + + Verbose mode. Display column headers + + + Request parameters descriptor for CatAllocation + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-allocation.html
+
+ + + + The unit in which to display byte values + + + Return local information, do not retrieve the state from master node (default: false) + + + Explicit operation timeout for connection to master node + + + Comma-separated list of column names to display + + + Return help information + + + Verbose mode. Display column headers + + + Request parameters descriptor for CatCount + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-count.html
+
+ + + + Return local information, do not retrieve the state from master node (default: false) + + + Explicit operation timeout for connection to master node + + + Comma-separated list of column names to display + + + Return help information + + + Verbose mode. Display column headers + + + Request parameters descriptor for CatFielddata + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/cat-fielddata.html
+
+ + + + The unit in which to display byte values + + + Return local information, do not retrieve the state from master node (default: false) + + + Explicit operation timeout for connection to master node + + + Comma-separated list of column names to display + + + Return help information + + + Verbose mode. Display column headers + + + A comma-separated list of fields to return the fielddata size + + + Request parameters descriptor for CatHealth + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-health.html
+
+ + + + Return local information, do not retrieve the state from master node (default: false) + + + Explicit operation timeout for connection to master node + + + Comma-separated list of column names to display + + + Return help information + + + Set to false to disable timestamping + + + Verbose mode. Display column headers + + + Request parameters descriptor for CatHelp + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat.html
+
+ + + + Return help information + + + Request parameters descriptor for CatIndices + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-indices.html
+
+ + + + The unit in which to display byte values + + + Return local information, do not retrieve the state from master node (default: false) + + + Explicit operation timeout for connection to master node + + + Comma-separated list of column names to display + + + Return help information + + + Set to true to return stats only for primary shards + + + Verbose mode. Display column headers + + + Request parameters descriptor for CatMaster + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-master.html
+
+ + + + Return local information, do not retrieve the state from master node (default: false) + + + Explicit operation timeout for connection to master node + + + Comma-separated list of column names to display + + + Return help information + + + Verbose mode. Display column headers + + + Request parameters descriptor for CatNodes + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-nodes.html
+
+ + + + Return local information, do not retrieve the state from master node (default: false) + + + Explicit operation timeout for connection to master node + + + Comma-separated list of column names to display + + + Return help information + + + Verbose mode. Display column headers + + + Request parameters descriptor for CatPendingTasks + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-pending-tasks.html
+
+ + + + Return local information, do not retrieve the state from master node (default: false) + + + Explicit operation timeout for connection to master node + + + Comma-separated list of column names to display + + + Return help information + + + Verbose mode. Display column headers + + + Request parameters descriptor for CatPlugins + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/cat-plugins.html
+
+ + + + Return local information, do not retrieve the state from master node (default: false) + + + Explicit operation timeout for connection to master node + + + Comma-separated list of column names to display + + + Return help information + + + Verbose mode. Display column headers + + + Request parameters descriptor for CatRecovery + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-recovery.html
+
+ + + + The unit in which to display byte values + + + Explicit operation timeout for connection to master node + + + Comma-separated list of column names to display + + + Return help information + + + Verbose mode. Display column headers + + + Request parameters descriptor for CatShards + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-shards.html
+
+ + + + Return local information, do not retrieve the state from master node (default: false) + + + Explicit operation timeout for connection to master node + + + Comma-separated list of column names to display + + + Return help information + + + Verbose mode. Display column headers + + + Request parameters descriptor for CatThreadPool + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/cat-thread-pool.html
+
+ + + + Return local information, do not retrieve the state from master node (default: false) + + + Explicit operation timeout for connection to master node + + + Comma-separated list of column names to display + + + Return help information + + + Verbose mode. Display column headers + + + Enables displaying the complete node ids + + + Request parameters descriptor for ClearScroll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html
+
+ + + + Request parameters descriptor for ClusterGetSettings + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-update-settings.html
+
+ + + + Return settings in flat format (default: false) + + + Explicit operation timeout for connection to master node + + + Explicit operation timeout + + + Request parameters descriptor for ClusterHealth + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-health.html
+
+ + + + Specify the level of detail for returned information + + + Return local information, do not retrieve the state from master node (default: false) + + + Explicit operation timeout for connection to master node + + + Explicit operation timeout + + + Wait until the specified number of shards is active + + + Wait until the specified number of nodes is available + + + Wait until the specified number of relocating shards is finished + + + Wait until cluster is in a specific state + + + Request parameters descriptor for ClusterPendingTasks + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-pending.html
+
+ + + + Return local information, do not retrieve the state from master node (default: false) + + + Specify timeout for connection to master + + + Request parameters descriptor for ClusterPutSettings + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-update-settings.html
+
+ + + + Return settings in flat format (default: false) + + + Request parameters descriptor for ClusterReroute + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-reroute.html
+
+ + + + Simulate the operation only and return the resulting state + + + Return an explanation of why the commands can or cannot be executed + + + Don't return cluster state metadata (default: false) + + + Explicit operation timeout for connection to master node + + + Explicit operation timeout + + + Request parameters descriptor for ClusterState + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-state.html
+
+ + + + Return local information, do not retrieve the state from master node (default: false) + + + Specify timeout for connection to master + + + Return settings in flat format (default: false) + + + Request parameters descriptor for ClusterStats + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-stats.html
+
+ + + + Return settings in flat format (default: false) + + + Whether to return time and byte values in human-readable format. + + + Request parameters descriptor for Count + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html
+
+ + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Include only documents with a specific `_score` value in the result + + + Specify the node or shard the operation should be performed on (default: random) + + + Specific routing value + + + The URL-encoded query definition (instead of using the request body) + + + Request parameters descriptor for CountPercolateGet + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html
+
+ + + + A comma-separated list of specific routing values + + + Specify the node or shard the operation should be performed on (default: random) + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + The index to count percolate the document into. Defaults to index. + + + The type to count percolate document into. Defaults to type. + + + Explicit version number for concurrency control + + + Specific version type + + + Request parameters descriptor for Delete + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-delete.html
+
+ + + + Specific write consistency setting for the operation + + + ID of parent document + + + Refresh the index after performing the operation + + + Specific replication type + + + Specific routing value + + + Explicit operation timeout + + + Explicit version number for concurrency control + + + Specific version type + + + Request parameters descriptor for DeleteByQuery + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-delete-by-query.html
+
+ + + + The analyzer to use for the query string + + + Specific write consistency setting for the operation + + + The default operator for query string query (AND or OR) + + + The field to use as default where no field prefix is given in the query string + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Specific replication type + + + Query in the Lucene query string syntax + + + Specific routing value + + + The URL-encoded query definition (instead of using the request body) + + + Explicit operation timeout + + + Request parameters descriptor for DeleteScript + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html
+
+ + + + Request parameters descriptor for DeleteTemplate + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html
+
+ + + + Request parameters descriptor for Exists + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-get.html
+
+ + + + The ID of the parent document + + + Specify the node or shard the operation should be performed on (default: random) + + + Specify whether to perform the operation in realtime or search mode + + + Refresh the shard containing the document before performing the operation + + + Specific routing value + + + Request parameters descriptor for ExplainGet + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-explain.html
+
+ + + + Specify whether wildcards and prefix queries in the query string query should be analyzed (default: false) + + + The analyzer for the query string query + + + The default operator for query string query (AND or OR) + + + The default field for query string query (default: _all) + + + A comma-separated list of fields to return in the response + + + Specify whether format-based query failures (such as providing text to a numeric field) should be ignored + + + Specify whether query terms should be lowercased + + + The ID of the parent document + + + Specify the node or shard the operation should be performed on (default: random) + + + Query in the Lucene query string syntax + + + Specific routing value + + + The URL-encoded query definition (instead of using the request body) + + + True or false to return the _source field or not, or a list of fields to return + + + True or false to return the _source field or not, or a list of fields to return + + + A list of fields to exclude from the returned _source field + + + A list of fields to extract and return from the _source field + + + Request parameters descriptor for Get + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-get.html
+
+ + + + A comma-separated list of fields to return in the response + + + The ID of the parent document + + + Specify the node or shard the operation should be performed on (default: random) + + + Specify whether to perform the operation in realtime or search mode + + + Refresh the shard containing the document before performing the operation + + + Specific routing value + + + True or false to return the _source field or not, or a list of fields to return + + + True or false to return the _source field or not, or a list of fields to return + + + A list of fields to exclude from the returned _source field + + + A list of fields to extract and return from the _source field + + + Explicit version number for concurrency control + + + Specific version type + + + Request parameters descriptor for GetScript + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html
+
+ + + + Request parameters descriptor for GetSource + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-get.html
+
+ + + + The ID of the parent document + + + Specify the node or shard the operation should be performed on (default: random) + + + Specify whether to perform the operation in realtime or search mode + + + Refresh the shard containing the document before performing the operation + + + Specific routing value + + + True or false to return the _source field or not, or a list of fields to return + + + True or false to return the _source field or not, or a list of fields to return + + + A list of fields to exclude from the returned _source field + + + A list of fields to extract and return from the _source field + + + Explicit version number for concurrency control + + + Specific version type + + + Request parameters descriptor for GetTemplate + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html
+
+ + + + Request parameters descriptor for Index + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-index_.html
+
+ + + + Explicit write consistency setting for the operation + + + Explicit operation type + + + ID of the parent document + + + Refresh the index after performing the operation + + + Specific replication type + + + Specific routing value + + + Explicit operation timeout + + + Explicit timestamp for the document + + + Expiration time for the document + + + Explicit version number for concurrency control + + + Specific version type + + + Request parameters descriptor for IndicesAnalyzeGetForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-analyze.html
+
+ + + + The name of the analyzer to use + + + A comma-separated list of character filters to use for the analysis + + + Use the analyzer configured for this field (instead of passing the analyzer name) + + + A comma-separated list of filters to use for the analysis + + + The name of the index to scope the operation + + + With `true`, specify that a local shard should be used if available, with `false`, use a random shard (default: true) + + + The text on which the analysis should be performed (when request body is not used) + + + The name of the tokenizer to use for the analysis + + + Format of the output + + + Request parameters descriptor for IndicesClearCacheForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-clearcache.html
+
+ + + + Clear field data + + + A comma-separated list of fields to clear when using the `field_data` parameter (default: all) + + + Clear filter caches + + + Clear filter caches + + + A comma-separated list of keys to clear when using the `filter_cache` parameter (default: all) + + + Clear ID caches for parent/child + + + Clear ID caches for parent/child + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + A comma-separated list of index name to limit the operation + + + Clear the recycler cache + + + Request parameters descriptor for IndicesClose + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-open-close.html
+
+ + + + Explicit operation timeout + + + Specify timeout for connection to master + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Request parameters descriptor for IndicesCreate + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-create-index.html
+
+ + + + Explicit operation timeout + + + Specify timeout for connection to master + + + Request parameters descriptor for IndicesDelete + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-delete-index.html
+
+ + + + Explicit operation timeout + + + Specify timeout for connection to master + + + Request parameters descriptor for IndicesDeleteMapping + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-delete-mapping.html
+
+ + + + Specify timeout for connection to master + + + Request parameters descriptor for IndicesDeleteWarmer + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html
+
+ + + + Specify timeout for connection to master + + + Request parameters descriptor for IndicesExists + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-settings.html
+
+ + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Return local information, do not retrieve the state from master node (default: false) + + + Request parameters descriptor for IndicesFlushForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-flush.html
+
+ + + + 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) + + + 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) + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Request parameters descriptor for IndicesGetAliasForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html
+
+ + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Return local information, do not retrieve the state from master node (default: false) + + + Request parameters descriptor for IndicesGetAliasesForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html
+
+ + + + Explicit operation timeout + + + Return local information, do not retrieve the state from master node (default: false) + + + Request parameters descriptor for IndicesGetMappingForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html
+
+ + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Return local information, do not retrieve the state from master node (default: false) + + + Request parameters descriptor for IndicesGetSettingsForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html
+
+ + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Return settings in flat format (default: false) + + + Return local information, do not retrieve the state from master node (default: false) + + + Request parameters descriptor for IndicesGetWarmerForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html
+
+ + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Return local information, do not retrieve the state from master node (default: false) + + + Request parameters descriptor for IndicesOpen + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-open-close.html
+
+ + + + Explicit operation timeout + + + Specify timeout for connection to master + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Request parameters descriptor for IndicesOptimizeForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-optimize.html
+
+ + + + Specify whether the index should be flushed after performing the operation (default: true) + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + The number of segments the index should be merged into (default: dynamic) + + + Specify whether the operation should only expunge deleted documents + + + TODO: ? + + + Specify whether the request should block until the merge process is finished (default: true) + + + Force a merge operation to run, even if there is a single segment in the index (default: false) + + + Request parameters descriptor for IndicesPutMapping + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-put-mapping.html
+
+ + + + Specify whether to ignore conflicts while updating the mapping (default: false) + + + Explicit operation timeout + + + Specify timeout for connection to master + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Request parameters descriptor for IndicesPutSettingsForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-update-settings.html
+
+ + + + Specify timeout for connection to master + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Return settings in flat format (default: false) + + + Request parameters descriptor for IndicesPutTemplateForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html
+
+ + + + Whether the index template should only be added if new or can also replace an existing one + + + Explicit operation timeout + + + Specify timeout for connection to master + + + Return settings in flat format (default: false) + + + Request parameters descriptor for IndicesPutWarmerForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html
+
+ + + + Specify timeout for connection to master + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) in the search request to warm + + + 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) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both, in the search request to warm. + + + Request parameters descriptor for IndicesRefreshForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-refresh.html
+
+ + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Force a refresh even if not required + + + TODO: ? + + + Request parameters descriptor for IndicesSegmentsForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-segments.html
+
+ + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Whether to return time and byte values in human-readable format. + + + TODO: ? + + + Request parameters descriptor for IndicesStatsForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-stats.html
+
+ + + + A comma-separated list of fields for `fielddata` and `suggest` index metric (supports wildcards) + + + A comma-separated list of fields for `fielddata` index metric (supports wildcards) + + + A comma-separated list of fields for `fielddata` and `completion` index metric (supports wildcards) + + + A comma-separated list of search groups for `search` index metric + + + Whether to return time and byte values in human-readable format. + + + Return stats aggregated at cluster, index or shard level + + + Request parameters descriptor for IndicesStatusForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-status.html
+
+ + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Whether to return time and byte values in human-readable format. + + + TODO: ? + + + Return information about shard recovery + + + TODO: ? + + + Request parameters descriptor for IndicesUpdateAliasesForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html
+
+ + + + Request timeout + + + Specify timeout for connection to master + + + Request parameters descriptor for IndicesValidateQueryGetForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html
+
+ + + + Return detailed information about the error + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + TODO: ? + + + The URL-encoded query definition (instead of using the request body) + + + Query in the Lucene query string syntax + + + Request parameters descriptor for Info + 
+            http://www.elasticsearch.org/guide/
+
+ + + + Request parameters descriptor for ListBenchmarks + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-benchmark.html
+
+ + + + Request parameters descriptor for MgetGet + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-get.html
+
+ + + + A comma-separated list of fields to return in the response + + + Specify the node or shard the operation should be performed on (default: random) + + + Specify whether to perform the operation in realtime or search mode + + + Refresh the shard containing the document before performing the operation + + + True or false to return the _source field or not, or a list of fields to return + + + True or false to return the _source field or not, or a list of fields to return + + + A list of fields to exclude from the returned _source field + + + A list of fields to extract and return from the _source field + + + Request parameters descriptor for MltGet + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-more-like-this.html
+
+ + + + The boost factor + + + The word occurrence frequency as count: words with higher occurrence in the corpus will be ignored + + + The maximum query terms to be included in the generated query + + + The minimum length of the word: longer words will be ignored + + + The word occurrence frequency as count: words with lower occurrence in the corpus will be ignored + + + The term frequency as percent: terms with lower occurence in the source document will be ignored + + + The minimum length of the word: shorter words will be ignored + + + Specific fields to perform the query against + + + How many terms have to match in order to consider the document a match (default: 0.3) + + + Specific routing value + + + The offset from which to return results + + + A comma-separated list of indices to perform the query against (default: the index containing the document) + + + The search query hint + + + A scroll search request definition + + + The number of documents to return (default: 10) + + + A specific search request definition (instead of using the request body) + + + Specific search type (eg. `dfs_then_fetch`, `count`, etc) + + + A comma-separated list of types to perform the query against (default: the same type as the document) + + + A list of stop words to be ignored + + + Request parameters descriptor for MsearchGet + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-multi-search.html
+
+ + + + Search operation type + + + Request parameters descriptor for MtermvectorsGet + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html
+
+ + + + Specifies if total term frequency and document frequency should be returned. Applies to all returned documents unless otherwise specified in body "params" or "docs". + + + 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 "params" or "docs". + + + A comma-separated list of fields to return. Applies to all returned documents unless otherwise specified in body "params" or "docs". + + + Specifies if term offsets should be returned. Applies to all returned documents unless otherwise specified in body "params" or "docs". + + + Specifies if term positions should be returned. Applies to all returned documents unless otherwise specified in body "params" or "docs". + + + Specifies if term payloads should be returned. Applies to all returned documents unless otherwise specified in body "params" or "docs". + + + Specify the node or shard the operation should be performed on (default: random) .Applies to all returned documents unless otherwise specified in body "params" or "docs". + + + Specific routing value. Applies to all returned documents unless otherwise specified in body "params" or "docs". + + + Parent id of documents. Applies to all returned documents unless otherwise specified in body "params" or "docs". + + + Request parameters descriptor for NodesHotThreadsForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-hot-threads.html
+
+ + + + The interval for the second sampling of threads + + + Number of samples of thread stacktrace (default: 10) + + + Specify the number of threads to provide information for (default: 3) + + + The type to sample (default: cpu) + + + Request parameters descriptor for NodesInfoForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-info.html
+
+ + + + Return settings in flat format (default: false) + + + Whether to return time and byte values in human-readable format. + + + Request parameters descriptor for NodesShutdownForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-shutdown.html
+
+ + + + Set the delay for the operation (default: 1s) + + + Exit the JVM as well (default: true) + + + Request parameters descriptor for NodesStatsForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-stats.html
+
+ + + + A comma-separated list of fields for `fielddata` and `suggest` index metric (supports wildcards) + + + A comma-separated list of fields for `fielddata` index metric (supports wildcards) + + + A comma-separated list of fields for `fielddata` and `completion` index metric (supports wildcards) + + + A comma-separated list of search groups for `search` index metric + + + Whether to return time and byte values in human-readable format. + + + Return indices stats aggregated at node, index or shard level + + + A comma-separated list of document types for the `indexing` index metric + + + Request parameters descriptor for PercolateGet + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html
+
+ + + + A comma-separated list of specific routing values + + + Specify the node or shard the operation should be performed on (default: random) + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + The index to percolate the document into. Defaults to index. + + + The type to percolate document into. Defaults to type. + + + Explicit version number for concurrency control + + + Specific version type + + + Request parameters descriptor for Ping + 
+            http://www.elasticsearch.org/guide/
+
+ + + + Request parameters descriptor for PutScript + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html
+
+ + + + Request parameters descriptor for ScrollGet + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html
+
+ + + + Request parameters descriptor for SearchGet + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html
+
+ + + + The analyzer to use for the query string + + + Specify whether wildcard and prefix queries should be analyzed (default: false) + + + The default operator for query string query (AND or OR) + + + The field to use as default where no field prefix is given in the query string + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Specify whether format-based query failures (such as providing text to a numeric field) should be ignored + + + Specify whether query terms should be lowercased + + + Specify the node or shard the operation should be performed on (default: random) + + + A comma-separated list of specific routing values + + + Specify how long a consistent view of the index should be maintained for scrolled search + + + Search operation type + + + Specific 'tag' of the request for logging and statistical purposes + + + Specify which field to use for suggestions + + + Specify suggest mode + + + How many suggestions to return in response + + + The source text for which the suggestions should be returned + + + Request parameters descriptor for SearchShardsGet + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-shards.html
+
+ + + + Specify the node or shard the operation should be performed on (default: random) + + + Specific routing value + + + Return local information, do not retrieve the state from master node (default: false) + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Request parameters descriptor for SearchTemplateGet + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-template.html
+
+ + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Specify the node or shard the operation should be performed on (default: random) + + + A comma-separated list of specific routing values + + + Specify how long a consistent view of the index should be maintained for scrolled search + + + Search operation type + + + Request parameters descriptor for SnapshotCreate + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html
+
+ + + + Explicit operation timeout for connection to master node + + + Should this request wait until the operation has completed before returning + + + Request parameters descriptor for SnapshotCreateRepository + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html
+
+ + + + Explicit operation timeout for connection to master node + + + Explicit operation timeout + + + Request parameters descriptor for SnapshotDelete + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html
+
+ + + + Explicit operation timeout for connection to master node + + + Request parameters descriptor for SnapshotDeleteRepository + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html
+
+ + + + Explicit operation timeout for connection to master node + + + Explicit operation timeout + + + Request parameters descriptor for SnapshotGet + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html
+
+ + + + Explicit operation timeout for connection to master node + + + Request parameters descriptor for SnapshotGetRepository + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html
+
+ + + + Explicit operation timeout for connection to master node + + + Return local information, do not retrieve the state from master node (default: false) + + + Request parameters descriptor for SnapshotRestore + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html
+
+ + + + Explicit operation timeout for connection to master node + + + Should this request wait until the operation has completed before returning + + + Request parameters descriptor for SnapshotStatus + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-snapshots.html
+
+ + + + Explicit operation timeout for connection to master node + + + Request parameters descriptor for Suggest + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html
+
+ + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Specify the node or shard the operation should be performed on (default: random) + + + Specific routing value + + + The URL-encoded request definition (instead of using request body) + + + Request parameters descriptor for TermvectorGet + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-termvectors.html
+
+ + + + Specifies if total term frequency and document frequency should be returned. + + + Specifies if document count, sum of document frequencies and sum of total term frequencies should be returned. + + + A comma-separated list of fields to return. + + + Specifies if term offsets should be returned. + + + Specifies if term positions should be returned. + + + Specifies if term payloads should be returned. + + + Specify the node or shard the operation should be performed on (default: random). + + + Specific routing value. + + + Parent id of documents. + + + Request parameters descriptor for Update + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-update.html
+
+ + + + Explicit write consistency setting for the operation + + + The script language (default: mvel) + + + ID of the parent document + + + Refresh the index after performing the operation + + + Specific replication type + + + Specify how many times should the operation be retried when a conflict occurs (default: 0) + + + Specific routing value + + + The URL-encoded script definition (instead of using request body) + + + Explicit operation timeout + + + Explicit timestamp for the document + + + Expiration time for the document + + + Explicit version number for concurrency control + + + Specific version type + + + + Used to stringify valuetypes to string (i.e querystring parameters and route parameters). + + + + + Represents the json array. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class. + + The capacity of the json array. + + + + The json representation of the array. + + The json representation of the array. + + + + Represents the json object. + + + + + The internal member dictionary. + + + + + Initializes a new instance of . + + + + + Initializes a new instance of . + + The implementation to use when comparing keys, or null to use the default for the type of the key. + + + + Adds the specified key. + + The key. + The value. + + + + Determines whether the specified key contains key. + + The key. + + true if the specified key contains key; otherwise, false. + + + + + Removes the specified key. + + The key. + + + + + Tries the get value. + + The key. + The value. + + + + + Adds the specified item. + + The item. + + + + Clears this instance. + + + + + Determines whether [contains] [the specified item]. + + The item. + + true if [contains] [the specified item]; otherwise, false. + + + + + Copies to. + + The array. + Index of the array. + + + + Removes the specified item. + + The item. + + + + + Gets the enumerator. + + + + + + Returns an enumerator that iterates through a collection. + + + An object that can be used to iterate through the collection. + + + + + Returns a json that represents the current . + + + A json that represents the current . + + + + + Provides implementation for type conversion operations. Classes derived from the class can override this method to specify dynamic behavior for operations that convert an object from one type to another. + + Provides information about the conversion operation. The binder.Type property provides the type to which the object must be converted. For example, for the statement (String)sampleObject in C# (CType(sampleObject, Type) in Visual Basic), where sampleObject is an instance of the class derived from the class, binder.Type returns the type. The binder.Explicit property provides information about the kind of conversion that occurs. It returns true for explicit conversion and false for implicit conversion. + The result of the type conversion operation. + + Alwasy returns true. + + + + + Provides the implementation for operations that delete an object member. This method is not intended for use in C# or Visual Basic. + + Provides information about the deletion. + + Alwasy returns true. + + + + + Provides the implementation for operations that get a value by index. Classes derived from the class can override this method to specify dynamic behavior for indexing operations. + + Provides information about the operation. + The indexes that are used in the operation. For example, for the sampleObject[3] operation in C# (sampleObject(3) in Visual Basic), where sampleObject is derived from the DynamicObject class, is equal to 3. + The result of the index operation. + + Alwasy returns true. + + + + + Provides the implementation for operations that get member values. Classes derived from the class can override this method to specify dynamic behavior for operations such as getting a value for a property. + + Provides information about the object that called the dynamic operation. The binder.Name property provides the name of the member on which the dynamic operation is performed. For example, for the Console.WriteLine(sampleObject.SampleProperty) statement, where sampleObject is an instance of the class derived from the class, binder.Name returns "SampleProperty". The binder.IgnoreCase property specifies whether the member name is case-sensitive. + The result of the get operation. For example, if the method is called for a property, you can assign the property value to . + + Alwasy returns true. + + + + + Provides the implementation for operations that set a value by index. Classes derived from the class can override this method to specify dynamic behavior for operations that access objects by a specified index. + + Provides information about the operation. + The indexes that are used in the operation. For example, for the sampleObject[3] = 10 operation in C# (sampleObject(3) = 10 in Visual Basic), where sampleObject is derived from the class, is equal to 3. + The value to set to the object that has the specified index. For example, for the sampleObject[3] = 10 operation in C# (sampleObject(3) = 10 in Visual Basic), where sampleObject is derived from the class, is equal to 10. + + true if the operation is successful; otherwise, false. If this method returns false, the run-time binder of the language determines the behavior. (In most cases, a language-specific run-time exception is thrown. + + + + + Provides the implementation for operations that set member values. Classes derived from the class can override this method to specify dynamic behavior for operations such as setting a value for a property. + + Provides information about the object that called the dynamic operation. The binder.Name property provides the name of the member to which the value is being assigned. For example, for the statement sampleObject.SampleProperty = "Test", where sampleObject is an instance of the class derived from the class, binder.Name returns "SampleProperty". The binder.IgnoreCase property specifies whether the member name is case-sensitive. + The value to set to the member. For example, for sampleObject.SampleProperty = "Test", where sampleObject is an instance of the class derived from the class, the is "Test". + + true if the operation is successful; otherwise, false. If this method returns false, the run-time binder of the language determines the behavior. (In most cases, a language-specific run-time exception is thrown.) + + + + + Returns the enumeration of all dynamic member names. + + + A sequence that contains dynamic member names. + + + + + Gets the at the specified index. + + + + + + Gets the keys. + + The keys. + + + + Gets the values. + + The values. + + + + Gets or sets the with the specified key. + + + + + + Gets the count. + + The count. + + + + Gets a value indicating whether this instance is read only. + + + true if this instance is read only; otherwise, false. + + + + + This class encodes and decodes JSON strings. + Spec. details, see http://www.json.org/ + + JSON uses Arrays and Objects. These correspond here to the datatypes JsonArray(IList<object>) and JsonObject(IDictionary<string,object>). + All numbers are parsed to doubles. + + + + + Parses the string json into a value + + A JSON string. + An IList<object>, a IDictionary<string,object>, a double, a string, null, true, or false + + + + Try parsing the json string into a value. + + + A JSON string. + + + The object. + + + Returns true if successfull otherwise false. + + + + + Converts a IDictionary<string,object> / IList<object> object into a JSON string + + A IDictionary<string,object> / IList<object> + Serializer strategy to use + A JSON encoded string, or null if object 'json' is not serializable + + + + Determines if a given object is numeric in any way + (can be integer, double, null, etc). + + + + diff --git a/packages/Elasticsearch.Net.1.3.1/lib/Elasticsearch.Net.dll b/packages/Elasticsearch.Net.1.3.1/lib/Elasticsearch.Net.dll new file mode 100644 index 0000000..5297654 Binary files /dev/null and b/packages/Elasticsearch.Net.1.3.1/lib/Elasticsearch.Net.dll differ diff --git a/packages/Elasticsearch.Net.1.3.1/lib/Elasticsearch.Net.pdb b/packages/Elasticsearch.Net.1.3.1/lib/Elasticsearch.Net.pdb new file mode 100644 index 0000000..6416a78 Binary files /dev/null and b/packages/Elasticsearch.Net.1.3.1/lib/Elasticsearch.Net.pdb differ diff --git a/packages/NEST.1.3.1/NEST.1.3.1.nupkg b/packages/NEST.1.3.1/NEST.1.3.1.nupkg new file mode 100644 index 0000000..80ec4a9 Binary files /dev/null and b/packages/NEST.1.3.1/NEST.1.3.1.nupkg differ diff --git a/packages/NEST.1.3.1/lib/Nest.XML b/packages/NEST.1.3.1/lib/Nest.XML new file mode 100644 index 0000000..a4553fb --- /dev/null +++ b/packages/NEST.1.3.1/lib/Nest.XML @@ -0,0 +1,12447 @@ + + + + Nest + + + + Implements several handy alias extensions. + + + + + Returns a list of aliases that point to the specified index, simplified version of GetAliases. + + + The exact indexname we want to know aliases of + + + + Returns a list of aliases that point to the specified index, simplified version of GetAliases. + + + The exact indexname we want to know aliases of + + + + Returns a list of indices that have the specified aliasName applied to them. Simplified version of GetAliases. + + + The exact alias name + + + + Returns a list of indices that have the specified aliasName applied to them. Simplified version of GetAliases. + + + The exact alias name + + + Implements a convenience extension method for count that defaults + to counting over all indices and types. + + + + + The count API allows to easily execute a query and get the number of matches for that query. + It can be executed across one or more indices and across one or more types. + This overload returns a dynamic response and defaults to all types and indices +  >http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-count.html + + + An optional descriptor to describe the count operation + + + + The count API allows to easily execute a query and get the number of matches for that query. + It can be executed across one or more indices and across one or more types. + This overload returns a dynamic response and defaults to all types and indices +  >http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-count.html + + + An optional descriptor to describe the count operation + + + + Implements extensions to Delete that allow for easier by id deletes. + + + + + The delete API allows to delete a typed JSON document from a specific index based on its id. +  >http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/docs-delete.html + + + The name of the index as string + The type name of the document you wish to delete + The id as string of the document you want to delete + An optional descriptor to further describe the delete operation + + + + The delete API allows to delete a typed JSON document from a specific index based on its id. +  >http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/docs-delete.html + + The type used to infer the default index and typename + + The id as int of the document you want to delete + An optional descriptor to further describe the delete operation + + + + The delete API allows to delete a typed JSON document from a specific index based on its id. +  >http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/docs-delete.html + + The type used to infer the default index and typename + + The id as string of the document you want to delete + An optional descriptor to further describe the delete operation + + + + The delete API allows to delete a typed JSON document from a specific index based on its id. +  >http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/docs-delete.html + + The type used to infer the default index and typename + + The id as int of the document you want to delete + An optional descriptor to further describe the delete operation + + + + The delete API allows to delete a typed JSON document from a specific index based on its id. +  >http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/docs-delete.html + + + The name of the index as string + The type name of the document you wish to delete + The id as string of the document you want to delete + An optional descriptor to further describe the delete operation + + + + The delete API allows to delete a typed JSON document from a specific index based on its id. +  >http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/docs-delete.html + + The type used to infer the default index and typename + + The id as string of the document you want to delete + An optional descriptor to further describe the delete operation + + + + The delete API allows to delete a typed JSON document from a specific index based on its id. +  >http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/docs-delete.html + + The type used to infer the default index and typename + + The object used to infer the id + An optional descriptor to further describe the delete operation + + + + The delete API allows to delete a typed JSON document from a specific index based on its id. +  >http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/docs-delete.html + + The type used to infer the default index and typename + + The object used to infer the id + An optional descriptor to further describe the delete operation + + + + Provides convenience extension methods that make it easier to delete existing indices. + + + + + The delete index API allows to delete an existing index. +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/indices-delete-index.html + + + The name of the index to be deleted + A descriptor that further describes the parameters for the delete index operation + + + + The delete index API allows to delete an existing index. +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/indices-delete-index.html + + + The name of the index to be deleted + A descriptor that further describes the parameters for the delete index operation + + + + Provides GetMany extensions that make it easier to get many documents given a list of ids + + + + + Shortcut into the Bulk call that indexes the specified objects +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/docs-bulk.html + + + The type used to infer the default index and typename + List of objects to index, Id will be inferred (Id property or IdProperty attribute on type) + Override the inferred indexname for T + Override the inferred typename for T + + + + Shortcut into the Bulk call that indexes the specified objects +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/docs-bulk.html + + + The type used to infer the default index and typename + List of objects to index, Id will be inferred (Id property or IdProperty attribute on type) + Override the inferred indexname for T + Override the inferred typename for T + + + + Implements Get() extensions that make it easier to get a document given an id + + + + + The get API allows to get a typed JSON document from the index based on its id. +  >http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/docs-get.html + + The type used to infer the default index and typename + + The string id of the document we want the fetch + Optionally override the inferred index name for T + Optionally override the inferred typename for T + + + + The get API allows to get a typed JSON document from the index based on its id. +  >http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/docs-get.html + + The type used to infer the default index and typename + + The long id of the document we want the fetch + Optionally override the inferred index name for T + Optionally override the inferred typename for T + + + + The get API allows to get a typed JSON document from the index based on its id. +  >http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/docs-get.html + + The type used to infer the default index and typename + + The string id of the document we want the fetch + Optionally override the inferred index name for T + Optionally override the inferred typename for T + + + + The get API allows to get a typed JSON document from the index based on its id. +  >http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/docs-get.html + + The type used to infer the default index and typename + + The long id of the document we want the fetch + Optionally override the inferred index name for T + Optionally override the inferred typename for T + + + + Provides GetMany extensions that make it easier to get many documents given a list of ids + + + + + Shortcut into the Bulk call that deletes the specified objects +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/docs-bulk.html + + + The type used to infer the default index and typename + List of objects to delete + Override the inferred indexname for T + Override the inferred typename for T + + + + Shortcut into the Bulk call that deletes the specified objects +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/docs-bulk.html + + + The type used to infer the default index and typename + List of objects to delete + Override the inferred indexname for T + Override the inferred typename for T + + + + Provides GetMany extensions that make it easier to get many documents given a list of ids + + + + + Multi GET API allows to get multiple documents based on an index, type (optional) and id (and possibly routing). + The response includes a docs array with all the fetched documents, each element similar in structure to a document + provided by the get API. +  >http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/docs-multi-get.html + + The type used to infer the default index and typename + + IEnumerable of ids as string for the documents to fetch + Optionally override the default inferred index name for T + Optionally overiide the default inferred typename for T + + + + Multi GET API allows to get multiple documents based on an index, type (optional) and id (and possibly routing). + The response includes a docs array with all the fetched documents, each element similar in structure to a document + provided by the get API. +  >http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/docs-multi-get.html + + The type used to infer the default index and typename + + IEnumerable of ids as ints for the documents to fetch + Optionally override the default inferred index name for T + Optionally overiide the default inferred typename for T + + + + Multi GET API allows to get multiple documents based on an index, type (optional) and id (and possibly routing). + The response includes a docs array with all the fetched documents, each element similar in structure to a document + provided by the get API. +  >http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/docs-multi-get.html + + The type used to infer the default index and typename + + IEnumerable of ids as string for the documents to fetch + Optionally override the default inferred index name for T + Optionally overiide the default inferred typename for T + + + + Multi GET API allows to get multiple documents based on an index, type (optional) and id (and possibly routing). + The response includes a docs array with all the fetched documents, each element similar in structure to a document + provided by the get API. +  >http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/docs-multi-get.html + + The type used to infer the default index and typename + + IEnumerable of ids as ints for the documents to fetch + Optionally override the default inferred index name for T + Optionally overiide the default inferred typename for T + + + + Provides convenience extension to open an index by string or type. + + + + + The create index API allows to instantiate an index. Elasticsearch provides support for multiple indices, + including executing operations across several indices. +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/indices-create-index.html + + + The name of the index to be created + A descriptor that further describes the parameters for the create index operation + + + + The create index API allows to instantiate an index. Elasticsearch provides support for multiple indices, + including executing operations across several indices. +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/indices-create-index.html + + + The name of the index to be created + A descriptor that further describes the parameters for the create index operation + + + + The create index API allows to instantiate an index. Elasticsearch provides support for multiple indices, + including executing operations across several indices. +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/indices-create-index.html + + + The name of the index to be created + A descriptor that further describes the parameters for the create index operation + + + + Provides convenience extension to open an index by string or type. + + + + + The open and close index APIs allow to close an index, and later on opening it. + A closed index has almost no overhead on the cluster (except for maintaining its metadata), and is blocked + for read/write operations. + A closed index can be opened which will then go through the normal recovery process. +  >http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/indices-open-close.html + + + The name of the index to be opened + + + + The open and close index APIs allow to close an index, and later on opening it. + A closed index has almost no overhead on the cluster (except for maintaining its metadata), and is blocked + for read/write operations. + A closed index can be opened which will then go through the normal recovery process. +  >http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/indices-open-close.html + + The type used to infer the index name to be opened + + + + + The open and close index APIs allow to close an index, and later on opening it. + A closed index has almost no overhead on the cluster (except for maintaining its metadata), and is blocked + for read/write operations. + A closed index can be opened which will then go through the normal recovery process. +  >http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/indices-open-close.html + + + The name of the index to be closed + + + + The open and close index APIs allow to close an index, and later on opening it. + A closed index has almost no overhead on the cluster (except for maintaining its metadata), and is blocked + for read/write operations. + A closed index can be opened which will then go through the normal recovery process. +  >http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/indices-open-close.html + + The type used to infer the index name to be closed + + + + + Provides extension methods to provide a cleaner scoll API given a scollTime and scrollId + + + + + Provides extension methods to provide a cleaner scoll API given a scollTime and scrollId + + + + + A search request can be scrolled by specifying the scroll parameter. + The scroll parameter is a time value parameter (for example: scroll=5m), + indicating for how long the nodes that participate in the search will maintain relevant resources in + order to continue and support it. + This is very similar in its idea to opening a cursor against a database. + + The type that represents the result hits + + The time the server should wait for the scroll before closing the scan operation + The scroll id to continue the scroll operation + + + + A search request can be scrolled by specifying the scroll parameter. + The scroll parameter is a time value parameter (for example: scroll=5m), + indicating for how long the nodes that participate in the search will maintain relevant resources in + order to continue and support it. + This is very similar in its idea to opening a cursor against a database. + + The type that represents the result hits + + The time the server should wait for the scroll before closing the scan operation + The scroll id to continue the scroll operation + + + + Deletes a registered scroll request on the cluster +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-request-scroll.html + + + The scrollId to clear + + + + Deletes a registered scroll request on the cluster +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-request-scroll.html + + + The scrollId to clear + + + + This is a convenience method to deserialize to T using the registered deserializer. + NOTE: If you want to deserialize to a NEST response you need to use the overload that + takes an ElasticsearchResponse + + The type to deserialize to + the interface we are extending + The string representation of the data to be deserialized + + + + Provides convenience extension methods that make it easier to get the _source for + a given document given a string or long id. + + + + + Use the /{index}/{type}/{id}/_source endpoint to get just the _source field of the document, + without any additional content around it. +  >http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/docs-get.html#_source + + The type used to infer the default index and typename + + id as string of the document we want the _source from + Optionally override the inferred index name for T + Optionally override the inferred type name for T + + + + Use the /{index}/{type}/{id}/_source endpoint to get just the _source field of the document, + without any additional content around it. +  >http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/docs-get.html#_source + + The type used to infer the default index and typename + + id as int of the document we want the _source from + Optionally override the inferred index name for T + Optionally override the inferred type name for T + + + + Use the /{index}/{type}/{id}/_source endpoint to get just the _source field of the document, + without any additional content around it. +  >http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/docs-get.html#_source + + The type used to infer the default index and typename + + id as string of the document we want the _source from + Optionally override the inferred index name for T + Optionally override the inferred type name for T + + + + Use the /{index}/{type}/{id}/_source endpoint to get just the _source field of the document, + without any additional content around it. +  >http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/docs-get.html#_source + + The type used to infer the default index and typename + + id as int of the document we want the _source from + Optionally override the inferred index name for T + Optionally override the inferred type name for T + + + + Provides convenience extension methods to get many _source's given a list of ids. + + + + + SourceMany allows you to get a list of T documents out of elasticsearch, internally it calls into MultiGet() + + Multi GET API allows to get multiple documents based on an index, type (optional) and id (and possibly routing). + The response includes a docs array with all the fetched documents, each element similar in structure to a document + provided by the get API. + +  >http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/docs-multi-get.html + + The type used to infer the default index and typename + + A list of ids as string + Optionally override the default inferred indexname for T + Optionally override the default inferred indexname for T + + + + SourceMany allows you to get a list of T documents out of elasticsearch, internally it calls into MultiGet() + + Multi GET API allows to get multiple documents based on an index, type (optional) and id (and possibly routing). + The response includes a docs array with all the fetched documents, each element similar in structure to a document + provided by the get API. + +  >http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/docs-multi-get.html + + The type used to infer the default index and typename + + A list of ids as int + Optionally override the default inferred indexname for T + Optionally override the default inferred indexname for T + + + + SourceMany allows you to get a list of T documents out of elasticsearch, internally it calls into MultiGet() + + Multi GET API allows to get multiple documents based on an index, type (optional) and id (and possibly routing). + The response includes a docs array with all the fetched documents, each element similar in structure to a document + provided by the get API. + +  >http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/docs-multi-get.html + + The type used to infer the default index and typename + + A list of ids as string + Optionally override the default inferred indexname for T + Optionally override the default inferred indexname for T + + + + SourceMany allows you to get a list of T documents out of elasticsearch, internally it calls into MultiGet() + + Multi GET API allows to get multiple documents based on an index, type (optional) and id (and possibly routing). + The response includes a docs array with all the fetched documents, each element similar in structure to a document + provided by the get API. + +  >http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/docs-multi-get.html + + The type used to infer the default index and typename + + A list of ids as int + Optionally override the default inferred indexname for T + Optionally override the default inferred indexname for T + + + + Get a DateTime form of the returned key, only make sense on date_histogram aggregations. + + + + + Marker interface for alias operation + + + + + + + + + + The pattern_replace char filter allows the use of a regex to manipulate the characters in a string before analysis. + + + + + Splits tokens into tokens and payload whenever a delimiter character is found. + + + + + Character used for splitting the tokens. + + + + + The type of the payload. int for integer, float for float and identity for characters. + + + + + Token filter that generates bigrams for frequently occuring terms. Single terms are still indexed. + Note, common_words or common_words_path field is required. + + + + + A list of common words to use. + + + + + A path (either relative to config location, or absolute) to a list of common words. + + + + + If true, common words matching will be case insensitive. + + + + + Generates bigrams then removes common words and single terms followed by a common word. + + + + + The keyword_repeat token filter Emits each incoming token twice once as keyword and once as a non-keyword to allow an unstemmed version of a term to be indexed side by side with the stemmed version of the term. + + + + + Basic support for hunspell stemming. + Hunspell dictionaries will be picked up from a dedicated hunspell directory on the filesystem. + + + + + If true, dictionary matching will be case insensitive. + + + + + A locale for this filter. If this is unset, the lang or language are used instead - so one of these has to be set. + + + + + The name of a dictionary. + + + + + If only unique terms should be returned, this needs to be set to true. + + + + + If only the longest term should be returned, set this to true. + + + + + Limits the number of tokens that are indexed per document and field. + + + + + The maximum number of tokens that should be indexed per document and field. + + + + + If set to true the filter exhaust the stream even if max_token_count tokens have been consumed already. + + + + + The pattern_capture token filter, unlike the pattern tokenizer, emits a token for every capture group in the regular expression. + + + + + If preserve_original is set to true then it would also emit the original token + + + + + A token filter of type keep that only keeps tokens with text contained in a predefined set of words. + + + + + A list of words to keep. + + + + + A path to a words file. + + + + + A boolean indicating whether to lower case the words. + + + + + Overrides stemming algorithms, by applying a custom mapping, then protecting these terms from being modified by stemmers. Must be placed before any stemming filters. + + + + + A list of mapping rules to use. + + + + + A path (either relative to config location, or absolute) to a list of mappings. + + + + + A token filter of type uppercase that normalizes token text to upper case. + + + + + This class allows you to map aspects of a Type's property + that influences how NEST treats it. + + + + + Override the json property name of a type + + + + + Ignore this property completely + 
- When mapping automatically using MapFromAttributes()
+ 
- When Indexing this type do not serialize whatever this value hold
+ + + + + This class allows you to map aspects of a Type's property + that influences how NEST treats it. + + + + + Override the json property name of a type + + + + + Ignore this property completely + 
- When mapping automatically using MapFromAttributes()
+ 
- When Indexing this type do not serialize whatever this value hold
+ + + + + + + + + Used to describe request parameters not part of the body. e.q query string or + connection configuration overrides + + + + Request parameters for DeleteScript + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html
+
+ + + + descriptor for DeleteScript + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html
+
+ + + + + Specify settings for this request alone, handy if you need a custom timeout or want to bypass sniffing, retries + + + + Request parameters for GetScript + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html
+
+ + + + descriptor for GetScript + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html
+
+ + + + Request parameters for PutScript + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html
+
+ + + + descriptor for PutScript + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html
+
+ + + + + Provides a base for descriptors that need to describe a path in the form of + 
+            /{name}
+
+ name is mandatory. + + + + + Specify the {name} part of the operation + + + + Request parameters for CatIndices + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-indices.html
+
+ + + + The unit in which to display byte values + + + Return local information, do not retrieve the state from master node (default: false) + + + Explicit operation timeout for connection to master node + + + Comma-separated list of column names to display + + + Return help information + + + Set to true to return stats only for primary shards + + + Verbose mode. Display column headers + + + descriptor for CatIndices + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-indices.html
+
+ + + + The unit in which to display byte values + + + Return local information, do not retrieve the state from master node (default: false) + + + Explicit operation timeout for connection to master node + + + Comma-separated list of column names to display + + + Return help information + + + Set to true to return stats only for primary shards + + + Verbose mode. Display column headers + + + Request parameters for CatShards + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-shards.html
+
+ + + + Return local information, do not retrieve the state from master node (default: false) + + + Explicit operation timeout for connection to master node + + + Comma-separated list of column names to display + + + Return help information + + + Verbose mode. Display column headers + + + descriptor for CatShards + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-shards.html
+
+ + + + Return local information, do not retrieve the state from master node (default: false) + + + Explicit operation timeout for connection to master node + + + Comma-separated list of column names to display + + + Return help information + + + Verbose mode. Display column headers + + + Request parameters for CatThreadPool + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/cat-thread-pool.html
+
+ + + + Return local information, do not retrieve the state from master node (default: false) + + + Explicit operation timeout for connection to master node + + + Comma-separated list of column names to display + + + Return help information + + + Verbose mode. Display column headers + + + Enables displaying the complete node ids + + + descriptor for CatThreadPool + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/cat-thread-pool.html
+
+ + + + Return local information, do not retrieve the state from master node (default: false) + + + Explicit operation timeout for connection to master node + + + Comma-separated list of column names to display + + + Return help information + + + Verbose mode. Display column headers + + + Enables displaying the complete node ids + + + Request parameters for CatRecovery + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-recovery.html
+
+ + + + The unit in which to display byte values + + + Explicit operation timeout for connection to master node + + + Comma-separated list of column names to display + + + Return help information + + + Verbose mode. Display column headers + + + descriptor for CatRecovery + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-recovery.html
+
+ + + + The unit in which to display byte values + + + Explicit operation timeout for connection to master node + + + Comma-separated list of column names to display + + + Return help information + + + Verbose mode. Display column headers + + + Request parameters for CatPlugins + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/cat-plugins.html
+
+ + + + Return local information, do not retrieve the state from master node (default: false) + + + Explicit operation timeout for connection to master node + + + Comma-separated list of column names to display + + + Return help information + + + Verbose mode. Display column headers + + + descriptor for CatPlugins + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/cat-plugins.html
+
+ + + + Return local information, do not retrieve the state from master node (default: false) + + + Explicit operation timeout for connection to master node + + + Comma-separated list of column names to display + + + Return help information + + + Verbose mode. Display column headers + + + Request parameters for CatPendingTasks + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-pending-tasks.html
+
+ + + + Return local information, do not retrieve the state from master node (default: false) + + + Explicit operation timeout for connection to master node + + + Comma-separated list of column names to display + + + Return help information + + + Verbose mode. Display column headers + + + descriptor for CatPendingTasks + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-pending-tasks.html
+
+ + + + Return local information, do not retrieve the state from master node (default: false) + + + Explicit operation timeout for connection to master node + + + Comma-separated list of column names to display + + + Return help information + + + Verbose mode. Display column headers + + + Request parameters for CatNodes + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-nodes.html
+
+ + + + Return local information, do not retrieve the state from master node (default: false) + + + Explicit operation timeout for connection to master node + + + Comma-separated list of column names to display + + + Return help information + + + Verbose mode. Display column headers + + + descriptor for CatNodes + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-nodes.html
+
+ + + + Return local information, do not retrieve the state from master node (default: false) + + + Explicit operation timeout for connection to master node + + + Comma-separated list of column names to display + + + Return help information + + + Verbose mode. Display column headers + + + Request parameters for CatMaster + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-master.html
+
+ + + + Return local information, do not retrieve the state from master node (default: false) + + + Explicit operation timeout for connection to master node + + + Comma-separated list of column names to display + + + Return help information + + + Verbose mode. Display column headers + + + descriptor for CatMaster + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-master.html
+
+ + + + Return local information, do not retrieve the state from master node (default: false) + + + Explicit operation timeout for connection to master node + + + Comma-separated list of column names to display + + + Return help information + + + Verbose mode. Display column headers + + + Request parameters for CatHealth + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-health.html
+
+ + + + Return local information, do not retrieve the state from master node (default: false) + + + Explicit operation timeout for connection to master node + + + Comma-separated list of column names to display + + + Return help information + + + Set to false to disable timestamping + + + Verbose mode. Display column headers + + + descriptor for CatHealth + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-health.html
+
+ + + + Return local information, do not retrieve the state from master node (default: false) + + + Explicit operation timeout for connection to master node + + + Comma-separated list of column names to display + + + Return help information + + + Set to false to disable timestamping + + + Verbose mode. Display column headers + + + Request parameters for CatFielddata + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/cat-fielddata.html
+
+ + + + The unit in which to display byte values + + + Return local information, do not retrieve the state from master node (default: false) + + + Explicit operation timeout for connection to master node + + + Comma-separated list of column names to display + + + Return help information + + + Verbose mode. Display column headers + + + A comma-separated list of fields to return the fielddata size + + + descriptor for CatFielddata + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/cat-fielddata.html
+
+ + + + The unit in which to display byte values + + + Return local information, do not retrieve the state from master node (default: false) + + + Explicit operation timeout for connection to master node + + + Comma-separated list of column names to display + + + Return help information + + + Verbose mode. Display column headers + + + A comma-separated list of fields to return the fielddata size + + + A comma-separated list of fields to return the fielddata size + + + Request parameters for CatCount + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-count.html
+
+ + + + Return local information, do not retrieve the state from master node (default: false) + + + Explicit operation timeout for connection to master node + + + Comma-separated list of column names to display + + + Return help information + + + Verbose mode. Display column headers + + + descriptor for CatCount + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-count.html
+
+ + + + Return local information, do not retrieve the state from master node (default: false) + + + Explicit operation timeout for connection to master node + + + Comma-separated list of column names to display + + + Return help information + + + Verbose mode. Display column headers + + + Request parameters for CatAllocation + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-allocation.html
+
+ + + + The unit in which to display byte values + + + Return local information, do not retrieve the state from master node (default: false) + + + Explicit operation timeout for connection to master node + + + Comma-separated list of column names to display + + + Return help information + + + Verbose mode. Display column headers + + + descriptor for CatAllocation + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-allocation.html
+
+ + + + The unit in which to display byte values + + + Return local information, do not retrieve the state from master node (default: false) + + + Explicit operation timeout for connection to master node + + + Comma-separated list of column names to display + + + Return help information + + + Verbose mode. Display column headers + + + Request parameters for ClusterPendingTasks + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-pending.html
+
+ + + + Return local information, do not retrieve the state from master node (default: false) + + + Specify timeout for connection to master + + + descriptor for ClusterPendingTasks + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-pending.html
+
+ + + + Return local information, do not retrieve the state from master node (default: false) + + + Specify timeout for connection to master + + + Request parameters for ClusterStats + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-stats.html
+
+ + + + Return settings in flat format (default: false) + + + Whether to return time and byte values in human-readable format. + + + descriptor for ClusterStats + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-stats.html
+
+ + + + Return settings in flat format (default: false) + + + Whether to return time and byte values in human-readable format. + + + Request parameters for CatAliases + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-aliases.html
+
+ + + + Return local information, do not retrieve the state from master node (default: false) + + + Explicit operation timeout for connection to master node + + + Comma-separated list of column names to display + + + Return help information + + + Verbose mode. Display column headers + + + descriptor for CatAliases + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-aliases.html
+
+ + + + Return local information, do not retrieve the state from master node (default: false) + + + Explicit operation timeout for connection to master node + + + Comma-separated list of column names to display + + + Return help information + + + Verbose mode. Display column headers + + + Request parameters for IndicesDeleteAlias + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html
+
+ + + + Explicit timestamp for the document + + + Specify timeout for connection to master + + + descriptor for IndicesDeleteAlias + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html
+
+ + + + + Provides a base for descriptors that need to describe a path in the form of + 
+            /{index}/{name}
+
+ neither parameter is optional + + + + Explicit timestamp for the document + + + Specify timeout for connection to master + + + Request parameters for SnapshotGetRepository + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html
+
+ + + + Explicit operation timeout for connection to master node + + + Return local information, do not retrieve the state from master node (default: false) + + + descriptor for SnapshotGetRepository + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html
+
+ + + + + Provides a base for descriptors that need to describe a path that contains a + 
+            {repository}
+
+ routing value + + + + + Specify the name of the repository we are targeting + + + + Explicit operation timeout for connection to master node + + + Return local information, do not retrieve the state from master node (default: false) + + + Request parameters for IndicesPutAlias + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html
+
+ + + + Explicit timestamp for the document + + + Specify timeout for connection to master + + + descriptor for IndicesPutAlias + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html
+
+ + + + + Provides a base for descriptors that need to describe a path in the form of + 
+            /{index}/{name}
+
+ neither parameter is optional + + + + Explicit timestamp for the document + + + Specify timeout for connection to master + + + Request parameters for SearchShardsGet + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-shards.html
+
+ + + + Specify the node or shard the operation should be performed on (default: random) + + + Specific routing value + + + Return local information, do not retrieve the state from master node (default: false) + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Request parameters for SearchShardsGet + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-shards.html
+
+ + + + Specify the node or shard the operation should be performed on (default: random) + + + Specific routing value + + + Return local information, do not retrieve the state from master node (default: false) + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + + A descriptor wich describes a search operation for _search_shards + + descriptor for SearchShardsGet + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-shards.html
+
+ + + + + Provides a base for descriptors that need to describe a path in the form of + 
+            /{indices}/{types}
+
+ all parameters are optional and will default to the defaults for T + + + + + The indices to execute the search on. Defaults to the default index + + + + + The indices to execute the search on. Defaults to the default index + + + + + The indices to execute the search on. Defaults to the default index + + + + + The indices to execute the search on. Defaults to the default index + + + + + The indices to execute the search on. Defaults to the default index + + + + + The index to execute the search on, using the default index for typeof TAlternative. Defaults to the default index + + + + + The index to execute the search on. Defaults to the default index + + + + + The index to execute the search on. Defaults to the default index + + + + + The index to execute the search on. Defaults to the default index + + + + + The types to execute the search on. Defaults to the inferred typename of T + unless T is dynamic then a type (or AllTypes()) MUST be specified. + + + + + The types to execute the search on. Defaults to the inferred typename of T + unless T is dynamic then a type (or AllTypes()) MUST be specified. + + + + + The types to execute the search on. Defaults to the inferred typename of T + unless T is dynamic then a type (or AllTypes()) MUST be specified. + + + + + The types to execute the search on. Defaults to the inferred typename of T + unless T is dynamic then a type (or AllTypes()) MUST be specified. + + + + + The types to execute the search on. Defaults to the inferred typename of T + unless T is dynamic then a type (or AllTypes()) MUST be specified. + + + + + The type to execute the search on. Defaults to the inferred typename of T + unless T is dynamic then a type (or AllTypes()) MUST be specified. + + + + + The type to execute the search on. Defaults to the inferred typename of T + unless T is dynamic then a type (or AllTypes()) MUST be specified. + + + + + The type to execute the search on. Defaults to the inferred typename of T + unless T is dynamic then a type (or AllTypes()) MUST be specified. + + + + + An alternative type to infer the typename from + + + + + Execute search over all indices + + + + + Execute search over all types + + + + Specify the node or shard the operation should be performed on (default: random) + + + Specific routing value + + + Return local information, do not retrieve the state from master node (default: false) + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + + Provides a base for descriptors that need to describe a path that contains a + 
+            {repository}
+
+ routing value + + + + + Specify the name of the repository we are targeting + + + + Request parameters for SnapshotStatus + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-snapshots.html
+
+ + + + Explicit operation timeout for connection to master node + + + descriptor for SnapshotStatus + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-snapshots.html
+
+ + + + Explicit operation timeout for connection to master node + + + Request parameters for IndicesRecoveryForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/indices-recovery.html
+
+ + + + Whether to display detailed information about shard recovery + + + Display only those recoveries that are currently on-going + + + Whether to return time and byte values in human-readable format. + + + descriptor for IndicesRecoveryForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/indices-recovery.html
+
+ + + + + Provides a base for descriptors that need to describe a path in the form of + 
+            /{indices}
+
+ {indices} is optional + + + + Whether to display detailed information about shard recovery + + + Display only those recoveries that are currently on-going + + + Whether to return time and byte values in human-readable format. + + + + Based on the type information present in this descriptor create method that takes + the returned _source and hit and returns the ClrType it should deserialize too. + This is so that Documents[A] can contain actual instances of subclasses B, C as well. + If you specify types using .Types(typeof(B), typeof(C)) then NEST can automagically + create a TypeSelector based on the hits _type property. + + + + Request parameters for SearchTemplateGet + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-template.html
+
+ + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Specify the node or shard the operation should be performed on (default: random) + + + A comma-separated list of specific routing values + + + Specify how long a consistent view of the index should be maintained for scrolled search + + + Search operation type + + + Request parameters for SearchTemplateGet + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-template.html
+
+ + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Specify the node or shard the operation should be performed on (default: random) + + + A comma-separated list of specific routing values + + + Specify how long a consistent view of the index should be maintained for scrolled search + + + Search operation type + + + descriptor for SearchTemplateGet + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-template.html
+
+ + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Specify the node or shard the operation should be performed on (default: random) + + + A comma-separated list of specific routing values + + + Specify how long a consistent view of the index should be maintained for scrolled search + + + Search operation type + + + + Whether conditionless queries are allowed or not + + + + Request parameters for IndicesExistsTemplateForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html
+
+ + + + Return local information, do not retrieve the state from master node (default: false) + + + descriptor for IndicesExistsTemplateForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html
+
+ + + + Return local information, do not retrieve the state from master node (default: false) + + + Request parameters for IndicesGetAliasForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html
+
+ + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Return local information, do not retrieve the state from master node (default: false) + + + descriptor for IndicesGetAliasForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html
+
+ + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Return local information, do not retrieve the state from master node (default: false) + + + Request parameters for IndicesExistsAliasForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html
+
+ + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Return local information, do not retrieve the state from master node (default: false) + + + descriptor for IndicesExistsAliasForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html
+
+ + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Return local information, do not retrieve the state from master node (default: false) + + + Request parameters for IndicesGetFieldMappingForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-field-mapping.html
+
+ + + + Whether the default mapping values should be returned as well + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Return local information, do not retrieve the state from master node (default: false) + + + Request parameters for IndicesGetFieldMappingForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-field-mapping.html
+
+ + + + Whether the default mapping values should be returned as well + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Return local information, do not retrieve the state from master node (default: false) + + + descriptor for IndicesGetFieldMappingForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-field-mapping.html
+
+ + + + + Provides a base for descriptors that need to describe a path in the form of + 
+            /{indices}/{types/{Fields}
+
+ {types} is optional, {indices} is too, {Fields} is mandatory + + + + + Force the operation to hit _all indices + + + + + Specify multiple indices by string + + + + + Specify multiple indices by stating the types you are searching on. + Each type will be asked for their default index and dedupped. + + + + + Use the default index of T + + + + + Use the default index of T + + + + + Use the default index of T + + + + + limit the types to operate on by specifiying them by string + + + + + limit the types to operate on by specifying the CLR types, the type names will be inferred. + + + + + Limit the operation on type T + + + + + Specify the fields to operate on + + + + + Specify the fields to operate on + + + + Whether the default mapping values should be returned as well + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Return local information, do not retrieve the state from master node (default: false) + + + Request parameters for MpercolateGet + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html
+
+ + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + descriptor for MpercolateGet + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html
+
+ + + + + Provides a base for descriptors that need to describe a path in the form of + 
+            /{index}/{type}
+
+ {index} is optional and so is {type} and will NOT fallback to the defaults of T + type can only be specified in conjuction with index. + + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Request parameters for NodesHotThreadsForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-hot-threads.html
+
+ + + + The interval for the second sampling of threads + + + Number of samples of thread stacktrace (default: 10) + + + Specify the number of threads to provide information for (default: 3) + + + The type to sample (default: cpu) + + + descriptor for NodesHotThreadsForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-hot-threads.html
+
+ + + + The interval for the second sampling of threads + + + Number of samples of thread stacktrace (default: 10) + + + Specify the number of threads to provide information for (default: 3) + + + The type to sample (default: cpu) + + + Request parameters for NodesShutdownForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-shutdown.html
+
+ + + + Set the delay for the operation (default: 1s) + + + Exit the JVM as well (default: true) + + + descriptor for NodesShutdownForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-shutdown.html
+
+ + + + + Provides a base for descriptors that need to describe a path in the form of + 
+            /{nodeid}
+
+ node id is optional + + + + + Specify the {name} part of the operation + + + + Set the delay for the operation (default: 1s) + + + Exit the JVM as well (default: true) + + + + Provides a base for descriptors that need to describe a path in the form of + 
+            /{indices}/{types/{name}
+
+ {types} is optional, {indices} is too but needs an explicit AllIndices(). + + + + + Specify multiple indices by string + + + + + Specify multiple indices by stating the types you are searching on. + Each type will be asked for their default index and dedupped. + + + + + Use the default index of T + + + + + Use the default index of T + + + + + Use the default index of T + + + + + limit the types to operate on by specifiying them by string + + + + + limit the types to operate on by specifying the CLR types, the type names will be inferred. + + + + + Limit the operation on type T + + + + + Specify the {name} part of the operation + + + + Request parameters for Ping + 
+            http://www.elasticsearch.org/guide/
+
+ + + + descriptor for Ping + 
+            http://www.elasticsearch.org/guide/
+
+ + + + + Describe a get operation for the mlt_query docs property + + + + + Describe a get operation for the mlt_query docs property + + + + + Describe a get operation for the mlt_query docs property + + Use a different type to lookup + + + + Describe a get operation for the mlt_query docs property + + Use a different type to lookup + + + Request parameters for IndicesExistsType + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-types-exists.html
+
+ + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Return local information, do not retrieve the state from master node (default: false) + + + descriptor for IndicesExistsType + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-types-exists.html
+
+ + + + + Provides a base for descriptors that need to describe a path in the form of + 
+            /{index}/{type}
+
+ Where neither parameter is optional + + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Return local information, do not retrieve the state from master node (default: false) + + + + Provides NEST's ElasticClient with configurationsettings + + + + + Control how NEST's behaviour. + + + + + This calls SetDefaultTypenameInferrer with an implementation that will pluralize type names. This used to be the default prior to Nest 0.90 + + + + + Allows you to update internal the json.net serializer settings to your liking + + + + + Add a custom JsonConverter to the build in json serialization by passing in a predicate for a type. + This is faster then adding them using AddJsonConverters() because this way they will be part of the cached + Json.net contract for a type. + + + + + Index to default to when no index is specified. + + When null/empty/not set might throw NRE later on + when not specifying index explicitly while indexing. + + + + + By default NEST camelCases property names (EmailAddress => emailAddress) that do not have an explicit propertyname + either via an ElasticProperty attribute or because they are part of Dictionary where the keys should be treated verbatim. + 
+            Here you can register a function that transforms propertynames (default casing, pre- or suffixing)
+
+ + + + + Allows you to override how type names should be represented, the default will call .ToLowerInvariant() on the type's name. + + + + + Map types to a index names. Takes precedence over SetDefaultIndex(). + + + + + Allows you to override typenames, takes priority over the global SetDefaultTypeNameInferrer() + + + + + Instantiate a new connectionsettings object that proves ElasticClient with configuration values + + A single uri representing the root of the node you want to connect to + defaults to http://localhost:9200 + + The default index/alias name used for operations that expect an index/alias name, + By specifying it once alot of magic string can be avoided. + You can also specify specific default index/alias names for types using .SetDefaultTypeIndices( + If you do not specify this, NEST might throw a runtime exception if an explicit indexname was not provided for a call + + + + + Instantiate a new connectionsettings object that proves ElasticClient with configuration values + + A connection pool implementation that'll tell the client what nodes are available + The default index/alias name used for operations that expect an index/alias name, + By specifying it once alot of magic string can be avoided. + You can also specify specific default index/alias names for types using .SetDefaultTypeIndices( + If you do not specify this, NEST might throw a runtime exception if an explicit indexname was not provided for a call + + + + + DescriptorFor is a marker to rename unintuitive generated elasticsearch operation names + + + + + Create a strongly typed string representation of the path to a property + i.e p => p.Arrary.First().SubProperty.Field will return 'array.subProperty.field' + + The type of the object + The path we want to specify + An optional ^boost postfix, only make sense with queries + + + + Create a strongly typed string representation of the name to a property + i.e p => p.Arrary.First().SubProperty.Field will return 'field' + + The type of the object + The path we want to specify + An optional ^boost postfix, only make sense with queries + + + + Represents a typed container for property names i.e "property" in "field.nested.property"; + + + + + Represents a typed container for object paths "field.nested.property"; + + + + Request parameters for ClusterGetSettings + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-update-settings.html
+
+ + + + Return settings in flat format (default: false) + + + Explicit operation timeout for connection to master node + + + Explicit operation timeout + + + descriptor for ClusterGetSettings + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-update-settings.html
+
+ + + + Return settings in flat format (default: false) + + + Explicit operation timeout for connection to master node + + + Explicit operation timeout + + + Request parameters for ClusterPutSettings + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-update-settings.html
+
+ + + + Return settings in flat format (default: false) + + + descriptor for ClusterPutSettings + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-update-settings.html
+
+ + + + Return settings in flat format (default: false) + + + Request parameters for SnapshotDelete + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html
+
+ + + + Explicit operation timeout for connection to master node + + + descriptor for SnapshotDelete + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html
+
+ + + + + Provides a base for descriptors that need to describe a path that contains a + 
+            {repository}
+
+ routing value + + + + + Specify the name of the repository we are targeting + + + + Explicit operation timeout for connection to master node + + + + Describe the query to perform using the static Query class + + + + Request parameters for ExplainGet + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-explain.html
+
+ + + + Specify whether wildcards and prefix queries in the query string query should be analyzed (default: false) + + + The analyzer for the query string query + + + The default operator for query string query (AND or OR) + + + The default field for query string query (default: _all) + + + A comma-separated list of fields to return in the response + + + Specify whether format-based query failures (such as providing text to a numeric field) should be ignored + + + Specify whether query terms should be lowercased + + + The ID of the parent document + + + Specify the node or shard the operation should be performed on (default: random) + + + Query in the Lucene query string syntax + + + Specific routing value + + + The URL-encoded query definition (instead of using the request body) + + + True or false to return the _source field or not, or a list of fields to return + + + True or false to return the _source field or not, or a list of fields to return + + + A list of fields to exclude from the returned _source field + + + A list of fields to extract and return from the _source field + + + Request parameters for ExplainGet + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-explain.html
+
+ + + + Specify whether wildcards and prefix queries in the query string query should be analyzed (default: false) + + + The analyzer for the query string query + + + The default operator for query string query (AND or OR) + + + The default field for query string query (default: _all) + + + A comma-separated list of fields to return in the response + + + Specify whether format-based query failures (such as providing text to a numeric field) should be ignored + + + Specify whether query terms should be lowercased + + + The ID of the parent document + + + Specify the node or shard the operation should be performed on (default: random) + + + Query in the Lucene query string syntax + + + Specific routing value + + + The URL-encoded query definition (instead of using the request body) + + + True or false to return the _source field or not, or a list of fields to return + + + True or false to return the _source field or not, or a list of fields to return + + + A list of fields to exclude from the returned _source field + + + A list of fields to extract and return from the _source field + + + descriptor for ExplainGet + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-explain.html
+
+ + + + + Provides a base for descriptors that need to describe a path in the form of + 
+            /{index}/{type}/{id}
+
+ if one of the parameters is not explicitly specified this will fall back to the defaults for type T + + + + + Provides a base for descriptors that need to describe a path in the form of + 
+            /{index}/{type}/{id}
+
+ if one of the parameters is not explicitly specified this will fall back to the defaults for type + this version won't throw if any of the parts are inferred to be emptyT + + + + Specify whether wildcards and prefix queries in the query string query should be analyzed (default: false) + + + The analyzer for the query string query + + + The default operator for query string query (AND or OR) + + + The default field for query string query (default: _all) + + + A comma-separated list of fields to return in the response + + + A comma-separated list of fields to return in the response + + + Specify whether format-based query failures (such as providing text to a numeric field) should be ignored + + + Specify whether query terms should be lowercased + + + The ID of the parent document + + + Specify the node or shard the operation should be performed on (default: random) + + + Query in the Lucene query string syntax + + + Specific routing value + + + The URL-encoded query definition (instead of using the request body) + + + True or false to return the _source field or not, or a list of fields to return + + + True or false to return the _source field or not, or a list of fields to return + + + A list of fields to exclude from the returned _source field + + + A list of fields to exclude from the returned _source field + + + A list of fields to extract and return from the _source field + + + A list of fields to extract and return from the _source field + + + + Visit the query container just before we dispatch into the query it holds + + + + + + Visit every query item just before they are visited by their specialized Visit() implementation + + The IQuery object that will be visited + + + + Visit the filter container just before we dispatch into the filter it holds + + + + + + Visit every filer item just before they are visited by their specialized Visit() implementation + + The IFilterBase object that will be visited + + + + The current depth of the node being visited + + + + + Hints the relation with the parent, i,e queries inside a Must clause will have VisitorScope.Must set. + + + + Request parameters for AbortBenchmark + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-benchmark.html
+
+ + + + Request parameters for Bulk + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-bulk.html
+
+ + + + Explicit write consistency setting for the operation + + + Refresh the index after performing the operation + + + Explicitely set the replication type + + + Specific routing value + + + Explicit operation timeout + + + Default document type for items which don't provide one + + + Request parameters for CatHelp + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat.html
+
+ + + + Return help information + + + Request parameters for ClearScroll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html
+
+ + + + Request parameters for ClusterHealth + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-health.html
+
+ + + + Specify the level of detail for returned information + + + Return local information, do not retrieve the state from master node (default: false) + + + Explicit operation timeout for connection to master node + + + Explicit operation timeout + + + Wait until the specified number of shards is active + + + Wait until the specified number of nodes is available + + + Wait until the specified number of relocating shards is finished + + + Wait until cluster is in a specific state + + + Request parameters for ClusterReroute + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-reroute.html
+
+ + + + Simulate the operation only and return the resulting state + + + Return an explanation of why the commands can or cannot be executed + + + Don't return cluster state metadata (default: false) + + + Explicit operation timeout for connection to master node + + + Explicit operation timeout + + + Request parameters for ClusterState + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-state.html
+
+ + + + Return local information, do not retrieve the state from master node (default: false) + + + Specify timeout for connection to master + + + Return settings in flat format (default: false) + + + Request parameters for Count + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html
+
+ + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Include only documents with a specific `_score` value in the result + + + Specify the node or shard the operation should be performed on (default: random) + + + Specific routing value + + + The URL-encoded query definition (instead of using the request body) + + + Request parameters for CountPercolateGet + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html
+
+ + + + A comma-separated list of specific routing values + + + Specify the node or shard the operation should be performed on (default: random) + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + The index to count percolate the document into. Defaults to index. + + + The type to count percolate document into. Defaults to type. + + + Explicit version number for concurrency control + + + Specific version type + + + Request parameters for Delete + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-delete.html
+
+ + + + Specific write consistency setting for the operation + + + ID of parent document + + + Refresh the index after performing the operation + + + Specific replication type + + + Specific routing value + + + Explicit operation timeout + + + Explicit version number for concurrency control + + + Specific version type + + + Request parameters for DeleteByQuery + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-delete-by-query.html
+
+ + + + The analyzer to use for the query string + + + Specific write consistency setting for the operation + + + The default operator for query string query (AND or OR) + + + The field to use as default where no field prefix is given in the query string + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Specific replication type + + + Query in the Lucene query string syntax + + + Specific routing value + + + The URL-encoded query definition (instead of using the request body) + + + Explicit operation timeout + + + Request parameters for DeleteTemplate + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html
+
+ + + + Request parameters for Exists + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-get.html
+
+ + + + The ID of the parent document + + + Specify the node or shard the operation should be performed on (default: random) + + + Specify whether to perform the operation in realtime or search mode + + + Refresh the shard containing the document before performing the operation + + + Specific routing value + + + Request parameters for Get + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-get.html
+
+ + + + A comma-separated list of fields to return in the response + + + The ID of the parent document + + + Specify the node or shard the operation should be performed on (default: random) + + + Specify whether to perform the operation in realtime or search mode + + + Refresh the shard containing the document before performing the operation + + + Specific routing value + + + True or false to return the _source field or not, or a list of fields to return + + + True or false to return the _source field or not, or a list of fields to return + + + A list of fields to exclude from the returned _source field + + + A list of fields to extract and return from the _source field + + + Explicit version number for concurrency control + + + Specific version type + + + Request parameters for GetSource + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-get.html
+
+ + + + The ID of the parent document + + + Specify the node or shard the operation should be performed on (default: random) + + + Specify whether to perform the operation in realtime or search mode + + + Refresh the shard containing the document before performing the operation + + + Specific routing value + + + True or false to return the _source field or not, or a list of fields to return + + + True or false to return the _source field or not, or a list of fields to return + + + A list of fields to exclude from the returned _source field + + + A list of fields to extract and return from the _source field + + + Explicit version number for concurrency control + + + Specific version type + + + Request parameters for GetTemplate + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html
+
+ + + + Request parameters for Index + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-index_.html
+
+ + + + Explicit write consistency setting for the operation + + + Explicit operation type + + + ID of the parent document + + + Refresh the index after performing the operation + + + Specific replication type + + + Specific routing value + + + Explicit operation timeout + + + Explicit timestamp for the document + + + Expiration time for the document + + + Explicit version number for concurrency control + + + Specific version type + + + Request parameters for IndicesAnalyzeGetForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-analyze.html
+
+ + + + The name of the analyzer to use + + + A comma-separated list of character filters to use for the analysis + + + Use the analyzer configured for this field (instead of passing the analyzer name) + + + A comma-separated list of filters to use for the analysis + + + The name of the index to scope the operation + + + With `true`, specify that a local shard should be used if available, with `false`, use a random shard (default: true) + + + The text on which the analysis should be performed (when request body is not used) + + + The name of the tokenizer to use for the analysis + + + Format of the output + + + Request parameters for IndicesClearCacheForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-clearcache.html
+
+ + + + Clear field data + + + A comma-separated list of fields to clear when using the `field_data` parameter (default: all) + + + Clear filter caches + + + Clear filter caches + + + A comma-separated list of keys to clear when using the `filter_cache` parameter (default: all) + + + Clear ID caches for parent/child + + + Clear ID caches for parent/child + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + A comma-separated list of index name to limit the operation + + + Clear the recycler cache + + + Request parameters for IndicesClose + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-open-close.html
+
+ + + + Explicit operation timeout + + + Specify timeout for connection to master + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Request parameters for IndicesCreate + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-create-index.html
+
+ + + + Explicit operation timeout + + + Specify timeout for connection to master + + + Request parameters for IndicesDelete + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-delete-index.html
+
+ + + + Explicit operation timeout + + + Specify timeout for connection to master + + + Request parameters for IndicesDeleteMapping + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-delete-mapping.html
+
+ + + + Specify timeout for connection to master + + + Request parameters for IndicesDeleteWarmer + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html
+
+ + + + Specify timeout for connection to master + + + Request parameters for IndicesExists + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-settings.html
+
+ + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Return local information, do not retrieve the state from master node (default: false) + + + Request parameters for IndicesFlushForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-flush.html
+
+ + + + 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) + + + 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) + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Request parameters for IndicesGetAliasesForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html
+
+ + + + Explicit operation timeout + + + Return local information, do not retrieve the state from master node (default: false) + + + Request parameters for IndicesGetMappingForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html
+
+ + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Return local information, do not retrieve the state from master node (default: false) + + + Request parameters for IndicesGetSettingsForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html
+
+ + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Return settings in flat format (default: false) + + + Return local information, do not retrieve the state from master node (default: false) + + + Request parameters for IndicesGetWarmerForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html
+
+ + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Return local information, do not retrieve the state from master node (default: false) + + + Request parameters for IndicesOpen + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-open-close.html
+
+ + + + Explicit operation timeout + + + Specify timeout for connection to master + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Request parameters for IndicesOptimizeForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-optimize.html
+
+ + + + + Does an _optimize on all indices (unless bounded by setting the Indices property). + + + + + Does an _optimize on /{index}/_optimize + + + + + Does an _optimize on /{indices}/_optimize + + + + Specify whether the index should be flushed after performing the operation (default: true) + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + The number of segments the index should be merged into (default: dynamic) + + + Specify whether the operation should only expunge deleted documents + + + TODO: ? + + + Specify whether the request should block until the merge process is finished (default: true) + + + Force a merge operation to run, even if there is a single segment in the index (default: false) + + + Request parameters for IndicesPutMapping + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-put-mapping.html
+
+ + + + Specify whether to ignore conflicts while updating the mapping (default: false) + + + Explicit operation timeout + + + Specify timeout for connection to master + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Request parameters for IndicesPutSettingsForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-update-settings.html
+
+ + + + Specify timeout for connection to master + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Return settings in flat format (default: false) + + + Request parameters for IndicesPutTemplateForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html
+
+ + + + Whether the index template should only be added if new or can also replace an existing one + + + Explicit operation timeout + + + Specify timeout for connection to master + + + Return settings in flat format (default: false) + + + Request parameters for IndicesPutWarmerForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html
+
+ + + + Specify timeout for connection to master + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) in the search request to warm + + + 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) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both, in the search request to warm. + + + Request parameters for IndicesRefreshForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-refresh.html
+
+ + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Force a refresh even if not required + + + TODO: ? + + + Request parameters for IndicesSegmentsForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-segments.html
+
+ + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Whether to return time and byte values in human-readable format. + + + TODO: ? + + + Request parameters for IndicesStatsForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-stats.html
+
+ + + + A comma-separated list of fields for `fielddata` and `suggest` index metric (supports wildcards) + + + A comma-separated list of fields for `fielddata` index metric (supports wildcards) + + + A comma-separated list of fields for `fielddata` and `completion` index metric (supports wildcards) + + + A comma-separated list of search groups for `search` index metric + + + Whether to return time and byte values in human-readable format. + + + Return stats aggregated at cluster, index or shard level + + + Request parameters for IndicesStatusForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-status.html
+
+ + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Whether to return time and byte values in human-readable format. + + + TODO: ? + + + Return information about shard recovery + + + TODO: ? + + + Request parameters for IndicesUpdateAliasesForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html
+
+ + + + Request timeout + + + Specify timeout for connection to master + + + Request parameters for IndicesValidateQueryGetForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html
+
+ + + + Return detailed information about the error + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + TODO: ? + + + The URL-encoded query definition (instead of using the request body) + + + Query in the Lucene query string syntax + + + Request parameters for Info + 
+            http://www.elasticsearch.org/guide/
+
+ + + + Request parameters for ListBenchmarks + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-benchmark.html
+
+ + + + Request parameters for MgetGet + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-get.html
+
+ + + + A comma-separated list of fields to return in the response + + + Specify the node or shard the operation should be performed on (default: random) + + + Specify whether to perform the operation in realtime or search mode + + + Refresh the shard containing the document before performing the operation + + + True or false to return the _source field or not, or a list of fields to return + + + True or false to return the _source field or not, or a list of fields to return + + + A list of fields to exclude from the returned _source field + + + A list of fields to extract and return from the _source field + + + Request parameters for MltGet + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-more-like-this.html
+
+ + + + The boost factor + + + The word occurrence frequency as count: words with higher occurrence in the corpus will be ignored + + + The maximum query terms to be included in the generated query + + + The minimum length of the word: longer words will be ignored + + + The word occurrence frequency as count: words with lower occurrence in the corpus will be ignored + + + The term frequency as percent: terms with lower occurence in the source document will be ignored + + + The minimum length of the word: shorter words will be ignored + + + Specific fields to perform the query against + + + How many terms have to match in order to consider the document a match (default: 0.3) + + + Specific routing value + + + The offset from which to return results + + + A comma-separated list of indices to perform the query against (default: the index containing the document) + + + The search query hint + + + A scroll search request definition + + + The number of documents to return (default: 10) + + + A specific search request definition (instead of using the request body) + + + Specific search type (eg. `dfs_then_fetch`, `count`, etc) + + + A comma-separated list of types to perform the query against (default: the same type as the document) + + + A list of stop words to be ignored + + + Request parameters for MsearchGet + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-multi-search.html
+
+ + + + Search operation type + + + Request parameters for MtermvectorsGet + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html
+
+ + + + Specifies if total term frequency and document frequency should be returned. Applies to all returned documents unless otherwise specified in body "params" or "docs". + + + 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 "params" or "docs". + + + A comma-separated list of fields to return. Applies to all returned documents unless otherwise specified in body "params" or "docs". + + + Specifies if term offsets should be returned. Applies to all returned documents unless otherwise specified in body "params" or "docs". + + + Specifies if term positions should be returned. Applies to all returned documents unless otherwise specified in body "params" or "docs". + + + Specifies if term payloads should be returned. Applies to all returned documents unless otherwise specified in body "params" or "docs". + + + Specify the node or shard the operation should be performed on (default: random) .Applies to all returned documents unless otherwise specified in body "params" or "docs". + + + Specific routing value. Applies to all returned documents unless otherwise specified in body "params" or "docs". + + + Parent id of documents. Applies to all returned documents unless otherwise specified in body "params" or "docs". + + + Request parameters for NodesInfoForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-info.html
+
+ + + + Return settings in flat format (default: false) + + + Whether to return time and byte values in human-readable format. + + + Request parameters for NodesStatsForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-stats.html
+
+ + + + A comma-separated list of fields for `fielddata` and `suggest` index metric (supports wildcards) + + + A comma-separated list of fields for `fielddata` index metric (supports wildcards) + + + A comma-separated list of fields for `fielddata` and `completion` index metric (supports wildcards) + + + A comma-separated list of search groups for `search` index metric + + + Whether to return time and byte values in human-readable format. + + + Return indices stats aggregated at node, index or shard level + + + A comma-separated list of document types for the `indexing` index metric + + + Request parameters for PercolateGet + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html
+
+ + + + A comma-separated list of specific routing values + + + Specify the node or shard the operation should be performed on (default: random) + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + The index to percolate the document into. Defaults to index. + + + The type to percolate document into. Defaults to type. + + + Explicit version number for concurrency control + + + Specific version type + + + Request parameters for ScrollGet + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html
+
+ + + + Request parameters for SearchGet + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html
+
+ + + + The analyzer to use for the query string + + + Specify whether wildcard and prefix queries should be analyzed (default: false) + + + The default operator for query string query (AND or OR) + + + The field to use as default where no field prefix is given in the query string + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Specify whether format-based query failures (such as providing text to a numeric field) should be ignored + + + Specify whether query terms should be lowercased + + + Specify the node or shard the operation should be performed on (default: random) + + + A comma-separated list of specific routing values + + + Specify how long a consistent view of the index should be maintained for scrolled search + + + Search operation type + + + Specific 'tag' of the request for logging and statistical purposes + + + Specify which field to use for suggestions + + + Specify suggest mode + + + How many suggestions to return in response + + + The source text for which the suggestions should be returned + + + Request parameters for SnapshotCreate + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html
+
+ + + + Explicit operation timeout for connection to master node + + + Should this request wait until the operation has completed before returning + + + Request parameters for SnapshotCreateRepository + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html
+
+ + + + Explicit operation timeout for connection to master node + + + Explicit operation timeout + + + Request parameters for SnapshotDeleteRepository + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html
+
+ + + + Explicit operation timeout for connection to master node + + + Explicit operation timeout + + + Request parameters for SnapshotGet + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html
+
+ + + + Explicit operation timeout for connection to master node + + + Request parameters for SnapshotRestore + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html
+
+ + + + Explicit operation timeout for connection to master node + + + Should this request wait until the operation has completed before returning + + + Request parameters for Suggest + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html
+
+ + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Specify the node or shard the operation should be performed on (default: random) + + + Specific routing value + + + The URL-encoded request definition (instead of using request body) + + + Request parameters for TermvectorGet + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-termvectors.html
+
+ + + + Specifies if total term frequency and document frequency should be returned. + + + Specifies if document count, sum of document frequencies and sum of total term frequencies should be returned. + + + A comma-separated list of fields to return. + + + Specifies if term offsets should be returned. + + + Specifies if term positions should be returned. + + + Specifies if term payloads should be returned. + + + Specify the node or shard the operation should be performed on (default: random). + + + Specific routing value. + + + Parent id of documents. + + + Request parameters for Update + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-update.html
+
+ + + + Explicit write consistency setting for the operation + + + The script language (default: mvel) + + + ID of the parent document + + + Refresh the index after performing the operation + + + Specific replication type + + + Specify how many times should the operation be retried when a conflict occurs (default: 0) + + + Specific routing value + + + The URL-encoded script definition (instead of using request body) + + + Explicit operation timeout + + + Explicit timestamp for the document + + + Expiration time for the document + + + Explicit version number for concurrency control + + + Specific version type + + + Request parameters for Count + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html
+
+ + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Include only documents with a specific `_score` value in the result + + + Specify the node or shard the operation should be performed on (default: random) + + + Specific routing value + + + The URL-encoded query definition (instead of using the request body) + + + Request parameters for Delete + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-delete.html
+
+ + + + Specific write consistency setting for the operation + + + ID of parent document + + + Refresh the index after performing the operation + + + Specific replication type + + + Specific routing value + + + Explicit operation timeout + + + Explicit version number for concurrency control + + + Specific version type + + + Request parameters for DeleteByQuery + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-delete-by-query.html
+
+ + + + The analyzer to use for the query string + + + Specific write consistency setting for the operation + + + The default operator for query string query (AND or OR) + + + The field to use as default where no field prefix is given in the query string + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Specific replication type + + + Query in the Lucene query string syntax + + + Specific routing value + + + The URL-encoded query definition (instead of using the request body) + + + Explicit operation timeout + + + Request parameters for Exists + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-get.html
+
+ + + + The ID of the parent document + + + Specify the node or shard the operation should be performed on (default: random) + + + Specify whether to perform the operation in realtime or search mode + + + Refresh the shard containing the document before performing the operation + + + Specific routing value + + + Request parameters for Get + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-get.html
+
+ + + + A comma-separated list of fields to return in the response + + + The ID of the parent document + + + Specify the node or shard the operation should be performed on (default: random) + + + Specify whether to perform the operation in realtime or search mode + + + Refresh the shard containing the document before performing the operation + + + Specific routing value + + + True or false to return the _source field or not, or a list of fields to return + + + True or false to return the _source field or not, or a list of fields to return + + + A list of fields to exclude from the returned _source field + + + A list of fields to extract and return from the _source field + + + Explicit version number for concurrency control + + + Specific version type + + + Request parameters for GetSource + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-get.html
+
+ + + + The ID of the parent document + + + Specify the node or shard the operation should be performed on (default: random) + + + Specify whether to perform the operation in realtime or search mode + + + Refresh the shard containing the document before performing the operation + + + Specific routing value + + + True or false to return the _source field or not, or a list of fields to return + + + True or false to return the _source field or not, or a list of fields to return + + + A list of fields to exclude from the returned _source field + + + A list of fields to extract and return from the _source field + + + Explicit version number for concurrency control + + + Specific version type + + + Request parameters for IndicesDeleteMapping + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-delete-mapping.html
+
+ + + + Specify timeout for connection to master + + + Request parameters for IndicesGetMappingForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html
+
+ + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Return local information, do not retrieve the state from master node (default: false) + + + Request parameters for IndicesPutMapping + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-put-mapping.html
+
+ + + + + Calls putmapping on /_all/{type} + + + + + Calls putmapping on /{indices}/{type} + + + + + Calls putmapping on /{index}/{type} + + + + Specify whether to ignore conflicts while updating the mapping (default: false) + + + Explicit operation timeout + + + Specify timeout for connection to master + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Request parameters for IndicesValidateQueryGetForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html
+
+ + + + Return detailed information about the error + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + TODO: ? + + + The URL-encoded query definition (instead of using the request body) + + + Query in the Lucene query string syntax + + + Request parameters for MltGet + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-more-like-this.html
+
+ + + + The boost factor + + + The word occurrence frequency as count: words with higher occurrence in the corpus will be ignored + + + The maximum query terms to be included in the generated query + + + The minimum length of the word: longer words will be ignored + + + The word occurrence frequency as count: words with lower occurrence in the corpus will be ignored + + + The term frequency as percent: terms with lower occurence in the source document will be ignored + + + The minimum length of the word: shorter words will be ignored + + + Specific fields to perform the query against + + + How many terms have to match in order to consider the document a match (default: 0.3) + + + Specific routing value + + + The offset from which to return results + + + A comma-separated list of indices to perform the query against (default: the index containing the document) + + + The search query hint + + + A scroll search request definition + + + The number of documents to return (default: 10) + + + A specific search request definition (instead of using the request body) + + + Specific search type (eg. `dfs_then_fetch`, `count`, etc) + + + A comma-separated list of types to perform the query against (default: the same type as the document) + + + A list of stop words to be ignored + + + Request parameters for SearchGet + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html
+
+ + + + The analyzer to use for the query string + + + Specify whether wildcard and prefix queries should be analyzed (default: false) + + + The default operator for query string query (AND or OR) + + + The field to use as default where no field prefix is given in the query string + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Specify whether format-based query failures (such as providing text to a numeric field) should be ignored + + + Specify whether query terms should be lowercased + + + Specify the node or shard the operation should be performed on (default: random) + + + A comma-separated list of specific routing values + + + Specify how long a consistent view of the index should be maintained for scrolled search + + + Search operation type + + + Specific 'tag' of the request for logging and statistical purposes + + + Specify which field to use for suggestions + + + Specify suggest mode + + + How many suggestions to return in response + + + The source text for which the suggestions should be returned + + + Request parameters for TermvectorGet + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-termvectors.html
+
+ + + + Specifies if total term frequency and document frequency should be returned. + + + Specifies if document count, sum of document frequencies and sum of total term frequencies should be returned. + + + A comma-separated list of fields to return. + + + Specifies if term offsets should be returned. + + + Specifies if term positions should be returned. + + + Specifies if term payloads should be returned. + + + Specify the node or shard the operation should be performed on (default: random). + + + Specific routing value. + + + Parent id of documents. + + + + ElasticClient is NEST's strongly typed client which exposes fully mapped elasticsearch endpoints + + + + + Helper method that allows you to reindex from one index into another using SCAN and SCROLL. + + An IObservable you can subscribe to to listen to the progress of the reindexation process + + + + A search request can be scrolled by specifying the scroll parameter. + The scroll parameter is a time value parameter (for example: scroll=5m), + indicating for how long the nodes that participate in the search will maintain relevant resources in + order to continue and support it. + This is very similar in its idea to opening a cursor against a database. +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-request-scroll.html + + The type that represents the result hits + A descriptor that describes the scroll operation + A query response holding T hits as well as the ScrollId for the next scroll operation + + + + + + + + + + + + + The update API allows to update a document based on a script provided. + The operation gets the document (collocated with the shard) from the index, runs the script + (with optional script language and parameters), and index back the result + (also allows to delete, or ignore the operation). + It uses versioning to make sure no updates have happened during the "get" and "reindex". +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/docs-update.html + + The type to describe the document to be updated + a descriptor that describes the update operation + + + + + + + + + + + + + + + + + + + + + + + + + Change specific index level settings in real time. Note not all index settings CAN be updated. +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/indices-update-settings.html + + A descriptor that strongly types all the updateable settings + + + + + + + + + + + + + The validate API allows a user to validate a potentially expensive query without executing it. +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-validate.html + + The type used to describe the query + A descriptor that describes the query operation + + + + + + + + + + + + + The open and close index APIs allow to close an index, and later on opening it. + A closed index has almost no overhead on the cluster (except for maintaining its metadata), and is blocked + for read/write operations. + A closed index can be opened which will then go through the normal recovery process. +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/indices-open-close.html + + A descriptor thata describes the open index operation + + + + + + + + + + + + + The open and close index APIs allow to close an index, and later on opening it. + A closed index has almost no overhead on the cluster (except for maintaining its metadata), and is blocked + for read/write operations. + A closed index can be opened which will then go through the normal recovery process. +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/indices-open-close.html + + A descriptor thata describes the close index operation + + + + + + + + + + + + + The refresh API allows to explicitly refresh one or more index, making all operations performed since the last refresh + available for search. The (near) real-time capabilities depend on the index engine used. +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/indices-refresh.html + + A descriptor that describes the parameters for the refresh operation + + + + + + + + + + + + + Provide low level segments information that a Lucene index (shard level) is built with. + Allows to be used to provide more information on the state of a shard and an index, possibly optimization information, + data "wasted" on deletes, and so on. +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/indices-segments.html + + A descriptor that describes the parameters for the segments operation + + + + + + + + + + + + + The cluster state API allows to get a comprehensive state information of the whole cluster. +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/cluster-state.html + + A descriptor that describes the parameters for the cluster state operation + + + + + + + + + + + + + Allows to put a warmup search request on a specific index (or indices), with the body composing of a regular + search request. Types can be provided as part of the URI if the search request is designed to be run only + against the specific types. +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/indices-warmers.html#warmer-adding + + The name for the warmer that you want to register + A descriptor that further describes what the warmer should look like + + + + + + + + + + + + + Getting a warmer for specific index (or alias, or several indices) based on its name. +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/indices-warmers.html#warmer-retrieving + + The name of the warmer to get + An optional selector specifying additional parameters for the get warmer operation + + + + + + + + + + + + + Deletes a warmer +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/indices-warmers.html#removing + + The name of the warmer to delete + An optional selector specifying additional parameters for the delete warmer operation + + + + + + + + + + + + + Gets an index template +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/indices-templates.html#getting + + The name of the template to get + An optional selector specifying additional parameters for the get template operation + + + + + + + + + + + + + Index templates allow to define templates that will automatically be applied to new indices created. + The templates include both settings and mappings, and a simple pattern template that controls if + the template will be applied to the index created. +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/indices-templates.html + + The name of the template to register + An optional selector specifying additional parameters for the put template operation + + + + + + + + + + + + + Deletes an index template +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/indices-templates.html#delete + + The name of the template to delete + An optional selector specifying additional parameters for the delete template operation + + + + + + + + + + + + + + + + + + + Unregister a percolator +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-percolate.html + + The name for the percolator + An optional descriptor describing the unregister percolator operation further + + + + + + + + + + + + + Register a percolator +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-percolate.html + + The type to infer the index/type from, will also be used to strongly type the query + The name for the percolator + An optional descriptor describing the register percolator operation further + + + + + + + + + + + + + Percolate a document +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-percolate.html + + The type to infer the index/type from, and of the object that is being percolated + An optional descriptor describing the percolate operation further + + + + + + + + + + + + + Percolate a document but only return the number of matches not the matches itself +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-percolate.html + + The type to infer the index/type from, and of the object that is being percolated + The object to percolator + An optional descriptor describing the percolate operation further + + + + + + + + + + + + + The put mapping API allows to register specific mapping definition for a specific type. +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/indices-put-mapping.html + + The type we want to map in elasticsearch + A descriptor to describe the mapping of our type + + + + + + + + + + + + + The get mapping API allows to retrieve mapping definitions for an index or index/type. +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/indices-get-mapping.html + + A descriptor that describes the parameters for the get mapping operation + + + + + + + + + + + + + Allow to delete a mapping (type) along with its data. +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/indices-delete-mapping.html + + A descriptor that describes the parameters for the delete mapping operation + + + + + + + + + + + + + The flush API allows to flush one or more indices through an API. The flush process of an index basically + frees memory from the index by flushing data to the index storage and clearing the internal transaction log. + By default, Elasticsearch uses memory heuristics in order to automatically trigger + flush operations as required in order to clear memory. +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/indices-flush.html + + A descriptor that describes the parameters for the flush operation + + + + + + + + + + + + + The get settings API allows to retrieve settings of index/indices. +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/indices-get-settings.html + + A descriptor that describes the parameters for the get index settings operation + + + + + + + + + + + + + The delete index API allows to delete an existing index. +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/indices-delete-index.html + + A descriptor that describes the parameters for the delete index operation + + + + + + + + + + + + + The clear cache API allows to clear either all caches or specific cached associated with one ore more indices. +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/indices-clearcache.html + + A descriptor that describes the parameters for the clear cache operation + + + + + + + + + + + + + The create index API allows to instantiate an index. Elasticsearch provides support for multiple indices, + including executing operations across several indices. +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/indices-create-index.html + + A descriptor that describes the parameters for the create index operation + + + + + + + + + + + + + Does a request to the root of an elasticsearch node + + A descriptor to further describe the root operation + + + + + + + + + + + + + Indices level stats provide statistics on different operations happening on an index. The API provides statistics on + the index level scope (though most stats can also be retrieved using node level scope). +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/indices-stats.html + + Optionaly further describe the indices stats operation + + + + + + + + + + + + + The cluster nodes info API allows to retrieve one or more (or all) of the cluster nodes information. +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/cluster-nodes-info.html + + An optional descriptor to further describe the nodes info operation + + + + + + + + + + + + + The cluster nodes stats API allows to retrieve one or more (or all) of the cluster nodes statistics. +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/cluster-nodes-stats.html + + An optional descriptor to further describe the nodes stats operation + + + + + + + + + + + + + An API allowing to get the current hot threads on each node in the cluster. + + + An optional descriptor to further describe the nodes hot threads operation + + + + + + + + + + + + + Allows to shutdown one or more (or all) nodes in the cluster. + http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/cluster-nodes-shutdown.html#cluster-nodes-shutdown + + A descriptor that describes the nodes shutdown operation + + + + + + + + + + + + + Used to check if the index (indices) exists or not. +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/indices-exists.html + + A descriptor that describes the index exist operation + + + + + + + + + + + + + The more like this (mlt) API allows to get documents that are "like" a specified document. +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-more-like-this.html + + Type used to infer the default index and typename and used to describe the search + A descriptor that describes the more like this operation + + + + + + + + + + + + + The cluster health API allows to get a very simple status on the health of the cluster. +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/cluster-health.html + + An optional descriptor to further describe the cluster health operation + + + + + + + + + + + + + allows to retrieve statistics from a cluster wide perspective. The API returns basic index metrics + (shard numbers, store size, memory usage) and information about the current nodes that form the + cluster (number, roles, os, jvm versions, memory usage, cpu and installed plugins). + + A descriptor that describes the cluster stats operation + + + + + + + + + + + + + Performs the analysis process on a text and return the tokens breakdown of the text. +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/indices-analyze.html + + A descriptor that describes the analyze operation + + + + + + + + + + + + + The search API allows to execute a search query and get back search hits that match the query. +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-search.html + + The type used to infer the index and typename as well describe the query strongly typed + A descriptor that describes the parameters for the search operation + + + + + + + + + + + + + The type used to infer the index and typename as well describe the query strongly typed + A descriptor that describes the parameters for the search operation + + + + + + + + + + + + + The /_search/template endpoint allows to use the mustache language to pre render search + requests, before they are executed and fill existing templates with template parameters. + + The type used to infer the index and typename as well describe the query strongly typed + A descriptor that describes the parameters for the search operation + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + The multi search API allows to execute several search requests within the same API. +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-multi-search.html + + A descriptor that describes the search operations on the multi search api + + + + + + + + + + + + + The count API allows to easily execute a query and get the number of matches for that query. + It can be executed across one or more indices and across one or more types. +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-count.html + + The type used to infer the default index and typename as well as describe the strongly + typed parts of the query + An optional descriptor to further describe the count operation + + + + + + + + + + + + + The delete by query API allows to delete documents from one or more indices and one or more types based on a query. +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/docs-delete-by-query.html + + The type used to infer the default index and typename as well as describe the strongly + typed parts of the query + An optional descriptor to further describe the delete by query operation + + + + + + + + + + + + + The bulk API makes it possible to perform many index/delete operations in a single API call. + This can greatly increase the indexing speed. +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/docs-bulk.html + + A descriptor the describe the index/create/delete operation for this bulk operation + + + + + + + + + + + + + The index API adds or updates a typed JSON document in a specific index, making it searchable. +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/docs-index_.html + + The type used to infer the default index and typename + The object to be indexed, Id will be inferred (Id property or IdProperty attribute on type) + Optionally furter describe the index operation i.e override type/index/id + + + + + + + + + + + + + The delete API allows to delete a typed JSON document from a specific index based on its id. +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/docs-delete.html + + The type used to infer the default index and typename + Describe the delete operation, i.e type/index/id + + + + + + + + + + + + + Multi GET API allows to get multiple documents based on an index, type (optional) and id (and possibly routing). + The response includes a docs array with all the fetched documents, each element similar in structure to a document + provided by the get API. +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/docs-multi-get.html + + A descriptor describing which documents should be fetched + + + + + + + + + + + + + Use the /{index}/{type}/{id}/_source endpoint to get just the _source field of the document, + without any additional content around it. +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/docs-get.html#_source + + The type used to infer the default index and typename + A descriptor that describes which document's source to fetch + + + + + + + + + + + + + Use the /{index}/{type}/{id} to get the document and its metadata +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/docs-get.html#_source + + The type used to infer the default index and typename + A descriptor that describes which document's source to fetch + + + + + + + + + + + + + APIs in elasticsearch accept an index name when working against a specific index, and several indices when applicable. + The index aliases API allow to alias an index with a name, with all APIs automatically converting the alias name to the + actual index name. An alias can also be mapped to more than one index, and when specifying it, the alias + will automatically expand to the aliases indices.i An alias can also be associated with a filter that will + automatically be applied when searching, and routing values. +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/indices-aliases.html + + A desriptor that describes the parameters for the alias operation + + + + + + + + + + + + + The get index alias api allows to filter by alias name and index name. This api redirects to the master and fetches + the requested index aliases, if available. This api only serialises the found index aliases. + Difference with GetAlias is that this call will also return indices without aliases set +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/indices-aliases.html#alias-retrieving + + A descriptor that describes which aliases/indexes we are interested int + + + + + + + + + + + + + The get index alias api allows to filter by alias name and index name. This api redirects to the master and fetches + the requested index aliases, if available. This api only serialises the found index aliases. +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/indices-aliases.html#alias-retrieving + + A descriptor that describes which aliases/indexes we are interested int + + + + + + + + + + + + + Add a single index alias + http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/indices-aliases.html#alias-adding + + A descriptor that describes the put alias request + + + + + + + + + + + + + Delete an index alias + http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/indices-aliases.html#deleting + + A descriptor that describes the delete alias request + + + + + + + + + + + + + The optimize API allows to optimize one or more indices through an API. The optimize process basically optimizes + the index for faster search operations (and relates to the number of segments a Lucene index holds within each shard). + The optimize operation allows to reduce the number of segments by merging them. +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/indices-optimize.html + + An optional descriptor that further describes the optimize operation, i.e limit it to one index + + + + + + + + + + + + + The indices status API allows to get a comprehensive status information of one or more indices. +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/indices-status.html + + An optional descriptor that further describes the status operation, i.e limiting it to certain indices + + + + + + + + + + + + + Returns information and statistics on terms in the fields of a particular document as stored in the index. +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/docs-termvectors.html + + + + + + + + + + + + + + + + Multi termvectors API allows to get multiple termvectors based on an index, type and id. + http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/docs-multi-termvectors.html + + The type used to infer the default index and typename + The descriptor describing the multi termvectors operation + + + + + + + + + + + + + The suggest feature suggests similar looking terms based on a provided text by using a suggester. +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-suggesters.html + + The type used to strongly type parts of the suggest operation + The suggesters to use this operation (can be multiple) + + + + + + + + + + + + + Deletes a registered scroll request on the cluster +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-request-scroll.html + + Specify the scroll id as well as request specific configuration + + + + + + + + + + + + + Check if a document exists without returning its contents +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/docs-get.html + + The type used to infer the default index and typename + Describe what document we are looking for + + + + + + + + + + + + + Before any snapshot or restore operation can be performed a snapshot repository should be registered in Elasticsearch. +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/modules-snapshots.html#_repositories + + The name for the repository + describe what the repository looks like + + + + + + + + + + + + + Delete a repository, if you have ongoing restore operations be sure to delete the indices being restored into first. +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/modules-snapshots.html#_repositories + + The name of the repository + Optionaly provide the delete operation with more details> + + + + + + + + + + + + + A repository can contain multiple snapshots of the same cluster. Snapshot are identified by unique names within the cluster. + ///  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/modules-snapshots.html#_snapshot + + The name of the repository we want to create a snapshot in + The name of the snapshot + Optionally provide more details about the snapshot operation + + + + + + + + + + + + + Delete a snapshot +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/modules-snapshots.html#_snapshot + + The repository name under which the snapshot we want to delete lives + The name of the snapshot that we want to delete + Optionally further describe the delete snapshot operation + + + + + + + + + + + + + Gets information about one or more snapshots +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/modules-snapshots.html#_snapshot + + The repository name under which the snapshots live + The names of the snapshots we want information from (can be _all or wildcards) + Optionally further describe the get snapshot operation + + + + + + + + + + + + + Restore a snapshot +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/modules-snapshots.html#_restore + + The repository name that holds our snapshot + The name of the snapshot that we want to restore + Optionally further describe the restore operation + + + + + + + + + + + + + Allows to update cluster wide specific settings. Settings updated can either be persistent + (applied cross restarts) or transient (will not survive a full cluster restart). +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/cluster-update-settings.html + + + + + + + + + + + + + + Gets cluster wide specific settings. Settings updated can either be persistent + (applied cross restarts) or transient (will not survive a full cluster restart). +  http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/cluster-update-settings.html + + + + + + + + + + + + + + Returns a list of any cluster-level changes (e.g. create index, update mapping, allocate or fail shard) which have not yet been executed. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Executes a HEAD request to the cluster to determine whether it's up or not. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Perform any request you want over the configured IConnection synchronously while taking advantage of the cluster failover. + + The type representing the response JSON + the HTTP Method to use + The path of the the url that you would like to hit + The body of the request, string and byte[] are posted as is other types will be serialized to JSON + Optionally configure request specific timeouts, headers + An ElasticsearchResponse of T where T represents the JSON response body + + + + Perform any request you want over the configured IConnection asynchronously while taking advantage of the cluster failover. + + The type representing the response JSON + the HTTP Method to use + The path of the the url that you would like to hit + The body of the request, string and byte[] are posted as is other types will be serialized to JSON + Optionally configure request specific timeouts, headers + A task of ElasticsearchResponse of T where T represents the JSON response body + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Perform any request you want over the configured IConnection while taking advantage of the cluster failover. + + The type representing the response JSON + the HTTP Method to use + The path of the the url that you would like to hit + The body of the request, string and byte[] are posted as is other types will be serialized to JSON + Optionally configure request specific timeouts, headers + An ElasticsearchResponse of T where T represents the JSON response body + + + + Perform any request you want over the configured IConnection asynchronously while taking advantage of the cluster failover. + + The type representing the response JSON + the HTTP Method to use + The path of the the url that you would like to hit + The body of the request, string and byte[] are posted as is other types will be serialized to JSON + Optionally configure request specific timeouts, headers + A task of ElasticsearchResponse of T where T represents the JSON response body + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Because the nodes.hot_threads endpoint returns plain text instead of JSON, we have to + manually parse the response text into a typed response object. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Instantiate a new strongly typed connection to elasticsearch + + An optional settings object telling the client how and where to connect to. + Defaults to a static single node connection pool to http://localhost:9200 + It's recommended to pass an explicit 'new ConnectionSettings()' instance + + Optionally provide a different connection handler, defaults to http using HttpWebRequest + Optionally provide a custom serializer responsible for taking a stream and turning into T + The transport coordinates requests between the client and the connection pool and the connection + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Deserialize an object + + The type you want to deserialize too + The stream to deserialize off + + + + Deserialize to type T bypassing checks for custom deserialization state and or BaseResponse return types. + + + + + _msearch needs a specialized json format in the body + + + + descriptor for SnapshotGet + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html
+
+ + + + Explicit operation timeout for connection to master node + + + descriptor for MtermvectorsGet + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html
+
+ + + + + Provides a base for descriptors that need to describe a path in the form of + 
+            /{index}/{type}
+
+ Where neither parameter is optional + + + + Specifies if total term frequency and document frequency should be returned. Applies to all returned documents unless otherwise specified in body "params" or "docs". + + + 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 "params" or "docs". + + + A comma-separated list of fields to return. Applies to all returned documents unless otherwise specified in body "params" or "docs". + + + A comma-separated list of fields to return. Applies to all returned documents unless otherwise specified in body "params" or "docs". + + + Specifies if term offsets should be returned. Applies to all returned documents unless otherwise specified in body "params" or "docs". + + + Specifies if term positions should be returned. Applies to all returned documents unless otherwise specified in body "params" or "docs". + + + Specifies if term payloads should be returned. Applies to all returned documents unless otherwise specified in body "params" or "docs". + + + Specify the node or shard the operation should be performed on (default: random) .Applies to all returned documents unless otherwise specified in body "params" or "docs". + + + Specific routing value. Applies to all returned documents unless otherwise specified in body "params" or "docs". + + + Parent id of documents. Applies to all returned documents unless otherwise specified in body "params" or "docs". + + + descriptor for SnapshotRestore + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html
+
+ + + + Explicit operation timeout for connection to master node + + + Should this request wait until the operation has completed before returning + + + descriptor for SnapshotCreate + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html
+
+ + + + Explicit operation timeout for connection to master node + + + Should this request wait until the operation has completed before returning + + + descriptor for SnapshotDeleteRepository + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html
+
+ + + + + Provides a base for descriptors that need to describe a path that contains a + 
+            {repository}
+
+ routing value + + + + + Specify the name of the repository we are targeting + + + + Explicit operation timeout for connection to master node + + + Explicit operation timeout + + + + optional - Hadoop file-system URI + + + + + required - path with the file-system where data is stored/loaded + + + + + whether to load the default Hadoop configuration (default) or not + + + + + + Hadoop configuration XML to be loaded (use commas for multi values) + + + + + + 'inlined' key=value added to the Hadoop configuration + + + + + + + When set to true metadata files are stored in compressed format. This setting doesn't + affect index files that are already compressed by default. Defaults to false. + + + + + + Throttles the number of streams (per node) preforming snapshot operation. Defaults to 5 + + + + + + Big files can be broken down into chunks during snapshotting if needed. + The chunk size can be specified in bytes or by using size value notation, + i.e. 1g, 10m, 5k. Disabled by default + + + + + + Container name. Defaults to elasticsearch-snapshots + + + + + + Specifies the path within container to repository data. Defaults to empty (root directory). + + + + + + + When set to true metadata files are stored in compressed format. This setting doesn't + affect index files that are already compressed by default. Defaults to false. + + + + + + Throttles the number of streams (per node) preforming snapshot operation. Defaults to 5 + + + + + + Big files can be broken down into chunks during snapshotting if needed. + The chunk size can be specified in bytes or by using size value notation, + i.e. 1g, 10m, 5k. Defaults to 64m (64m max) + + + + + + The name of the bucket to be used for snapshots. (Mandatory) + + + + + + The region where bucket is located. Defaults to US Standard + + + + + + + Specifies the path within bucket to repository data. Defaults to root directory. + + + + + + + The access key to use for authentication. Defaults to value of cloud.aws.access_key. + + + + + + + The secret key to use for authentication. Defaults to value of cloud.aws.secret_key. + + + + + + + When set to true metadata files are stored in compressed format. This setting doesn't + affect index files that are already compressed by default. Defaults to false. + + + + + + Throttles the number of streams (per node) preforming snapshot operation. Defaults to 5 + + + + + + Big files can be broken down into chunks during snapshotting if needed. + The chunk size can be specified in bytes or by using size value notation, + i.e. 1g, 10m, 5k. Defaults to 100m. + + + + + + Location of the snapshots. Mandatory. + + + + + + Turns on compression of the snapshot files. Defaults to true. + + + + + + Throttles the number of streams (per node) preforming snapshot operation. Defaults to 5 + + + + + + Big files can be broken down into chunks during snapshotting if needed. + The chunk size can be specified in bytes or by using size value notation, i.e. 1g, 10m, 5k. + Defaults to null (unlimited chunk size). + + + + + + Throttles per node restore rate. Defaults to 20mb per second. + + + + + + Throttles per node snapshot rate. Defaults to 20mb per second. + + + + + + Location of the snapshots. Mandatory. + + + + + + Throttles the number of streams (per node) preforming snapshot operation. Defaults to 5 + + + + + A comma-separated list of fields to return the fielddata size + + + A comma-separated list of fields to return in the response + + + A list of fields to exclude from the returned _source field + + + A list of fields to extract and return from the _source field + + + A comma-separated list of fields to return in the response + + + A list of fields to exclude from the returned _source field + + + A list of fields to extract and return from the _source field + + + A list of fields to exclude from the returned _source field + + + A list of fields to extract and return from the _source field + + + Use the analyzer configured for this field (instead of passing the analyzer name) + + + A comma-separated list of fields to clear when using the `field_data` parameter (default: all) + + + A comma-separated list of fields for `fielddata` and `suggest` index metric (supports wildcards) + + + A comma-separated list of fields for `fielddata` index metric (supports wildcards) + + + A comma-separated list of fields for `fielddata` and `completion` index metric (supports wildcards) + + + A comma-separated list of fields to return in the response + + + A list of fields to exclude from the returned _source field + + + A list of fields to extract and return from the _source field + + + Specific fields to perform the query against + + + A comma-separated list of fields to return. Applies to all returned documents unless otherwise specified in body "params" or "docs". + + + A comma-separated list of fields for `fielddata` and `suggest` index metric (supports wildcards) + + + A comma-separated list of fields for `fielddata` index metric (supports wildcards) + + + A comma-separated list of fields for `fielddata` and `completion` index metric (supports wildcards) + + + Specify which field to use for suggestions + + + A comma-separated list of fields to return. + + + descriptor for ClearScroll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html
+
+ + + + + Specify the {name} part of the operation + + + + descriptor for SnapshotCreateRepository + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html
+
+ + + + + The shared file system repository ("type": "fs") is using shared file system to store snapshot. + The path specified in the location parameter should point to the same location in the shared + filesystem and be accessible on all data and master nodes. + + + + + + + The URL repository ("type": "url") can be used as an alternative read-only way to access data + created by shared file system repository is using shared file system to store snapshot. + + + + + + + Specify an azure storage container to snapshot and restore to. (defaults to a container named elasticsearch-snapshots) + + + + + Create an snapshot/restore repository that points to an HDFS filesystem + + + + + + + Register a custom repository + + + + Explicit operation timeout for connection to master node + + + Explicit operation timeout + + + descriptor for Index + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-index_.html
+
+ + + + Explicit write consistency setting for the operation + + + Explicit operation type + + + ID of the parent document + + + Refresh the index after performing the operation + + + Specific replication type + + + Specific routing value + + + Explicit operation timeout + + + Explicit timestamp for the document + + + Expiration time for the document + + + Explicit version number for concurrency control + + + Specific version type + + + descriptor for CountPercolateGet + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html
+
+ + + + + The object to perculate + + + + + The object to perculate + + + + + The object to perculate + + + + + The object to perculate + + + + + Make sure we keep calculating score even if we are sorting on a field. + + + + + Allows to add one or more sort on specific fields. Each sort can be reversed as well. + The sort is defined on a per field level, with special field name for _score to sort by score. + + + Sort ascending. + + + + + + Allows to add one or more sort on specific fields. Each sort can be reversed as well. + The sort is defined on a per field level, with special field name for _score to sort by score. + + + Sort descending. + + + + + + Allows to add one or more sort on specific fields. Each sort can be reversed as well. + The sort is defined on a per field level, with special field name for _score to sort by score. + + + Sort ascending. + + + + + + Allows to add one or more sort on specific fields. Each sort can be reversed as well. + The sort is defined on a per field level, with special field name for _score to sort by score. + + + Sort descending. + + + + + + Sort() allows you to fully describe your sort unlike the SortAscending and SortDescending aliases. + + + + + + SortGeoDistance() allows you to sort by a distance from a geo point. + + + + + + SortScript() allows you to sort by a distance from a geo point. + + + + + + Describe the query to perform using a query descriptor lambda + + + + + Shortcut to .Query(q=>q.QueryString(qs=>qs.Query("string")) + Does a match_all if the userInput string is null or empty; + + + + + Filter search using a filter descriptor lambda + + + + + Filter search + + + + A comma-separated list of specific routing values + + + Specify the node or shard the operation should be performed on (default: random) + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + The index to count percolate the document into. Defaults to index. + + + The type to count percolate document into. Defaults to type. + + + Explicit version number for concurrency control + + + Specific version type + + + descriptor for Suggest + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html
+
+ + + + + Provides a base for descriptors that need to describe a path in the form of + 
+            /{indices}
+
+ {indices} is optional but AllIndices() needs to be explicitly called. + + + + + To avoid repetition of the suggest text, it is possible to define a global text. + + + + + The term suggester suggests terms based on edit distance. The provided suggest text is analyzed before terms are suggested. + The suggested terms are provided per analyzed suggest text token. The term suggester doesn’t take the query into account that is part of request. + + + + + The phrase suggester adds additional logic on top of the term suggester to select entire corrected phrases + instead of individual tokens weighted based on ngram-langugage models. + + + + + The completion suggester is a so-called prefix suggester. + It does not do spell correction like the term or phrase suggesters but allows basic auto-complete functionality. + + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Specify the node or shard the operation should be performed on (default: random) + + + Specific routing value + + + The URL-encoded request definition (instead of using request body) + + + descriptor for IndicesClose + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-open-close.html
+
+ + + + + Provides a base for descriptors that need to describe a path in the form of + 
+            /{index}
+
+ index is not optional + + + + Explicit operation timeout + + + Specify timeout for connection to master + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + descriptor for ClusterState + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-state.html
+
+ + + + Return local information, do not retrieve the state from master node (default: false) + + + Specify timeout for connection to master + + + Return settings in flat format (default: false) + + + descriptor for IndicesClearCacheForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-clearcache.html
+
+ + + + Clear field data + + + A comma-separated list of fields to clear when using the `field_data` parameter (default: all) + + + A comma-separated list of fields to clear when using the `field_data` parameter (default: all) + + + Clear filter caches + + + Clear filter caches + + + A comma-separated list of keys to clear when using the `filter_cache` parameter (default: all) + + + Clear ID caches for parent/child + + + Clear ID caches for parent/child + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + A comma-separated list of index name to limit the operation + + + Clear the recycler cache + + + descriptor for GetSource + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-get.html
+
+ + + + The ID of the parent document + + + Specify the node or shard the operation should be performed on (default: random) + + + Specify whether to perform the operation in realtime or search mode + + + Refresh the shard containing the document before performing the operation + + + Specific routing value + + + True or false to return the _source field or not, or a list of fields to return + + + True or false to return the _source field or not, or a list of fields to return + + + A list of fields to exclude from the returned _source field + + + A list of fields to exclude from the returned _source field + + + A list of fields to extract and return from the _source field + + + A list of fields to extract and return from the _source field + + + Explicit version number for concurrency control + + + Specific version type + + + descriptor for NodesStatsForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-stats.html
+
+ + + + A comma-separated list of fields for `fielddata` and `suggest` index metric (supports wildcards) + + + A comma-separated list of fields for `fielddata` and `suggest` index metric (supports wildcards) + + + A comma-separated list of fields for `fielddata` index metric (supports wildcards) + + + A comma-separated list of fields for `fielddata` index metric (supports wildcards) + + + A comma-separated list of fields for `fielddata` and `completion` index metric (supports wildcards) + + + A comma-separated list of fields for `fielddata` and `completion` index metric (supports wildcards) + + + A comma-separated list of search groups for `search` index metric + + + Whether to return time and byte values in human-readable format. + + + Return indices stats aggregated at node, index or shard level + + + A comma-separated list of document types for the `indexing` index metric + + + descriptor for NodesInfoForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-info.html
+
+ + + + Return settings in flat format (default: false) + + + Whether to return time and byte values in human-readable format. + + + descriptor for ClusterHealth + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-health.html
+
+ + + + Specify the level of detail for returned information + + + Return local information, do not retrieve the state from master node (default: false) + + + Explicit operation timeout for connection to master node + + + Explicit operation timeout + + + Wait until the specified number of shards is active + + + Wait until the specified number of nodes is available + + + Wait until the specified number of relocating shards is finished + + + Wait until cluster is in a specific state + + + descriptor for IndicesAnalyzeGetForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-analyze.html
+
+ + + + The name of the analyzer to use + + + A comma-separated list of character filters to use for the analysis + + + Use the analyzer configured for this field (instead of passing the analyzer name) + + + Use the analyzer configured for this field (instead of passing the analyzer name) + + + A comma-separated list of filters to use for the analysis + + + The name of the index to scope the operation + + + With `true`, specify that a local shard should be used if available, with `false`, use a random shard (default: true) + + + The text on which the analysis should be performed (when request body is not used) + + + The name of the tokenizer to use for the analysis + + + Format of the output + + + descriptor for IndicesUpdateAliasesForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html
+
+ + + + Request timeout + + + Specify timeout for connection to master + + + descriptor for IndicesStatusForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-status.html
+
+ + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Whether to return time and byte values in human-readable format. + + + TODO: ? + + + Return information about shard recovery + + + TODO: ? + + + descriptor for IndicesGetAliasesForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html
+
+ + + + Explicit operation timeout + + + Return local information, do not retrieve the state from master node (default: false) + + + descriptor for Delete + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-delete.html
+
+ + + + Specific write consistency setting for the operation + + + ID of parent document + + + Refresh the index after performing the operation + + + Specific replication type + + + Specific routing value + + + Explicit operation timeout + + + Explicit version number for concurrency control + + + Specific version type + + + descriptor for Exists + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-get.html
+
+ + + + The ID of the parent document + + + Specify the node or shard the operation should be performed on (default: random) + + + Specify whether to perform the operation in realtime or search mode + + + Refresh the shard containing the document before performing the operation + + + Specific routing value + + + descriptor for Count + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html
+
+ + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Include only documents with a specific `_score` value in the result + + + Specify the node or shard the operation should be performed on (default: random) + + + Specific routing value + + + The URL-encoded query definition (instead of using the request body) + + + descriptor for IndicesExists + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-settings.html
+
+ + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Return local information, do not retrieve the state from master node (default: false) + + + descriptor for IndicesStatsForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-stats.html
+
+ + + + A comma-separated list of fields for `fielddata` and `suggest` index metric (supports wildcards) + + + A comma-separated list of fields for `fielddata` and `suggest` index metric (supports wildcards) + + + A comma-separated list of fields for `fielddata` index metric (supports wildcards) + + + A comma-separated list of fields for `fielddata` index metric (supports wildcards) + + + A comma-separated list of fields for `fielddata` and `completion` index metric (supports wildcards) + + + A comma-separated list of fields for `fielddata` and `completion` index metric (supports wildcards) + + + A comma-separated list of search groups for `search` index metric + + + Whether to return time and byte values in human-readable format. + + + Return stats aggregated at cluster, index or shard level + + + descriptor for Info + 
+            http://www.elasticsearch.org/guide/
+
+ + + + descriptor for IndicesGetSettingsForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html
+
+ + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Return settings in flat format (default: false) + + + Return local information, do not retrieve the state from master node (default: false) + + + descriptor for IndicesDelete + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-delete-index.html
+
+ + + + Explicit operation timeout + + + Specify timeout for connection to master + + + descriptor for IndicesFlushForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-flush.html
+
+ + + + 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) + + + 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) + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + descriptor for IndicesDeleteMapping + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-delete-mapping.html
+
+ + + + Specify timeout for connection to master + + + descriptor for IndicesGetMappingForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html
+
+ + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Return local information, do not retrieve the state from master node (default: false) + + + + Provides a base for descriptors that need to describe a path in the form of + 
+            /{indices}/{type}
+
+ {indices} is optional and so is {type} and will fallback to default of T + + + + descriptor for TermvectorGet + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-termvectors.html
+
+ + + + Specifies if total term frequency and document frequency should be returned. + + + Specifies if document count, sum of document frequencies and sum of total term frequencies should be returned. + + + A comma-separated list of fields to return. + + + A comma-separated list of fields to return. + + + Specifies if term offsets should be returned. + + + Specifies if term positions should be returned. + + + Specifies if term payloads should be returned. + + + Specify the node or shard the operation should be performed on (default: random). + + + Specific routing value. + + + Parent id of documents. + + + descriptor for DeleteTemplate + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html
+
+ + + + descriptor for GetTemplate + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html
+
+ + + + descriptor for IndicesDeleteWarmer + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html
+
+ + + + Specify timeout for connection to master + + + descriptor for IndicesSegmentsForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-segments.html
+
+ + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Whether to return time and byte values in human-readable format. + + + TODO: ? + + + descriptor for IndicesRefreshForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-refresh.html
+
+ + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Force a refresh even if not required + + + TODO: ? + + + descriptor for IndicesOptimizeForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-optimize.html
+
+ + + + Specify whether the index should be flushed after performing the operation (default: true) + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + The number of segments the index should be merged into (default: dynamic) + + + Specify whether the operation should only expunge deleted documents + + + TODO: ? + + + Specify whether the request should block until the merge process is finished (default: true) + + + Force a merge operation to run, even if there is a single segment in the index (default: false) + + + descriptor for IndicesOpen + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-open-close.html
+
+ + + + Explicit operation timeout + + + Specify timeout for connection to master + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + descriptor for ScrollGet + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html
+
+ + + + Specify how long a consistent view of the index should be maintained for scrolled search + + + The scroll id used to continue/start the scrolled pagination + + + descriptor for IndicesPutSettingsForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-update-settings.html
+
+ + + + + Provides a base for descriptors that need to describe a path in the form of + 
+            /{index}
+
+ index is optional but AllIndices() needs to be explicitly specified for it to be optional + + + + + The number of replicas each shard has. + + + + + Set to an actual value (like 0-all) or false to disable it. + + + + + Set to true to have the index read only, false to allow writes and metadta changes. + + + + + Set to true to disable read operations againstthe index. + + + + + Set to true to disable write operations against the index. + + + + + Set to true to disable metadata operations against the index. + + + + + The async refresh interval of a shard. + + + + + Defaults to 8. + + + + + Codec. Default to default. + + + + + Whether to load the bloom filter. Defaults to true. + [coming in 0.90.9] Coming in 0.90.9.. See the section called “Bloom filter posting format”. + + + + + Default to true. + + + + + When to flush based on operations. + + + + + When to flush based on translog (bytes) size. + + + + + When to flush based on a period of not flushing. + + + + + Disables flushing. Note, should be set for a short interval and then enabled. + + + + + The maximum size of filter cache (per segment in shard). Set to -1 to disable. + + + + + The expire after access time for filter cache. Set to -1 to disable. + + + + + The gateway snapshot interval (only applies to shared gateways). Defaults to 10s. + + + + + A node matching any rule will be allowed to host shards from the index. + + + + + A node matching any rule will NOT be allowed to host shards from the index. + + + + + Only nodes matching all rules will be allowed to host shards from the index. + + + + + Enables shard allocation for a specific index. + + + + + Disable allocation. Defaults to false. + + + + + Disable new allocation. Defaults to false. + + + + + Disable replica allocation. Defaults to false. + + + + + Controls the total number of shards allowed to be allocated on a single node. Defaults to unbounded (-1). + + + + + When using local gateway a particular shard is recovered only if there can be allocated quorum shards in the cluster. + It can be set to: + quorum (default) + quorum-1 (or half) + full + full-1. + Number values are also supported, e.g. 1. + + + + + Disables temporarily the purge of expired docs. + + + + + Disables temporarily the purge of expired docs. + + + + + Either simple or buffered (default). + + + + + See index.compound_format in the section called “Index Settings”. + + + + + See `index.compound_on_flush in the section called “Index Settings”. + + + + + See Warmers. Defaults to true. + + + + + When updating analysis settings you need to close and open the index prior and afterwards + + + + Specify timeout for connection to master + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Return settings in flat format (default: false) + + + descriptor for DeleteByQuery + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-delete-by-query.html
+
+ + + + The analyzer to use for the query string + + + Specific write consistency setting for the operation + + + The default operator for query string query (AND or OR) + + + The field to use as default where no field prefix is given in the query string + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Specific replication type + + + Query in the Lucene query string syntax + + + Specific routing value + + + The URL-encoded query definition (instead of using the request body) + + + Explicit operation timeout + + + + when rest.action.multi.allow_explicit_index is set to false you can use this constructor to generate a multiget operation + with no index and type set + 
+            See also: https://github.com/elasticsearch/elasticsearch/issues/3636
+
+ + + + + + Manually set the index, default to the default index or the index set for the type on the connectionsettings. + + + + + Manualy set the type to get the object from, default to whatever + T will be inferred to if not passed. + + + + + Manually set the type of which a typename will be inferred + + + + + Control how the document's source is loaded + + + + + Control how the document's source is loaded + + + + + Set the routing for the get operation + + + + + Allows to selectively load specific fields for each document + represented by a search hit. Defaults to load the internal _source field. + + + + + Allows to selectively load specific fields for each document + represented by a search hit. Defaults to load the internal _source field. + + + + descriptor for AbortBenchmark + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-benchmark.html
+
+ + + + descriptor for Bulk + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-bulk.html
+
+ + + + Explicit write consistency setting for the operation + + + Refresh the index after performing the operation + + + Explicitely set the replication type + + + Specific routing value + + + Explicit operation timeout + + + Default document type for items which don't provide one + + + + CreateMany, convenience method to create many documents at once. + + the objects to create + A func called on each object to describe the individual create operation + + + + IndexMany, convenience method to pass many objects at once. + + the objects to index + A func called on each object to describe the individual index operation + + + + DeleteMany, convenience method to delete many objects at once. + + the objects to delete + A func called on each object to describe the individual delete operation + + + + DeleteMany, convenience method to delete many objects at once. + + Enumerable of string ids to delete + A func called on each ids to describe the individual delete operation + + + + DeleteMany, convenience method to delete many objects at once. + + Enumerable of int ids to delete + A func called on each ids to describe the individual delete operation + + + descriptor for CatHelp + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat.html
+
+ + + + Return help information + + + descriptor for ClusterReroute + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-reroute.html
+
+ + + + Simulate the operation only and return the resulting state + + + Return an explanation of why the commands can or cannot be executed + + + Don't return cluster state metadata (default: false) + + + Explicit operation timeout for connection to master node + + + Explicit operation timeout + + + descriptor for Get + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-get.html
+
+ + + + A comma-separated list of fields to return in the response + + + A comma-separated list of fields to return in the response + + + The ID of the parent document + + + Specify the node or shard the operation should be performed on (default: random) + + + Specify whether to perform the operation in realtime or search mode + + + Refresh the shard containing the document before performing the operation + + + Specific routing value + + + True or false to return the _source field or not, or a list of fields to return + + + True or false to return the _source field or not, or a list of fields to return + + + A list of fields to exclude from the returned _source field + + + A list of fields to exclude from the returned _source field + + + A list of fields to extract and return from the _source field + + + A list of fields to extract and return from the _source field + + + Explicit version number for concurrency control + + + Specific version type + + + descriptor for IndicesCreate + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-create-index.html
+
+ + + + Explicit operation timeout + + + Specify timeout for connection to master + + + + Initialize the descriptor using the values from for instance a previous Get Index Settings call. + + + + + Set the number of shards (if possible) for the new index. + + + + + + + Set the number of replicas (if possible) for the new index. + + + + + + + Set/Update settings, the index.* prefix is not needed for the keys. + + + + + Remove an existing mapping by name + + + + + Remove an exisiting mapping by inferred type name + + + + + Add an alias for this index upon index creation + + + + + Add a new mapping for T + + + + + Add a new mapping using the first rootObjectMapping parameter as the base to construct the new mapping. + Handy if you wish to reuse a mapping. + + + + + Set up analysis tokenizers, filters, analyzers + + + + descriptor for IndicesGetWarmerForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html
+
+ + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Return local information, do not retrieve the state from master node (default: false) + + + descriptor for IndicesPutMapping + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-put-mapping.html
+
+ + + + Specify whether to ignore conflicts while updating the mapping (default: false) + + + Explicit operation timeout + + + Specify timeout for connection to master + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + + Convenience method to map from most of the object from the attributes/properties. + Later calls can override whatever is set is by this call. + This helps mapping all the ints as ints, floats as floats etcetera withouth having to be overly verbose in your fluent mapping + + + + + descriptor for IndicesPutTemplateForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html
+
+ + + + Whether the index template should only be added if new or can also replace an existing one + + + Explicit operation timeout + + + Specify timeout for connection to master + + + Return settings in flat format (default: false) + + + + Initialize the descriptor using the values from for instance a previous Get Template Mapping call. + + + + descriptor for IndicesPutWarmerForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html
+
+ + + + Specify timeout for connection to master + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) in the search request to warm + + + 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) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both, in the search request to warm. + + + descriptor for IndicesValidateQueryGetForAll + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html
+
+ + + + Return detailed information about the error + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + TODO: ? + + + The URL-encoded query definition (instead of using the request body) + + + Query in the Lucene query string syntax + + + descriptor for ListBenchmarks + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-benchmark.html
+
+ + + + descriptor for MgetGet + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-get.html
+
+ + + + A comma-separated list of fields to return in the response + + + A comma-separated list of fields to return in the response + + + Specify the node or shard the operation should be performed on (default: random) + + + Specify whether to perform the operation in realtime or search mode + + + Refresh the shard containing the document before performing the operation + + + True or false to return the _source field or not, or a list of fields to return + + + True or false to return the _source field or not, or a list of fields to return + + + A list of fields to exclude from the returned _source field + + + A list of fields to exclude from the returned _source field + + + A list of fields to extract and return from the _source field + + + A list of fields to extract and return from the _source field + + + descriptor for MltGet + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-more-like-this.html
+
+ + + + The boost factor + + + The word occurrence frequency as count: words with higher occurrence in the corpus will be ignored + + + The maximum query terms to be included in the generated query + + + The minimum length of the word: longer words will be ignored + + + The word occurrence frequency as count: words with lower occurrence in the corpus will be ignored + + + The term frequency as percent: terms with lower occurence in the source document will be ignored + + + The minimum length of the word: shorter words will be ignored + + + Specific fields to perform the query against + + + Specific fields to perform the query against + + + How many terms have to match in order to consider the document a match (default: 0.3) + + + Specific routing value + + + The offset from which to return results + + + A comma-separated list of indices to perform the query against (default: the index containing the document) + + + The search query hint + + + A scroll search request definition + + + The number of documents to return (default: 10) + + + A specific search request definition (instead of using the request body) + + + Specific search type (eg. `dfs_then_fetch`, `count`, etc) + + + A comma-separated list of types to perform the query against (default: the same type as the document) + + + A list of stop words to be ignored + + + + Optionally specify more search options such as facets, from/to etcetera. + + + + descriptor for MsearchGet + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-multi-search.html
+
+ + + + Search operation type + + + descriptor for PercolateGet + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html
+
+ + + + A comma-separated list of specific routing values + + + Specify the node or shard the operation should be performed on (default: random) + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + The index to percolate the document into. Defaults to index. + + + The type to percolate document into. Defaults to type. + + + Explicit version number for concurrency control + + + Specific version type + + + + The object to perculate + + + + + The object to perculate + + + + + The object to perculate + + + + + Make sure we keep calculating score even if we are sorting on a field. + + + + + Allows to add one or more sort on specific fields. Each sort can be reversed as well. + The sort is defined on a per field level, with special field name for _score to sort by score. + + + Sort ascending. + + + + + + Allows to add one or more sort on specific fields. Each sort can be reversed as well. + The sort is defined on a per field level, with special field name for _score to sort by score. + + + Sort descending. + + + + + + Allows to add one or more sort on specific fields. Each sort can be reversed as well. + The sort is defined on a per field level, with special field name for _score to sort by score. + + + Sort ascending. + + + + + + Allows to add one or more sort on specific fields. Each sort can be reversed as well. + The sort is defined on a per field level, with special field name for _score to sort by score. + + + Sort descending. + + + + + + Sort() allows you to fully describe your sort unlike the SortAscending and SortDescending aliases. + + + + + + SortGeoDistance() allows you to sort by a distance from a geo point. + + + + + + SortScript() allows you to sort by a distance from a geo point. + + + + + + Describe the query to perform using a query descriptor lambda + + + + + Shortcut to .Query(q=>q.QueryString(qs=>qs.Query("string")) + Does a match_all if the userInput string is null or empty; + + + + + Filter search using a filter descriptor lambda + + + + + Filter search + + + + descriptor for SearchGet + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html
+
+ + + A descriptor wich describes a search operation for _search and _msearch + + + + The analyzer to use for the query string + + + Specify whether wildcard and prefix queries should be analyzed (default: false) + + + The default operator for query string query (AND or OR) + + + The field to use as default where no field prefix is given in the query string + + + Whether specified concrete indices should be ignored when unavailable (missing or closed) + + + Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + + + Whether to expand wildcard expression to concrete indices that are open, closed or both. + + + Specify whether format-based query failures (such as providing text to a numeric field) should be ignored + + + Specify whether query terms should be lowercased + + + Specify the node or shard the operation should be performed on (default: random) + + + A comma-separated list of specific routing values + + + Specify how long a consistent view of the index should be maintained for scrolled search + + + Search operation type + + + Specific 'tag' of the request for logging and statistical purposes + + + Specify which field to use for suggestions + + + Specify which field to use for suggestions + + + Specify suggest mode + + + How many suggestions to return in response + + + The source text for which the suggestions should be returned + + + + When strict is set, conditionless queries are treated as an exception. + + + + + The number of hits to return. Defaults to 10. When using scroll search type + size is actually multiplied by the number of shards! + + + + + The number of hits to return. Defaults to 10. + + + + + The starting from index of the hits to return. Defaults to 0. + + + + + The starting from index of the hits to return. Defaults to 0. + + + + + A search timeout, bounding the search request to be executed within the + specified time value and bail with the hits accumulated up + to that point when expired. Defaults to no timeout. + + + + + Enables explanation for each hit on how its score was computed. + (Use .DocumentsWithMetaData on the return results) + + + + + Returns a version for each search hit. (Use .DocumentsWithMetaData on the return results) + + + + + Make sure we keep calculating score even if we are sorting on a field. + + + + + Allows to filter out documents based on a minimum score: + + + + + + Controls a preference of which shard replicas to execute the search request on. + By default, the operation is randomized between the each shard replicas. + + + The operation will go and be executed only on the primary shards. + + + + + + + Controls a preference of which shard replicas to execute the search request on. + By default, the operation is randomized between the each shard replicas. + + + The operation will go and be executed on the primary shard, and if not available (failover), + will execute on other shards. + + + + + + + Controls a preference of which shard replicas to execute the search request on. + By default, the operation is randomized between the each shard replicas. + + + The operation will prefer to be executed on a local allocated shard is possible. + + + + + + + Controls a preference of which shard replicas to execute the search request on. + By default, the operation is randomized between the each shard replicas. + + + Restricts the search to execute only on a node with the provided node id + + + + + + + Controls a preference of which shard replicas to execute the search request on. + By default, the operation is randomized between the each shard replicas. + + + Prefers execution on the node with the provided node id if applicable. + + + + + + Allows to configure different boost level per index when searching across + more than one indices. This is very handy when hits coming from one index + matter more than hits coming from another index (think social graph where each user has an index). + + + + + Allows to selectively load specific fields for each document + represented by a search hit. Defaults to load the internal _source field. + + + + + Allows to selectively load specific fields for each document + represented by a search hit. Defaults to load the internal _source field. + + + + + Allows to selectively load specific fields for each document + represented by a search hit. Defaults to load the internal _source field. + + + + + Allows to add one or more sort on specific fields. Each sort can be reversed as well. + The sort is defined on a per field level, with special field name for _score to sort by score. + + + Sort ascending. + + + + + + Allows to add one or more sort on specific fields. Each sort can be reversed as well. + The sort is defined on a per field level, with special field name for _score to sort by score. + + + Sort descending. + + + + + + Allows to add one or more sort on specific fields. Each sort can be reversed as well. + The sort is defined on a per field level, with special field name for _score to sort by score. + + + Sort ascending. + + + + + + Allows to add one or more sort on specific fields. Each sort can be reversed as well. + The sort is defined on a per field level, with special field name for _score to sort by score. + + + Sort descending. + + + + + + Sort() allows you to fully describe your sort unlike the SortAscending and SortDescending aliases. + + + + + + SortGeoDistance() allows you to sort by a distance from a geo point. + + + + + + SortScript() allows you to sort by a distance from a geo point. + + + + + + Allow to specify field facets that return the N most frequent terms. + + + + + Allow to specify field facets that return the N most frequent terms. + + + + + range facet allow to specify a set of ranges and get both the number of docs (count) + that fall within each range, and aggregated data either based on the field, or using another field + + struct, (int, double, string, DateTime) + + + + range facet allow to specify a set of ranges and get both the number of docs (count) + that fall within each range, and aggregated data either based on the field, or using another field + + struct, (int, double, string, DateTime) + + + + The histogram facet works with numeric data by building a histogram across intervals + of the field values. Each value is “rounded” into an interval (or placed in a bucket), + and statistics are provided per interval/bucket (count and total). + + + + + The histogram facet works with numeric data by building a histogram across intervals + of the field values. Each value is “rounded” into an interval (or placed in a bucket), + and statistics are provided per interval/bucket (count and total). + + + + + A specific histogram facet that can work with date field types enhancing it over the regular histogram facet. + + + + + A specific histogram facet that can work with date field types enhancing it over the regular histogram facet. + + + + + Statistical facet allows to compute statistical data on a numeric fields. + The statistical data include count, total, sum of squares, + mean (average), minimum, maximum, variance, and standard deviation. + + + + + Statistical facet allows to compute statistical data on a numeric fields. + The statistical data include count, total, sum of squares, + mean (average), minimum, maximum, variance, and standard deviation. + + + + + The terms_stats facet combines both the terms and statistical allowing + to compute stats computed on a field, per term value driven by another field. + + + + + The terms_stats facet combines both the terms and statistical allowing + to compute stats computed on a field, per term value driven by another field. + + + + + The geo_distance facet is a facet providing information for ranges of distances + from a provided geo_point including count of the number of hits that fall + within each range, and aggregation information (like total). + + + + + The geo_distance facet is a facet providing information for ranges of distances + from a provided geo_point including count of the number of hits that fall + within each range, and aggregation information (like total). + + + + + A facet query allows to return a count of the hits matching + the facet query. The query itself can be expressed using the Query DSL. + + + + + A filter facet (not to be confused with a facet filter) allows you to return a count of the h + its matching the filter. The filter itself can be expressed using the Query DSL. + Note, filter facet filters are faster than query facet when using native filters (non query wrapper ones). + + + + + The term suggester suggests terms based on edit distance. The provided suggest text is analyzed before terms are suggested. + The suggested terms are provided per analyzed suggest text token. The term suggester doesn’t take the query into account that is part of request. + + + + + The phrase suggester adds additional logic on top of the term suggester to select entire corrected phrases + instead of individual tokens weighted based on ngram-langugage models. + + + + + The completion suggester is a so-called prefix suggester. + It does not do spell correction like the term or phrase suggesters but allows basic auto-complete functionality. + + + + + Describe the query to perform using a query descriptor lambda + + + + + Describe the query to perform using the static Query class + + + + + Shortcut to .Query(q=>q.QueryString(qs=>qs.Query("string")) + Does a match_all if the userInput string is null or empty; + + + + + Describe the query to perform as a raw json string + + + + + Filter search using a filter descriptor lambda + + + + + Filter search + + + + + Filter search using a raw json string + + + + + Allow to highlight search results on one or more fields. The implementation uses the either lucene fast-vector-highlighter or highlighter. + + + + + Allows you to specify a rescore query + + + + + Shorthand for a match_all query without having to specify .Query(q=>q.MatchAll()) + + + + + Whether conditionless queries are allowed or not + + + + descriptor for Update + 
+            http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-update.html
+
+ + + + Explicit write consistency setting for the operation + + + The script language (default: mvel) + + + ID of the parent document + + + Refresh the index after performing the operation + + + Specific replication type + + + Specify how many times should the operation be retried when a conflict occurs (default: 0) + + + Specific routing value + + + The URL-encoded script definition (instead of using request body) + + + Explicit operation timeout + + + Explicit timestamp for the document + + + Expiration time for the document + + + Explicit version number for concurrency control + + + Specific version type + + + + The full document to be created if an existing document does not exist for a partial merge. + + + + + The partial update document to be merged on to the existing object. + + + + A comma-separated list of fields to return in the response + + + A comma-separated list of fields to return in the response + + + + Determines how the terms aggregation is executed + + + + + Order by using field values directly in order to aggregate data per-bucket + + + + + Order by using ordinals of the field values instead of the values themselves + + + + + 5,009.4km x 4,992.6km + + + + + 1,252.3km x 624.1km + + + + + 156.5km x 156km + + + + + 39.1km x 19.5km + + + + + 4.9km x 4.9km + + + + + 1.2km x 609.4m + + + + + 152.9m x 152.4m + + + + + 38.2m x 19m + + + + + 4.8m x 4.8m + + + + + 1.2m x 59.5cm + + + + + 14.9cm x 14.9cm + + + + + 3.7cm x 1.9cm + + + + + Occurs when an IElasticClient call does not have + enough information to dispatch into the raw client. + + + + + Registerering global jsonconverters is very costly, + The best thing is to specify them as a contract (see ElasticContractResolver) + This however prevents a way to give a jsonconverter state which for some calls is needed i.e: + A multiget and multisearch need access to the descriptor that describes what types are used. + When NEST knows it has to piggyback this it has to pass serialization state it will create a new + serializersettings object with a new contract resolver which holds this state. Its ugly but it does boost + massive performance gains. + + + + + This extension method should only be used in expressions which are analysed by Nest. + When analysed it will append to the path separating it with a dot. + This is especially useful with multi fields. + + + + + Raw operations with elasticsearch + + + + + An object to describe an indexed geoshape + http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/query-dsl-geo-shape-filter.html + + + + + If not specified will use the default typename for the type specified on Lookup<T> + + + + + If not specified will use the default index for the type specified on Lookup<T> + + + + + Whether to cache the filter built from the retrieved document (true - default) or whether to fetch and + rebuild the filter on every request (false). + + + + + A custom routing value to be used when retrieving the external terms doc. + + + + + The way terms filter executes is by iterating over the terms provided and + finding matches docs (loading into a bitset) and caching it. Sometimes, + we want a different execution model that can still be achieved by building more complex + queries in the DSL, but we can support them in the more compact model that terms filter provides. + + + + + Controls how elasticsearch handles dynamic mapping changes when a new document present new fields + + + + + Default value, allows unmapped fields to be cause a mapping update + + + + + New unmapped fields will be silently ignored + + + + + If new unmapped fields are passed, the whole document WON'T be added/updated + + + + + POCO representing the reindex response for a each step + + + + + The bulk result indexing the search results into the new index. + + + + + The scroll result + + + + + The no of scroll this result represents + + + + + Whether both the scroll and reindex result are valid + + + + + The index into which we're indexing + + + + + The index from which we're reindexing + + + + + A search request can be scrolled by specifying the scroll parameter. The scroll parameter is a time value parameter (for example: scroll=5m), indicating for how long the nodes that participate in the search will maintain relevant resources in order to continue and support it. This is very similar in its idea to opening a cursor against a database. + + The scroll parameter is a time value parameter (for example: scroll=5m) + + + + + A query to optionally limit the documents to use for the reindex operation. + + + + + The new index name to reindex too. + + + + + CreateIndex selector, will be passed the a descriptor initialized with the settings from + the index we're reindexing from + + + + + POCO representing the reindex response for a each step + + + + + Marker class that signals to the CustomJsonConverter to write the string verbatim + + + + + Specifies wheter this particular bulk operation succeeded or not + + + + + Create a new bulk operation + + Use this document to infer the id from + Use the document to infer on as the upsert document in this update operation + + + + Create a new Bulk Operation + + Use this document to infer the id from + The partial update document (doc) to send as update + Use the document to infer on as the upsert document in this update operation + + + + Only used for bulk update operations but in the future might come in handy for other complex bulk ops. + + + + + + Manually set the index, default to the default index or the fixed index set on the bulk operation + + + + + Manualy set the type to get the object from, default to whatever + T will be inferred to if not passed or the fixed type set on the parent bulk operation + + + + + Manually set the type of which a typename will be inferred + + + + + Manually set the id for the newly created object + + + + + Manually set the id for the newly created object + + + + + The object to update, if id is not manually set it will be inferred from the object. + Used ONLY to infer the ID see Document() to apply a partial object merge. + + + + + A document to upsert when the specified document to be updated is not found + + + + + The partial update document to be merged on to the existing object. + + + + + Add metadata associated with this percolator query document + + + + + The query to perform the percolation + + + + + Defaults to float so be sure to set this correctly! + + + + + http://www.elasticsearch.org/guide/reference/mapping/date-format.html + + + + + The name of the warmer + + + + + A Query that matches documents containing a particular sequence of terms. + It allows for prefix matches on the last term in the text. + + Type of document + + + + A Query that matches documents containing a particular sequence of terms. A PhraseQuery is built by QueryParser for input like "new york". + + Type of document + + + + Null if Percolation was not requested while indexing this doc, otherwise returns the percolator _ids that matched (if any) + + + + + Manually set the index, default to the default index or the fixed index set on the bulk operation + + + + + Manualy set the type to get the object from, default to whatever + T will be inferred to if not passed or the fixed type set on the parent bulk operation + + + + + Manually set the type of which a typename will be inferred + + + + + Manually set the id for the newly created object + + + + + Manually set the id for the newly created object + + + + + The object to update, if id is not manually set it will be inferred from the object + + + + + Manually set the index, default to the default index or the fixed index set on the bulk operation + + + + + Manualy set the type to get the object from, default to whatever + T will be inferred to if not passed or the fixed type set on the parent bulk operation + + + + + Manually set the type of which a typename will be inferred + + + + + Manually set the id for the newly created object + + + + + Manually set the id for the newly created object + + + + + The object to index, if id is not manually set it will be inferred from the object + + + + + Manually set the index, default to the default index or the fixed index set on the bulk operation + + + + + Manualy set the type to get the object from, default to whatever + T will be inferred to if not passed or the fixed type set on the parent bulk operation + + + + + Manually set the type of which a typename will be inferred + + + + + Manually set the id for the newly created object + + + + + Manually set the id for the newly created object + + + + + The object to infer the id off, (if id is not passed using Id()) + + + + + Language types used for language analyzers + + + + + A set of analyzers aimed at analyzing specific language text. + + + + + A list of stopword to initialize the stop filter with. Defaults to the english stop words. + + + + + A path (either relative to config location, or absolute) to a stopwords file configuration. + + + + + An analyzer of type keyword that “tokenizes” an entire stream as a single token. This is useful for data like zip codes, ids and so on. + Note, when using mapping definitions, it make more sense to simply mark the field as not_analyzed. + + + + + An analyzer of type pattern that can flexibly separate text into terms via a regular expression. + + + + + An analyzer of type stop that is built using a Lower Case Tokenizer, with Stop Token Filter. + + + + + A list of stopword to initialize the stop filter with. Defaults to the english stop words. + + + + + A path (either relative to config location, or absolute) to a stopwords file configuration. + + + + + An analyzer of type whitespace that is built using a Whitespace Tokenizer. + + + + + An analyzer of type simple that is built using a Lower Case Tokenizer. + + + + + A char filter of type html_strip stripping out HTML elements from an analyzed text. + + + + + A char filter of type mapping replacing characters of an analyzed text with given mapping. + + + + + A token filter of type asciifolding that converts alphabetic, numeric, and symbolic Unicode characters which are + not in the first 127 ASCII characters (the “Basic Latin” Unicode block) into their ASCII equivalents, if one exists. + + + + + Token filters that allow to decompose compound words. + + + + + A list of words to use. + + + + + A path (either relative to config location, or absolute) to a list of words. + + + + + Minimum word size. + + + + + Minimum subword size. + + + + + Maximum subword size. + + + + + Only matching the longest. + + + + + The trim token filter trims surrounding whitespaces around a token. + + + + + The unique token filter can be used to only index unique tokens during analysis. By default it is applied on all the token stream + + + + + If only_on_same_position is set to true, it will only remove duplicate tokens on the same position. + + + + + The truncate token filter can be used to truncate tokens into a specific length. This can come in handy with keyword (single token) + based mapped fields that are used for sorting in order to reduce memory usage. + + + + + length parameter which control the number of characters to truncate to, defaults to 10. + + + + + A token filter which removes elisions. For example, “l’avion” (the plane) will tokenized as “avion” (plane). + + + + + Accepts articles setting which is a set of stop words articles + + + + + A token filter of type reverse that simply reverses the tokens. + + + + + The phonetic token filter is provided as a plugin. + + + + + A filter that stems words using a Snowball-generated stemmer. + + + + + The kstem token filter is a high performance filter for english. + All terms must already be lowercased (use lowercase filter) for this filter to work correctly. + + + + + Protects words from being modified by stemmers. Must be placed before any stemming filters. + + + + + A filter that stems words (similar to snowball, but with more options). + + + + + A token filter of type porterStem that transforms the token stream as per the Porter stemming algorithm. + + + + + A token filter of type lowercase that normalizes token text to lower case. + Lowercase token filter supports Greek and Turkish lowercase token filters through the language parameter. + + + + + A token filter of type length that removes words that are too long or too short for the stream. + + + + + A token filter of type standard that normalizes tokens extracted with the Standard Tokenizer. + + + + + The path_hierarchy tokenizer takes something like this: + /something/something/else + And produces tokens: + + /something + /something/something + /something/something/else + + + + + The character delimiter to use, defaults to /. + + + + + An optional replacement character to use. Defaults to the delimiter + + + + + The buffer size to use, defaults to 1024. + + + + + Generates tokens in reverse order, defaults to false. + + + + + Controls initial tokens to skip, defaults to 0. + + + + + A tokenizer of type uax_url_email which works exactly like the standard tokenizer, but tokenizes emails and urls as single tokens + + + + + The maximum token length. If a token is seen that exceeds this length then it is discarded. Defaults to 255. + + + + + A tokenizer of type pattern that can flexibly separate text into terms via a regular expression. + + + + + The regular expression pattern, defaults to \W+. + + + + + The regular expression flags. + + + + + Which group to extract into tokens. Defaults to -1 (split). + + + + + A tokenizer of type whitespace that divides text at whitespace. + + + + + A tokenizer of type standard providing grammar based tokenizer that is a good tokenizer for most European language documents. + The tokenizer implements the Unicode Text Segmentation algorithm, as specified in Unicode Standard Annex #29. + + + + + The maximum token length. If a token is seen that exceeds this length then it is discarded. Defaults to 255. + + + + + A tokenizer of type nGram. + + + + + A tokenizer of type lowercase that performs the function of Letter Tokenizer and Lower Case Token Filter together. + It divides text at non-letters and converts them to lower case. + While it is functionally equivalent to the combination of Letter Tokenizer and Lower Case Token Filter, + there is a performance advantage to doing the two tasks at once, hence this (redundant) implementation. + + + + + A tokenizer of type letter that divides text at non-letters. That’s to say, it defines tokens as maximal strings of adjacent letters. + Note, this does a decent job for most European languages, but does a terrible job for some Asian languages, where words are not separated by spaces. + + + + + A tokenizer of type edgeNGram. + + + + + A tokenizer of type keyword that emits the entire input as a single input. + + + + + The term buffer size. Defaults to 256. + + + + + A token filter of type edgeNGram. + + + + + Convenience method to map from most of the object from the attributes/properties. + Later calls on the fluent interface can override whatever is set is by this call. + This helps mapping all the ints as ints, floats as floats etcetera withouth having to be overly verbose in your fluent mapping + + + + + + Convenience method to map from most of the object from the attributes/properties. + Later calls on the fluent interface can override whatever is set is by this call. + This helps mapping all the ints as ints, floats as floats etcetera withouth having to be overly verbose in your fluent mapping + + + + + + The name of the field that will be stored in the index. Defaults to the property/field name. + + + + + The name of the field that will be stored in the index. Defaults to the property/field name. + + + + + The name of the field that will be stored in the index. Defaults to the property/field name. + + + + + The name of the field that will be stored in the index. Defaults to the property/field name. + + + + + The name of the field that will be stored in the index. Defaults to the property/field name. + + + + + As of elasticsearch fields are always returned as an array. except for internal metadata values such as routing. + + The type to return the value as, remember that if your field is a string K should be string[] + + + + As of elasticsearch fields are always returned as an array. except for internal metadata values such as routing. + + The type to return the value as, remember that if your field is a string K should be string[] + + + + As of elasticsearch fields are always returned as an array. + except for internal metadata values such as routing. + + + + + As of elasticsearch fields are always returned as an array. + except for internal metadata values such as routing. + + + + + As of elasticsearch fields are always returned as an array. except for internal metadata values such as routing. + + The type to return the value as, remember that if your field is a string K should be string[] + + + + A token filter of type nGram. + + + + + The synonym token filter allows to easily handle synonyms during the analysis process. + + + + + Gets the explanations if Explain() was set. + + + + + AND's two BaseFilters + + A new basefilter that represents the AND of the two + + + + A query that match on any (configurable) of the provided terms. + This is a simpler syntax query for using a bool query with several term queries in the should clauses. + + The type that represents the expected hit type + The type of the field that we want to specfify terms for + + + + A thin wrapper allowing fined grained control what should happen if a filter is conditionless + if you need to fallback to something other than a match_all query + + + + + Insert raw filter json at this position of the filter + Be sure to start your json with '{' + + + + + + + Filters documents where a specific field has a value in them. + + + + + Filters documents where a specific field has a value in them. + + + + + Filters documents where a specific field has no value in them. + + + + + Filters documents where a specific field has no value in them. + + + + + Filters documents that only have the provided ids. + Note, this filter does not require the _id field to be indexed since it works using the _uid field. + + + + + Filters documents that only have the provided ids. + Note, this filter does not require the _id field to be indexed since it works using the _uid field. + + + + + Filters documents that only have the provided ids. + Note, this filter does not require the _id field to be indexed since it works using the _uid field. + + + + + A filter allowing to filter hits based on a point location using a bounding box + + + + + A filter allowing to filter hits based on a point location using a bounding box + + + + + A filter allowing to filter hits based on a point location using a bounding box + + + + + A filter allowing to filter hits based on a point location using a bounding box + + + + + Filters documents that include only hits that exists within a specific distance from a geo point. + + + + + Filters documents that include only hits that exists within a specific distance from a geo point. + + + + + By defining a geohash cell, only geopoints within this cell will match this filter + + + + + By defining a geohash cell, only geopoints within this cell will match this filter + + + + + Filters documents that exists within a range from a specific point: + + + + + Filters documents that exists within a range from a specific point: + + + + + Filter documents indexed using the circle geo_shape type. + + + + + Filter documents indexed using the circle geo_shape type. + + + + + Filter documents indexed using the envelope geo_shape type. + + + + + Filter documents indexed using the envelope geo_shape type. + + + + + Filter documents indexed using the linestring geo_shape type. + + + + + Filter documents indexed using the linestring geo_shape type. + + + + + Filter documents indexed using the multilinestring geo_shape type. + + + + + Filter documents indexed using the multilinestring geo_shape type. + + + + + Filter documents indexed using the point geo_shape type. + + + + + Filter documents indexed using the point geo_shape type. + + + + + Filter documents indexed using the multipoint geo_shape type. + + + + + Filter documents indexed using the multipoint geo_shape type. + + + + + Filter documents indexed using the polygon geo_shape type. + + + + + Filter documents indexed using the polygon geo_shape type. + + + + + Filter documents indexed using the multipolygon geo_shape type. + + + + + Filter documents indexed using the multipolygon geo_shape type. + + + + + Filter documents indexed using the geo_shape type. + + + + + Filter documents indexed using the geo_shape type. + + + + + A filter allowing to include hits that only fall within a polygon of points. + + + + + A filter allowing to include hits that only fall within a polygon of points. + + + + + A filter allowing to include hits that only fall within a polygon of points. + + + + + A filter allowing to include hits that only fall within a polygon of points. + + + + + The has_child filter accepts a query and the child type to run against, + and results in parent documents that have child docs matching the query. + + Type of the child + + + + The has_child filter accepts a query and the child type to run against, + and results in parent documents that have child docs matching the query. + + Type of the child + + + + A limit filter limits the number of documents (per shard) to execute on. + + + + + Filters documents matching the provided document / mapping type. + Note, this filter can work even when the _type field is not indexed + (using the _uid field). + + + + + Filters documents matching the provided document / mapping type. + Note, this filter can work even when the _type field is not indexed + (using the _uid field). + + + + + A filter that matches on all documents. + + + + + Filters documents with fields that have terms within a certain range. + Similar to range query, except that it acts as a filter. + + + + + A filter allowing to define scripts as filters. + + + + + Filters documents that have fields containing terms with a specified prefix + (not analyzed). Similar to phrase query, except that it acts as a filter. + + + + + Filters documents that have fields containing terms with a specified prefix + (not analyzed). Similar to phrase query, except that it acts as a filter. + + + + + Filters documents that have fields that contain a term (not analyzed). + Similar to term query, except that it acts as a filter + + + + + Filters documents that have fields that contain a term (not analyzed). + Similar to term query, except that it acts as a filter + + + + + Filters documents that have fields that contain a term (not analyzed). + Similar to term query, except that it acts as a filter + + + + + Filters documents that have fields that match any of the provided terms (not analyzed). + + + + + Filters documents that have fields that match any of the provided terms (not analyzed). + + + + + Filters documents that have fields that match any of the provided terms (not analyzed). + + + + + Filter documents indexed using the geo_shape type. + + + + + Filter documents indexed using the geo_shape type. + + + + + A filter that matches documents using AND boolean operator on other queries. + This filter is more performant then bool filter. + + + + + A filter that matches documents using AND boolean operator on other queries. + This filter is more performant then bool filter. + + + + + A filter that matches documents using OR boolean operator on other queries. + This filter is more performant then bool filter + + + + + A filter that matches documents using OR boolean operator on other queries. + This filter is more performant then bool filter + + + + + A filter that filters out matched documents using a query. + This filter is more performant then bool filter. + + + + + + A filter that matches documents matching boolean combinations of other queries. + Similar in concept to Boolean query, except that the clauses are other filters. + + + + + Wraps any query to be used as a filter. + + + + + A nested filter, works in a similar fashion to the nested query, except used as a filter. + It follows exactly the same structure, but also allows to cache the results + (set _cache to true), and have it named (set the _name value). + + + + + + The regexp filter allows you to use regular expression term queries. + + + + + + Same as setting to and include_upper to true. + + + + + Forces the 'From()' to be exclusive (which is inclusive by default). + + + + + Forces the 'To()' to be exclusive (which is inclusive by default). + + + + + Specifies a minimum number of the optional BooleanClauses which must be satisfied. + + + + + + + Specifies a minimum number of the optional BooleanClauses which must be satisfied. String overload where you can specify percentages + + + + + + + Boost this results matching this query. + + + + + + The clause(s) that must appear in matching documents + + + + + The clause(s) that must appear in matching documents + + + + + The clause (query) should appear in the matching document. A boolean query with no must clauses, one or more should clauses must match a document. + The minimum number of should clauses to match can be set using minimum_should_match parameter. + + + + + + + The clause (query) should appear in the matching document. A boolean query with no must clauses, one or more should clauses must match a document. + The minimum number of should clauses to match can be set using minimum_should_match parameter. + + + + + + + The clause (query) must not appear in the matching documents. Note that it is not possible to search on documents that only consists of a must_not clauses. + + + + + + + The clause (query) must not appear in the matching documents. Note that it is not possible to search on documents that only consists of a must_not clauses. + + + + + + + The top_children query runs the child query with an estimated hits size, and out of the hit docs, + aggregates it into parent docs. If there aren’t enough parent docs matching the + requested from/size search request, then it is run again with a wider (more hits) search. + + Type used to strongly type parts of this query + + + + Provide a child query for the top_children query + + Describe the child query to be executed + + + + How many hits are asked for in the first child query run is controlled using the factor parameter (defaults to 5). + + The factor that controls how many hits are asked for + + + + Provide a scoring mode for the child hits + + max, sum or avg + + + + If the initial fetch did not result in enough parent documents this factor will be used to determine + the next pagesize + + Multiplier for the original factor parameter + + + + The type of the children to query, defaults to the inferred typename for the T + that was used on the TopChildren call + + + + + A list of document ids. This parameter is required if like_text is not specified. + The texts are fetched from fields unless specified in each doc, and cannot be set to _all. + 
Available from Elasticsearch 1.3.0
+ + + + + A list of documents following the same syntax as the Multi GET API. This parameter is required if like_text is not specified. + The texts are fetched from fields unless specified in each doc, and cannot be set to _all. + 
Available from Elasticsearch 1.3.0
+ + + + + Specify multiple documents to suply the more like this like text + + + + + Specify multiple documents to supply the more like this text, but do not generate index: and type: on the get operations. + Useful if the node has rest.action.multi.allow_explicit_index set to false + + + + + + + Boosts the range query by the specified boost factor + + Boost factor + + + + Scripts are cached for faster execution. If the script has parameters that it needs to take into account, it is preferable to use the same script, and provide parameters to it: + + + + + + + Value to sort on when the orginal value for the field is missing + + + + + (the default), rounds to the lowest whole unit of this field. + + + + + Rounds to the highest whole unit of this field. + + + + + Round to the nearest whole unit of this field. If the given millisecond value is closer to the floor or is exactly halfway, this function behaves like floor. If the millisecond value is closer to the ceiling, this function behaves like ceiling. + + + + + Round to the nearest whole unit of this field. If the given millisecond value is closer to the floor, this function behaves like floor. If the millisecond value is closer to the ceiling or is exactly halfway, this function behaves like ceiling. + + + + + Round to the nearest whole unit of this field. If the given millisecond value is closer to the floor, this function behaves like floor. If the millisecond value is closer to the ceiling, this function behaves like ceiling. If the millisecond value is exactly halfway between the floor and ceiling, the ceiling is chosen over the floor only if it makes this field’s value even. + + + + + A filter allowing to define scripts as filters. + Ex: "doc['num1'].value > 1" + + + + + Filter script. + + script + this + + + + Indexed script can be referenced by script id + + Indexed script id + this + + + + Scripts are compiled and cached for faster execution. + If the same script can be used, just with different parameters provider, + it is preferable to use the ability to pass parameters to the script itself. + Ex: + Script: "doc['num1'].value > param1" + param: "param1" = 5 + + param + this + + + + Language of script. + + language + this + + + + Language of script. + + language + this + + + + JSON converter for IDictionary that ignores the contract resolver (e.g. CamelCasePropertyNamesContractResolver) + when converting dictionary keys to property names. + + + + + The individual error for separate requests on the _mpercolate API + + + + + Insert raw query json at this position of the query + Be sure to start your json with '{' + + + + + + + A query that uses a query parser in order to parse its content. + + + + + A query that uses the SimpleQueryParser to parse its context. + Unlike the regular query_string query, the simple_query_string query will + never throw an exception, and discards invalid parts of the query. + + + + + A query that match on any (configurable) of the provided terms. This is a simpler syntax query for using a bool query with several term queries in the should clauses. + + + + + A query that match on any (configurable) of the provided terms. This is a simpler syntax query for using a bool query with several term queries in the should clauses. + + + + + A query that match on any (configurable) of the provided terms. This is a simpler syntax query for using a bool query with several term queries in the should clauses. + + + + + A query that match on any (configurable) of the provided terms. This is a simpler syntax query for using a bool query with several term queries in the should clauses. + + + + + A query that match on any (configurable) of the provided terms. This is a simpler syntax query for using a bool query with several term queries in the should clauses. + + + + + A fuzzy based query that uses similarity based on Levenshtein (edit distance) algorithm. + Warning: this query is not very scalable with its default prefix length of 0 – in this case, + every term will be enumerated and cause an edit score calculation or max_expansions is not set. + + + + + fuzzy query on a numeric field will result in a range query “around” the value using the min_similarity value + + + + + fuzzy query on a numeric field will result in a range query “around” the value using the min_similarity value + + + + + + The default text query is of type boolean. It means that the text provided is analyzed and the analysis + process constructs a boolean query from the provided text. + + + + + The text_phrase query analyzes the text and creates a phrase query out of the analyzed text. + + + + + The text_phrase_prefix is the same as text_phrase, expect it allows for prefix matches on the last term + in the text + + + + + The multi_match query builds further on top of the match query by allowing multiple fields to be specified. + The idea here is to allow to more easily build a concise match type query over multiple fields instead of using a + relatively more expressive query by using multiple match queries within a bool query. + + + + + Nested query allows to query nested objects / docs (see nested mapping). The query is executed against the + nested objects / docs as if they were indexed as separate docs (they are, internally) and resulting in the + root parent doc (or parent nested mapping). + + + + + A thin wrapper allowing fined grained control what should happen if a query is conditionless + if you need to fallback to something other than a match_all query + + + + + The indices query can be used when executed across multiple indices, allowing to have a query that executes + only when executed on an index that matches a specific list of indices, and another query that executes + when it is executed on an index that does not match the listed indices. + + + + + Matches documents with fields that have terms within a certain range. The type of the Lucene query depends + on the field type, for string fields, the TermRangeQuery, while for number/date fields, the query is + a NumericRangeQuery + + + + + Fuzzy like this query find documents that are “like” provided text by running it against one or more fields. + + + + + More like this query find documents that are “like” provided text by running it against one or more fields. + + + + + The geo_shape Filter uses the same grid square representation as the geo_shape mapping to find documents + that have a shape that intersects with the envelope shape. + It will also use the same PrefixTree configuration as defined for the field mapping. + + + + + The geo_shape Filter uses the same grid square representation as the geo_shape mapping to find documents + that have a shape that intersects with the circle shape. + It will also use the same PrefixTree configuration as defined for the field mapping. + + + + + The geo_shape Filter uses the same grid square representation as the geo_shape mapping to find documents + that have a shape that intersects with the line string shape. + It will also use the same PrefixTree configuration as defined for the field mapping. + + + + + The geo_shape circle Filter uses the same grid square representation as the geo_shape mapping to find documents + that have a shape that intersects with the multi line string shape. + It will also use the same PrefixTree configuration as defined for the field mapping. + + + + + The geo_shape circle Filter uses the same grid square representation as the geo_shape mapping to find documents + that have a shape that intersects with the point shape. + It will also use the same PrefixTree configuration as defined for the field mapping. + + + + + The geo_shape circle Filter uses the same grid square representation as the geo_shape mapping to find documents + that have a shape that intersects with the multi point shape. + It will also use the same PrefixTree configuration as defined for the field mapping. + + + + + The geo_shape circle Filter uses the same grid square representation as the geo_shape mapping to find documents + that have a shape that intersects with the polygon shape. + It will also use the same PrefixTree configuration as defined for the field mapping. + + + + + The geo_shape circle Filter uses the same grid square representation as the geo_shape mapping to find documents + that have a shape that intersects with the multi polygon shape. + It will also use the same PrefixTree configuration as defined for the field mapping. + + + + + The common terms query is a modern alternative to stopwords which improves the precision and recall + of search results (by taking stopwords into account), without sacrificing performance. + + + + + The has_child query works the same as the has_child filter, by automatically wrapping the filter with a + constant_score. + + Type of the child + + + + The has_child query works the same as the has_child filter, by automatically wrapping the filter with a + constant_score. + + Type of the child + + + + The top_children query runs the child query with an estimated hits size, and out of the hit docs, aggregates + it into parent docs. If there aren’t enough parent docs matching the requested from/size search request, + then it is run again with a wider (more hits) search. + + Type of the child + + + + A query that applies a filter to the results of another query. This query maps to Lucene FilteredQuery. + + + + + A query that generates the union of documents produced by its subqueries, and that scores each document + with the maximum score for that document as produced by any subquery, plus a tie breaking increment for + any additional matching subqueries. + + + + + A query that wraps a filter or another query and simply returns a constant score equal to the query boost + for every document in the filter. Maps to Lucene ConstantScoreQuery. + + + + + custom_boost_factor query allows to wrap another query and multiply its score by the provided boost_factor. + This can sometimes be desired since boost value set on specific queries gets normalized, while this + query boost factor does not. + + + + + custom_score query allows to wrap another query and customize the scoring of it optionally with a + computation derived from other field values in the doc (numeric ones) using script expression + + + + + custom_score query allows to wrap another query and customize the scoring of it optionally with a + computation derived from other field values in the doc (numeric ones) using script or boost expression + + + + + A query that matches documents matching boolean combinations of other queries. The bool query maps to + Lucene BooleanQuery. + It is built using one or more boolean clauses, each clause with a typed occurrence + + + + + the boosting query can be used to effectively demote results that match a given query. + Unlike the “NOT” clause in bool query, this still selects documents that contain + undesirable terms, but reduces their overall score. + + + + + + A query that matches all documents. Maps to Lucene MatchAllDocsQuery. + + An optional boost to associate with this match_all + + When indexing, a boost value can either be associated on the document level, or per field. + The match all query does not take boosting into account by default. In order to take + boosting into account, the norms_field needs to be provided in order to explicitly specify which + field the boosting will be done on (Note, this will result in slower execution time). + + + + + Matches documents that have fields that contain a term (not analyzed). + The term query maps to Lucene TermQuery. + + + + + Matches documents that have fields that contain a term (not analyzed). + The term query maps to Lucene TermQuery. + + + + + Matches documents that have fields that contain a term (not analyzed). + The term query maps to Lucene TermQuery. + + + + + Matches documents that have fields that contain a term (not analyzed). + The term query maps to Lucene TermQuery. + + + + + Matches documents that have fields matching a wildcard expression (not analyzed). + Supported wildcards are *, which matches any character sequence (including the empty one), and ?, + which matches any single character. Note this query can be slow, as it needs to iterate + over many terms. In order to prevent extremely slow wildcard queries, a wildcard term should + not start with one of the wildcards * or ?. The wildcard query maps to Lucene WildcardQuery. + + + + + Matches documents that have fields matching a wildcard expression (not analyzed). + Supported wildcards are *, which matches any character sequence (including the empty one), and ?, + which matches any single character. Note this query can be slow, as it needs to iterate over many terms. + In order to prevent extremely slow wildcard queries, a wildcard term should not start with + one of the wildcards * or ?. The wildcard query maps to Lucene WildcardQuery. + + + + + Matches documents that have fields matching a wildcard expression (not analyzed). + Supported wildcards are *, which matches any character sequence (including the empty one), and ?, + which matches any single character. Note this query can be slow, as it needs to iterate over many terms. + In order to prevent extremely slow wildcard queries, a wildcard term should not start with + one of the wildcards * or ?. The wildcard query maps to Lucene WildcardQuery. + + + + + Matches documents that have fields containing terms with a specified prefix (not analyzed). + The prefix query maps to Lucene PrefixQuery. + + + + + Matches documents that have fields containing terms with a specified prefix (not analyzed). + The prefix query maps to Lucene PrefixQuery. + + + + + Matches documents that have fields containing terms with a specified prefix (not analyzed). + The prefix query maps to Lucene PrefixQuery. + + + + + Filters documents that only have the provided ids. Note, this filter does not require + the _id field to be indexed since it works using the _uid field. + + + + + Filters documents that only have the provided ids. + Note, this filter does not require the _id field to be indexed since + it works using the _uid field. + + + + + Filters documents that only have the provided ids. + Note, this filter does not require the _id field to be indexed since + it works using the _uid field. + + + + + Matches spans containing a term. The span term query maps to Lucene SpanTermQuery. + + + + + Matches spans containing a term. The span term query maps to Lucene SpanTermQuery. + + + + + Matches spans containing a term. The span term query maps to Lucene SpanTermQuery. + + + + + Matches spans near the beginning of a field. The span first query maps to Lucene SpanFirstQuery. + + + + + Matches spans which are near one another. One can specify slop, the maximum number of + intervening unmatched positions, as well as whether matches are required to be in-order. + The span near query maps to Lucene SpanNearQuery. + + + + + Matches the union of its span clauses. + The span or query maps to Lucene SpanOrQuery. + + + + + Removes matches which overlap with another span query. + The span not query maps to Lucene SpanNotQuery. + + + + + Wrap a multi term query (one of fuzzy, prefix, term range or regexp query) + as a span query so it can be nested. + + + + + custom_score query allows to wrap another query and customize the scoring of it optionally with a + computation derived from other field values in the doc (numeric ones) using script or boost expression + + + + + Function score query + + + + + + Based on the type information present in this descriptor create method that takes + the returned _source and hit and returns the ClrType it should deserialize too. + This is so that Documents[A] can contain actual instances of subclasses B, C as well. + If you specify types using .Types(typeof(B), typeof(C)) then NEST can automagically + create a TypeSelector based on the hits _type property. + + + + + Defaults to float so be sure to set this correctly! + + + + + http://www.elasticsearch.org/guide/reference/mapping/date-format.html + + + + + Sometimes you need a generic type mapping, i.e when using dynamic templates + in order to specify "{dynamic_template}" the type, or if you have some plugin that exposes a new type. + + + + + The name of the field that will be stored in the index. Defaults to the property/field name. + + + + + Returns a view on the documents inside the hits that are returned. + NOTE: if you use Fields() on the search descriptor .Documents will be empty use + .Fields instead or try the 'source filtering' feature introduced in Elasticsearch 1.0 + using .Source() on the search descriptor to get Documents of type T with only certain parts selected + + + + + + Will return the field selections inside the hits when the search descriptor specified .Fields. + Otherwise this will always be an empty collection. + + + + + Only set when search type = scan and scroll specified + + + + + + + + + + + IDictionary of id -Highlight Collection for the document + + + + + An analyzer of type custom that allows to combine a Tokenizer with zero or more Token Filters, and zero or more Char Filters. + The custom analyzer accepts a logical/registered name of the tokenizer to use, and a list of logical/registered names of token filters. + + + + + Writing these uses a custom converter that ignores the json props + + + + + Dynamic view of the settings object, useful for reading value from the settings + as it allows you to chain without nullrefs. Cannot be used to assign setting values though + + + + + An analyzer of type snowball that uses the standard tokenizer, with standard filter, lowercase filter, stop filter, and snowball filter. + The Snowball Analyzer is a stemming analyzer from Lucene that is originally based on the snowball project from snowball.tartarus.org. + + + + + JSON converter for IDictionary that ignores the contract resolver (e.g. CamelCasePropertyNamesContractResolver) + when converting dictionary keys to property names. + + + + + JSON converter for IDictionary that ignores the contract resolver (e.g. CamelCasePropertyNamesContractResolver) + when converting dictionary keys to property names. + + + + + Converter for converting Uri to String and vica versa + + + Code originated from http://stackoverflow.com/a/8087049/106909 + + + + + Determines whether this instance can convert the specified object type. + + + + + + + Reads the JSON representation of the object. + + + + + + + + + + Writes the JSON representation of the object. + + + + + + + + A token filter of type shingle that constructs shingles (token n-grams) from a token stream. + In other words, it creates combinations of tokens as a single token. + + + + + The minimum shingle size. Defaults to 2. + + + + + The maximum shingle size. Defaults to 2. + + + + + If true the output will contain the input tokens (unigrams) as well as the shingles. Defaults to true. + + + + + If output_unigrams is false the output will contain the input tokens (unigrams) if no shingles are available. + Note if output_unigrams is set to true this setting has no effect. Defaults to false. + + + + + The string to use when joining adjacent tokens to form a shingle. Defaults to " ". + + + + + This comes from Matt Warren's sample: + http://blogs.msdn.com/mattwar/archive/2007/07/31/linq-building-an-iqueryable-provider-part-ii.aspx + + + + + Pluralizes or singularizes words. + + + + + Initializes the class. + + + + + Adds the irregular rule. + + The singular. + The plural. + + + + Adds the unknown count rule. + + The word. + + + + Adds the plural rule. + + The rule. + The replacement. + + + + Adds the singular rule. + + The rule. + The replacement. + + + + Makes the plural. + + The word. + + + + + Makes the singular. + + The word. + + + + + Applies the rules. + + The rules. + The word. + + + + + Summary for the InflectorRule class + + + + + Initializes a new instance of the class. + + The regex pattern. + The replacement text. + + + + Applies the tule to the specified word. + + The word. + + + + + ConnectionSettings can be requested by JsonConverter's. + + + + + Define the type of field content. + + + + + Default. Will be defined by the type of property return. + + + + + Geo based points. + + + + + Geo shape type. + + + + + The attachment type allows to index different “attachment” type field (encoded as base64), for example, microsoft office formats, open document formats, ePub, HTML... + + + + + An ip mapping type allows to store ipv4 addresses in a numeric form allowing to easily sort, and range query it (using ip values). + + + + + The binary type is a base64 representation of binary data that can be stored in the index. + + + + + Text based string type. + + + + + Integer type. + + + + + Long type. + + + + + Float type. + + + + + Double type. + + + + + Date type. + + + + + Boolean type. + + + + + Completion type. + + + + + Nested type. + + + + + object type, no need to set this manually if its not a value type this will be set. + Only set this if you need to force a value type to be mapped to an elasticsearch object type. + + + + + Resolves member infos in an expression, instance may NOT be shared. + + + + + ConnectionSettings can be requested by JsonConverter's. + + + + + Signals to custom converter that it can get serialization state from one of the converters + Ugly but massive performance gain + + + + + internal constructor by TypeMappingWriter itself when it recurses, passes seenTypes as safeguard agains maxRecursion + + + + + Get the Elastic Search Field Type Related. + + ElasticPropertyAttribute + Property Field + String with the type name or null if can not be inferres + + + + Get the Elastic Search Field from a FieldType. + + FieldType + String with the type name or null if can not be inferres + + + + Inferes the FieldType from the type of the property. + + Type of the property + FieldType or null if can not be inferred + + + + An analyzer of type standard that is built of using Standard Tokenizer, with Standard Token Filter, Lower Case Token Filter, and Stop Token Filter. + + + + + A list of stopword to initialize the stop filter with. Defaults to the english stop words. + + + + + The maximum token length. If a token is seen that exceeds this length then it is discarded. Defaults to 255. + + + + + A token filter of type stop that removes stop words from token streams. + + + + + Named word_delimiter, it Splits words into subwords and performs optional transformations on subword groups. + + + + diff --git a/packages/NEST.1.3.1/lib/Nest.dll b/packages/NEST.1.3.1/lib/Nest.dll new file mode 100644 index 0000000..002dd3f Binary files /dev/null and b/packages/NEST.1.3.1/lib/Nest.dll differ diff --git a/packages/NEST.1.3.1/lib/Nest.pdb b/packages/NEST.1.3.1/lib/Nest.pdb new file mode 100644 index 0000000..68d86e1 Binary files /dev/null and b/packages/NEST.1.3.1/lib/Nest.pdb differ