From 7be95a976e555f75072fee9e0da0e0544be3f702 Mon Sep 17 00:00:00 2001 From: Eric Fontana Date: Fri, 6 Mar 2015 10:01:50 -0500 Subject: [PATCH 1/5] Re-factored to use Elasticsearch NEST and Bulk API --- .../Properties/AssemblyInfo.cs | 4 +- TimberWinR/Outputs/Elasticsearch.cs | 289 +- TimberWinR/Parser.cs | 12 + TimberWinR/TimberWinR.csproj | 6 + TimberWinR/mdocs/ElasticsearchOutput.md | 14 +- TimberWinR/packages.config | 2 + chocolateyUninstall.ps1.template | 2 +- .../Elasticsearch.Net.1.3.1.nupkg | Bin 0 -> 454746 bytes .../lib/Elasticsearch.Net.XML | 41449 ++++++++++++++++ .../lib/Elasticsearch.Net.dll | Bin 0 -> 481280 bytes .../lib/Elasticsearch.Net.pdb | Bin 0 -> 1152512 bytes packages/NEST.1.3.1/NEST.1.3.1.nupkg | Bin 0 -> 1743971 bytes packages/NEST.1.3.1/lib/Nest.XML | 12447 +++++ packages/NEST.1.3.1/lib/Nest.dll | Bin 0 -> 2076672 bytes packages/NEST.1.3.1/lib/Nest.pdb | Bin 0 -> 5019136 bytes 15 files changed, 54108 insertions(+), 117 deletions(-) create mode 100644 packages/Elasticsearch.Net.1.3.1/Elasticsearch.Net.1.3.1.nupkg create mode 100644 packages/Elasticsearch.Net.1.3.1/lib/Elasticsearch.Net.XML create mode 100644 packages/Elasticsearch.Net.1.3.1/lib/Elasticsearch.Net.dll create mode 100644 packages/Elasticsearch.Net.1.3.1/lib/Elasticsearch.Net.pdb create mode 100644 packages/NEST.1.3.1/NEST.1.3.1.nupkg create mode 100644 packages/NEST.1.3.1/lib/Nest.XML create mode 100644 packages/NEST.1.3.1/lib/Nest.dll create mode 100644 packages/NEST.1.3.1/lib/Nest.pdb 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 0000000000000000000000000000000000000000..fbc375e54196a4b2a0809aca618a7346119d2ba0 GIT binary patch literal 454746 zcmb5V1y~$!mpzCDcXto&?j#Th9^AcgYuqikySux)yCk@~6WrZlJHMIv=9}65@3Y%a z)$MAj`^oiy4IGzjKiP&zz*nZnnn%w~W^20DGVV(8Q4m0JQ$kWFTCibgV4QEZof2 z1~%p<#tx3;q{;^NrpAtf~}oUtR5jgy0|F@T&@(nye8k(+~q zn;XEv%gq7c;ovqhBqwG5{{rOy*P$_68#@{p88{j+1Az9%jJEcmz3m;%jUE0C=6@06 zU~KPf4ls83KkmZ};50NbHZb92W#i)DFyu1eVdZ3D2XJxluyS#*@c>MiY#pqP0Ji^m zd>qDxhOFF108Snbb`Bon|2RJ8|4}_5d60B4!63k3|B()|MHMDv z{D0HYe8PCtEDNgdg+xbx$-@dGVT?Q%eZakMK+6?a6uTs1l(oQa)95U_BvI*nU*M`P zxva^4x(|1B@^U{Mdn+!n^LM8u!6x7)$M2yD7pRnV93&f>WTCeYKYsPB+kr>~ojEk({0 zI@N~7frj&SfM{m$nqVHp3BKLlVRl!6T$m0{$P*%HI43dXELwpFQ=C>x=Uc0`2hr15K}p|E4rQ#U{F;_=%@6eJ<8GrWi}hrY;*KQW;u z_R%O+wMb1qmbXOcRXcgsVPmB0*AhigTipuZ&3AvVTmGzjzk3u%PWJPP*j0q(H+Ybc z7*5I;DjI$RIm1grgcjROtJ^xRJjbqNBHg#76vaKhw}^ziZ$V7=au$J;cG!Iynr(bn z@Ylw8NQgsEG^=HSgazSom<70R5Jho{V+`ST>GqX=BLeBKubOmAGwaAR5px?Pnu$4K zUB4btlh$K*wZ;}*zHSO2%6duEyg~j?+0e!VppsA^z`)dD!0mDT^7 zZsxpTd@=9tK2FEZty(+%JNfTvq%dqdRz<_Gdi@M>3PXG$R54c%iPd>fY6sw#2%Hh` zm)fV7JbJ4_^Qfj%21*q2Sy>N0Iv?J;QkU0LGcy^7FMxd$W9biWdoNy_4~#dNt%4@m z)n;LN0o$9*-83VjVUIwq!H@33%W8uu3ZxOQE45$&%$2u!vRM?ZDb~l73OBQR-+X8i z$DZl$=?E|+uD`ZU^YUSsdE76NJ>&>H6WlJzC{9i=`U@gDsc1*e$z)r1bJ&aP*M49+ zN$8Xy+lXU{;WYgI-v6Ypj6XQK;aCOVjx{Jm_v2gWdjmFPchehI-Ok5ZzEjRemoQz~ zX+CVLB?k_5bvT_Q&+GlKk~&>DW5YL?`$58F)|QQBJ3;$xGHQl^-P_+Y)tv$BZshkQ zsb{~4p$?1)o};4VBKI$?5k5##1^-B3;Kt9G#Bt{P0u8%T^P{i@%+kxgB?J?zCSG@FrRa*O1(xSO1G7UD6!S~_w0F!4O`qIUM-JBWe{CVsyzBw2g- zy|ws*FkgWE{_#ik%X~}=tM|+wqVxB3BKpcT7-Ac)4I}3 zf0E6;`VT9+vkq1-jM?f{$G+&`tmi4eMd6ouXW8AX&HYEy{nOgRjlc(z`$_M01i2J~ zOs@O<8M!!CIZ}Q@P_pQKGO*Gj0dQ!NQ>i)9A_;H`k|C^QRB(1w z1E0xy0|H2Ky|6w{r^#RG5^a{pk4aKde$LH;yNjFZ34oS791PHnn@Wf4{7g0&kU+`7 zmaBlCmNG>NH!hPC|GR7&-dgeG5T+5g#&x1&e9Dm~jOE6L zCr7F2NSBkT>>>q&J%K66+Kic%`F&OEX}d5s(p*zzq6spmz~j7BvpH9kyJjR;-g;?`nH(erLj@x*7>iV zA6fzyU$iVN5jd$i9VpYVLyhN_3{k5sSSg|&3|*lsYbu3^Ph62i^lL?~cvW+4_!^-s z1lEAO0a7%%#VQT}hB1Z9dMTj7__X7U8t3p-=v8gRMTkB0R&Rka?k<0a8Q1nIwNdXe zfRHV|)^Ul9eE}Vt4dB%;ViIAbn9y{*uU;2s%W>@&3GlaXw7)(n zJ_ZmOBaY&;A^gd08i?b-oykU;9vcrpN^5Pc`KsJk_qO$3rY@|5uY{9$o%7ou+hSCS zpB0dTrZas)!0GmBu!O|i>SvP`oUoI$rZ1mwf?+$Lv6SURHqZgHxG#qn>zqV~>zj5Q z+V7Nk!qQ4ar-orW^(?JirU&s*yJqx9j3ugJrC1TobTDdn>i0A)fN!%~Q~v!1vXBEo z#O#=_#7aP|1i7J2FyU{BmfcM>iB62rCc&8%&Jo(w?VVq;J}?n#a|-Rbj=_B^=xtY=zbdo{@M=}fZ3ZnAMeOxcf#eordjqrYWtL@Ek0YYB}?T6MBqW7%M115@d?AfPlo-jhx z3AucHMFA!4C`oE_60x#rt?c&aeuMNDOKU0_fX?*xZMTy+1|Eko#fafkG}oZ7ac|g@ zHMI?L%8jr_aX}LPHmCl}xYj@6Rq&^xYgjR6gNoAIm4=Nu@-Q^#)*zYk2N2-C9_?Ma z1^r^5;z_OJ$JXKS#~e57V~8;3l*+Ajf_Ja^jjLc=jkg|lyq{&pJD3XBncBsLHh!qU zFg6hEPM?$sUuoTGfNMgYoo*{*Acxw!jC%}_`5Av(qHEwl7o@FBh~ptnY|Fq$L{n+0 zS(EM@E-S-5E>1${-Yac=$3KNs7#GIz15RlzjB-r23H-R$i(O0Ao14AIj=q_~454w3 zllpGVd3tQYf;tLrjH2cZfzi$Z|4jrYMk0s^i7F~ph>Yf_zm_kf$Tyo6Lq_5YLCPoN z@KEx2`Tm&lS#@?a6;dRcpeEXFah(8dsp1sNu#!><#CXxw5an-wcKd6PY1HuEN~~-v zz;WJK74iENj@ydL6c`D6JC=j?mNJwZX{e@}w$Gech{L(chMt#HzGQ=YAq2>3G0ZZI zV>6P8S9;qK8dB%=w8)ra^TBBF%{mlMy^>fZ+wUY4p`nrTHWa20+~7OMG3mD&pFOc&ie359V*O`6i5O<@Hq^JIH8 z&8X$BVX7kk1dx2!s(+Q{Q5m&Y>IHKv>n(Ky(?Qt6v{L=eSMlkVzqN_mgyvVGbzNlh z&?#Ya;Y}d?pJOtpmy}bLjS+R#l%jgNG5UxW5C-5_h<1 zbUjm3h-tDq&hE}~eMNZX&hkxV_?7j|oE#y|$#lvS-N2V}ucx+MHj}OlhdXjzG4}Ck zEChWC?h`t3d`NzE8j9VlGcB z542^=43Zh`k~Fw2*zPy5`0S3<6$^A7AO(g>qMX%OdAhd)(Y!m zvZu@3*Yqi=m_I5%3l(Dim%d%3s=_aJ2FGL4vU)po1@`L z0PnP9?r@HlLyYUQ{?$5 zC0gun&1P9a;06))X|LRkH;&g&Y9WI{qXPa`!b)~g_XA$bmZ9OQr+{~)w#DKOm!!bF zbLlMZvUM*en0ZzJN7LudH`Lr8X9DR^nf|XV$3XVU#u9~IL#BQYK&=XVmrN#4+*dzp z3#Mj$KSL{Wh%ps;6UWpzsCHXLDNZh|JABo57-JUH)h|jdfKNpbhXV~&H#N~=0qqmT z`72J~gz4K676m6FdCpnGfeb-ZPV=~Fl=-PdfYh^0NDLLH<1hkwcK0=3skz+M)5I{x z6C49qor(}AaG4hC(5527gj!xsL!&OtROWsHEqw-?BQyV)ZwX&24zGpe?#Af1sMlormzuh4O+TYof6Eit^hd{S6h`}4fgx8^Ix zj=V~P*Z=f8i5DSY0rqlT5FI zR-D)-yfEYtS6N#JL1gGpfIl4^IT5_EZ0t}7=gQ)qncf4z8Gxh~3;v4u{GsWVV3*Z9 z4=nY|C|;>;vo}G~-5HyOv33~`l?qo6TZd@wn&pNhmRmCUVpEQCf`RJVaoVqBH9pbE z9Rl&okxPrn8$yb9gBevqY2<)sVucZ&Dj}f`+O|Ca&tMqecPm?Cl;x&CdXJ1|3hiac zPMz%$;z?N>EhD6ET|a&68R0hEWZaZ{zZ}L!a~2Daz!1ymCfaJa5$|ak62k4fri%_Z z7k#SU>jl`M+Vgw?i6WO#BY3O9{ zu$qdrE1Y=}-ef%SJD$R^{gHeYt2>>_qRh7)LmVu%qI@YWHkuZ1%PNYqhIJA27yDrN zjDml(AZA{W9?=N=m9KHgwAwQ4ioBeCKn&2r*X0xgOc@Kva&70d=;{udZz14JhCt4k zvE)hPSA7wc_K;KtvS9^I+szRZ(c61=WY_J|u?p>z`#O4HBp}T53b{gUB-BEG?)tj1 z3C}%zufPxdxtnud>txY}@I&QreTJx5e!V2~0iqDWXY18jpj$R$^XEZ#uLHyNU=NbR zS_&I-@+>V(PD$G#r7XiC-MHth?2wNy6Yhi_?FIt{91?}=33xTxxZbj zF)!kYsE*5y69QSYYe<%KhopCoSbuvy&>*+_tf0d`!6nphiQ~7$5LRnbRXc~f)Yo9S zhP+NOtd;gV4Az;AVTtzDwn%yxYaQ-gCq1^@&$Z5F4dNlJKG8_|II5p0@!O}O6;o#m_1Sk($e}*32^hzi)@Em$S7cNWnlA(vdpaCc zxy@r~1!2Rqx7ApI`DrLxysFQ17CvNgdyGxQ*D<2bDUJpS4aDP|;zj*nfl>S4;j5dG zg|vP}#-q!$MDs^kT^PZAOMxSi?xU7@99YhAdffbljH`Ai&21~B z^_t$W_J~=@IY3cnu!A;l`xIgUMch~wd8z-3_QdrKEx0_>mE(g_0Eo536}S>1ezJ^5 zr@k!yhiso@kXQ3(ukS(0%&T@rvm|N+ zP$>R$>^4k1-cvzcCY&Ri8mInYuBo1{kO-$u?{}qa{%}Mv3Op7?sihP+0_i?bH}kuy zj$?W-z^FG*%e5q*f&AcN9s zFrbpsKmcP%x(|v<=9daEl{FTRN^0OxC13ENDpwKTu#=}IeGWT* zFBLx4E{W|}7ew#k6-AXqXz{C_-N~C2-E$h8o^&5K=(M_ZRIk}Pg0~@unfZslHF?s{ zUaY%J#f*8Ms_KR_hK2nD{sA)sbkfvCi{)%Pi55X*nNZ324i@jJ;N}wwKIeXjXK=}f zEgID=Drpl!CH6DK;3S!RrO%vI3yzjiMElVkgn)d9l>(F3_8eZmn8B4lHiVxX?Ky-d ze9M&Uk?4vNsCc-&$p?RR@Uve`j4=)f#H7sfjt%)3i5}u?o4(SXPF|+^*Fsiyn;E#L z7>`GC64Bou&(^aB4pZ6AB^cJBwKk~xLepK%r7@1^^jS=v?5~lTAy)wKJ z5^tM!viK;G<`?4k4ar$auumwhgspE59=xkr*gff$PuLTS?vVof*L7}2SU=uvgdV!b z=?`9CHZ>kPPgmE6y9GVZKel#1qE9w_U^4}I9S{E~!)7wlI1VWtS|J~dVsG8P`>58O z4Tf~$)?$%SVHjp07{XH&u^3v4j8P8+hy+YC0vuOi5AJoh`qjtEhm2~6qEE=Ibsz5O z?1Aj#TKoIgS>i8fSGwvOvyK^i;f;F99!lYB1jW-gx{DrK=6U!<_Gq$u9VqP?K*@QIAsemxxz>BM7AN1a47OhPb(rZ8bKL?-JZ9q)p75K4+VeN=vk zFxf4^+zu$*`FJYHx7@yjhC8w7<(i8#KFf{4wWV33IU;2|MD9B-b5q}v2(AHMf({xJ zb!2o&pJZ3y=ryj!N#uVZca=s0`4*rzWguMX@*IlH9Jhmot& zuSBE0u@BGoYSUA~gpumeexg3W0!0rLct|n~*izd>F8^t03Q)%K7wChKKk8__6 zQrFEpq;I5$Gx^W>UG_GfBE1ffTXm;+qfd;87k{5cNwkia#Y2~4KbQ`@N3_hM(Ymyd zBI^%;N3;xswzXmnDUgi@enzxxqR~EJ9kaOqmT+T<(@NG-)FHN_=T100J&YBHkCKej-7Fc57>e=q z#>f+kt7NfBJQre=C*nnrziEX(`g7GV4dvS~jo9t)0fbe(`&n-#q7=nCW4plMOmyTG zkrZ<&dODwbXN6wYxM&;A%|Ucy=ZK4FyMPn-GOx(f`kN)w)n-=a2k`Xa z@PpHFv>RqL&%@IGF2700VlYQTqwRo0aOpCCXbDI(&MWPQ6YGa6P zS7K1?X^q*=5QF2ZE%SUuyW(y#UHmQ;Kei2K`Jsc%T4P}CJZ~A~FkFGC;$6g?Fo5T% zR8f%z9YZq-1Gr8zVDW+shXU|1YjvT)#n2zshQQ(Q>jb;SV7WzTtLlGcC@u~>p{!ml9f}_4*XEtw`3~BqhX#0kE zYW_C*7IY8ABa|UxlB(xLOllynJ*k56v&R7M#T3UH`E}tr^2ur8hedOP@0&J6YL++uiLK_Ju5a-71 z)Qf9v`8o{21^peWpe*-Q)lE<>a-Umxg#x0j=WXc-qmPG#2OJ)im7r+QNIhv`9}@%{ zvedb&fLJF(JQVm`N|HzeYIr?VhpShDmCEd{oZtma_>>z)7OIUjrJ*7c@z9qd37pWa zCRVaPr^48RXl_OF5wk;DkrJInzgcoMeXe4$&R7_H4+*g+AZ#9Hg*`{vg2!xSE80mK zvh^T}#EYypmp1=47nr{km$!8M$z^U0`NTowp1$OSrt@cPCSK4=3QbrjW>G#W51G{%E0UzZI;i!Y?&>QN@ zSC`j}7d6o8xN;RS2~C1J*?NV?{oXID%)Uis1h%L8*gS}tnB^i&n#C>r4MjmAEA-Rm z9i>iw72}l`;`|a?y2L^M4*0zskM7#CS@QP^JK<(Zq1PjFcKJ`PC=pS2gK}GgZZbSRO$Y-_PRea1@JB zCjmRD+{CI3WFi2Zc{^-yzfFhw6Cw^S(?o&PbFep4_}!FqJBCIM1dc8gL|Uke(>HStX*{KZGo>aPc0gE z_t;;&K|CCsD&J017`GG6jWa58h*zGV)&2lm%_TnSqY42U z2=+2oGdI75K$w3?{RRjcwEs|CX!ViQ3xMNcmpt=iEG9mo1TSYPb?%bd?~J;JLk(B7 z3BGNBHnSViv%Z$%HdQ=z?5bE!&ppiG60Kxr9xy3U+j3;-(lDKX4<%CI8d>>hpx8ge zx_+Bn3^=Kl&X&wyxuZ)ASb`5kzujlTjMU1VsBaQM3serPlozP#v)>3EF+&vuo4ay5 z)8}YPHVLwYQ38ZyZH`0*>yGwcy+9CmGsmFBpqN5rj@4vg_(Y=-ae4RH{84OqhYQ|z zILdlbBZNiuH+hGg^x1OKNAE$ze_#z zrT0g7Yy`#twgd7;TDY*@^afnPePe0m@~PmI9@6nTD@s*T-r?!X7j^fP+Y8wHXgSpq zOS!GHWPB%=p?97Y^e8;x(Zn~%frk2RPgMaTrxCv+zN5>3P z>|N2g31||_x(SFAM<)(f2sr=R6>-z1j2`~Idv)#VCy+%G9WHvU@M7?q)~=IMAP?_YWrjI%j%MFbwk@r&{En7Vy1mr~5JK)w4mkV-cSYraqsg4D z-=9!MpYGvS;T0MZub}juX|!)`RID}m`++WTqKBL3`5wf}HK77AXw0?PSKM9-Z4H5R zIHQP0w$CLx72zKkY<_Cpk$t%)W^AWO$hXV$d(ji44v5VQYG;X=lUOw1s(pNU}a9vGn{YOlqBwCJ?k5Yw3omPlegI;(YHxlEz(W~j()p|zG@tW_M2 znk)aam(t57r#zmoQI1aNc?K+VG#YWqJ*wV#+e}J4+YUNABa}K=^uUg)$Txn%Pp@{U zha^s7_hWG+5gcRxQ|PIrez_YL{_IXp$a)=aXs2k-qm|WKdf@CV#Zl?)ibx7q!qF6K z7RJaj3`tRET)T({(@zCd8_g!A7>d<7ETc3dXWB!o3%kYP+2b--X-Aa~pp{C-hCG$l zA(0|s{zZ@_Z`yKbI4{uwyxZ{3nk`-!BwpxqQ=pxLSjfhiM#(7V@&T+MY{;ea32m^DeZG+Og|=$ma&{(dWfmx6S```@S%S~;bK_p#K5WG z(#+&=hI`al!GS%MAUCjlnysr=#-7Qv&t6i!HvmiSkf-qmB7;ubS4>$>%DKTi~J{z<5mFfs-rCKe;Ra zD)7mLOfRBYz9~s3+`ti?6Cxi0c?g}*CQod8OkQOPI`it&5}saI=D=@WnK;1jL7pS2 z-kMuwZS599=~KfZ=GFjURuFe}PkJ)Tx_VgNM6r$mkIgC=xg`pIvqoXu;pYv&B(A1X z9_!bGv)@B)=R)C^jGb*wLE`TH4AX4!=x7ar@ij6L^sIjxii`k?`VD4Um=iG5f3&id zvTfjlcbC-D4ECj;clK4tGFD47&Cp~ntA?Zn*DysGz>l!uvco8+K!GD z*;W|uUs5i?LKpQtb2-?ORQ3-nC}-^6c^Z!t8~)&^LhDJ9PL;W_+xA~5Nm&GJz%~}0 z+-^(aqU9pAU4F$F3ZmFo!X-L{?VKUPaMl3q3XOzReoOCZLb~(67-&D1IPO0oQ2EX( ziM2m#$Q$7J%P{vYw54!lW?o3)a7GJ*kp=feJ#gEdmeHlpu~phdpw`!fY#~3_FR|0M zBh(sdDBa>9eaYG8OFf77DOn_6XMV(PJ*|W&G}G>q z;4r)uC7KSfI@_Qb*TR|`ca?Y_mkB(^%TQ0gx z4y#fEhQ?<3c~YVhBZRLIug*HaJ!%?NsFLmNvuQNVVGmpfwI#gcMojH$OpQ-ZV>U)D zin(v&&dBXyun_i`Ro;4xq-u8gr!9Dp`+SNX#GUs3BI8}IBbae3k|Re$X``rZWb)}(5#@1v-wAMJhC6 zNJ|Qgqh^noE#5W>U6p~ds*Peh)t6WwS>n;o4QP^26TpcZnQEs?jn0P}%h)+)7t}4sEO~)z#N#etK4?^e54+VT1doHjJN9 z)*%-Pg%jVzFL`STq`M_o=tXzIFM`j&~c?gCq(;EAbNar5u zKsyos%8<09Es(d&2>P)j4}DiP&ez#!Az3mz7G6W#tn@>Kb;zG5YrQ~$mAEgSi^q*8 z0N5Sg9=&C>rSSSxsje0iW~3Lqd67;zD$36MwN?BlrRQuVqwUV@;Hlibk^ot4y)FWs0Hjc$b?~byI`IW1+x! z1qS@g(1q>T2k2)&?A+*kqf37Gx|l;TL(|`Kg|7u+Z|IM*O>ZU9`4_fGu>y9F=3H4l zX_iwn)l)Fj0Y@oJ zT8I2bDePD6$_^ELRa*oDv-> zV;q9IGhmdbpB|J3i{TZ^c9o!7=DO55v-@a1IOX`6l#|zbjvP3PCW~3U$U_hJQ^OwX zpjnmPHsJa8b0Z&Z$~UeUDxFI9N5fv_@H2J~u*VNX9N($3F31n7x1MZvUR4B!e}sIc zSk{Z#_%d??5mYyhZ3WKE1Irxd@Y+J*rHeGNxb-A0@x!bE!%`vskx-PQEFCyIRJyCo z5?v%aZtb))$Ai^9?2=?#b%WI!Gk+JRu6*p72woQ)8nGxszvii-&b0Sj{&T zwE3Fv(!TYo*TVOa$n(KOzWEWBcefcx_{BUQ&|I3WAB zwWMn>+=WD6yNs(E`UarSBkocN<1oN;2*wH~W|Bm|dQldolbx|G)Y8|I>iPgNVl%kJ zqg*LcxM!K?G&}!{#rz%BKVQKbZBquM!>aD>B0d6)30j=o4;UO-=TV(Aed0^IqS9FCH z_M!>)a=g#IQ;}`+u9R^X-9PDz`#R;vd>++9YLksR9w8l=tX~>BZ$Q{x2X~cJ@;G2h zx4})nO7b*-0;?bYoRmJ-To>sz9B}as6@POy7n;~S-ORFnjGI8DlSIb)LNBT* z+1c8ovSn!H2@>JstHnz!oUl}1cj_fj@-Y-nShCM2<&s45ks0IAh;D9kQa#61^w=s@ zjNmcm#AobISn|+Bq?z)yFF=nHoR9Hq4hCsJ$`|VBlAyA%U;X*{KEUX*%rvRVFO~e2 zO5nlY46?+-cW5}qMEVt_|LvYVM~L07nrp7;SR&?10#@bkKfoh+GO4x}OO$B0DOIHC z?i@ciad3s)P-Z>!-N?OKN0(;0QY%q!+Fe98lZ#7XrB~tqriG6`Vv{*spB?uNV^d+H$dECJr+RX8EGN-(&mr>>I|Rm@7pj;kqJ==0+8B z?!%)>z8DrtoNbWNt;$j1%DggPA4A9Hm8DqKMY$Ap!X}xj05yj;D@I4BXxlPO{V!D! zzlG@^h2QBVBGTS!)sMEnb9e}G-GrQ}D~87cJ4Ms<&27WXW(Tnl{Ym7m+6m=d9%YLY z7B(0J1~15Ch966PRWA*}bSu8gse79iSrReJ3o}~{O(q@Mb_r#D$Yr1m+)xibkqY?W zPtvN7nSR1U81&4ddiJmVCBu)$6?#!8W-#^Aq?2miiZtCeHAbea@hK^sr4KG~fm2zf z;^L(zK#MnFXcyB2)kgF)NoGpQDO(~ z%{yD>4#Qnbu(rHScbs}Qk+^#+=iy;%{qMjPy|AeoNNhC32HuIs>Z*`8Z^IoieEWV>#1wu7?ctz925W5e7v7e(%J7sDn_WFuNO(k~g}~PuJLD>B zE2syeYz5HeDpt5N;Zx7xg|v;r&4WqM8Ts>Tl?5r_BwTEsfh-6=ld9;k$$_1N!hoC)R-A=fXnq5EyN zRCwo)#KKV-z4ui!x~84H77Q33C*^bwyrXOR?rdsX@%<`oojz@0b(5mYi~L6YwxYZc zMyAyMJsfajXy~##sye}_ve-tS9`}%6O^mlPKPgusntuH=G+7~xu>?ywT1hRJSSQ?MW2TFTHy)$QlFud@gr@O?<1=AlB)bI zt46DevZhVdbf)eF8~a{a{#oIl3@pyB`{(fg1ebFDLQ%3zAt}1|^iEmv2YrCDA6zP! zK~jYMCpdu4QvlA9IP~mqujlPgslT5Kk+K-&#Z0Y_tbWT6Zt- zO83zbNmetAGH-FA1)8{C26n)y#a#aj@wF+i6YJ}jTs`eW3%>Wl!=LtuT zC4MxlYpKjkWr?85d`iXY;emS&sjR9mY3O02ldr$pJr34mO^}ya zljj#u#*==rRw4Z=KK#|K=GN9@MZ{1Aa<#@0D(*Iz>!NhVH>D@AP4Pf;GS_7u!x9Uo}C%5{kCYR-=-X!b4NvuJ*hWE!U zADB5&bc|IR=uVLqIS%QX9*(nWxrKpA01zD>gro%O;C_Gk1yAnKC_=fYN9kuEiTQTB z^1KztUB3jK{Aa(+l7*5B1c7<^57*hxjw6%NMnQn|*Nw6IPi1G2RZU2>|C5ThENga# z)xSAb_Q%rIgNe*mRa%`~i59j^@{m!IimWyuul|^f-u+D?u(u51bPrQi&sD+BVNM$t zqN}xgy<0lf1iBX`!kFOi>(%RBbFvj@JsYB`KE5@Pxov})1V#_itTn6FTvIFBkYWL? zoC%>FzE#{4#Q)ODt1DfDHRCGRNFCB&YOJ5G8epwG1e%e3BAs~T=C;wzM^pt-f7mot zoa1T1@6dvZS|8myF=UvTD=8fdLXMwI@*}XxtFOu0a5?BNJx#A}eRghuo(E|nmrb*O zW3vdvrcai9R3|EFw!N>F%_rEupkcK4;f$Xzzuy}mjKWZ&bv6mLjA29#b3JCSX*;n8 z4YMsu6{FZ+iEDdrFf^P^TCKW{a{W!xwD-_Yonsy8 z#Ovfrzp%ZKhg=<7WHtK_o!0+NC*I;Rm%6FhjN;#YhW3V)a;>xLtyeXh$UwSpWE9Sl z`?eaf#@9h~VymSP>>{Dmbn?^HzJ8DUzf<5;)t}W){7d1{#UiU+`m4@0|D|vN#-cX^ zP*GtPw!bL^M@uU;UHp?`BCEELH0#>xC*KSG;n{?=qe<8Mtqw!oHW;ZgrGf!s32KYF`Oe{aD2ubS|;*C1_Vq?e!f$1ExQDQm3z zeKrT_Hanj5@)t!%swsl<>Y}#w?EiARSAUai^M7%%p&hqKl|{peBB=jw7<&KPWx~8) z?rR~S{wfiY$*o?7q|2DZL{sSRD0J8R8JHDeeHp)|eTNz}FhQ>Nro`2%?xk^1ekC@E{7EcqBsRHQUvi_o3#>iQ@?Tc+^r+GL}P3(m^zu%&z+DOMW=op`hz_VQSKTju^x}Zkt9QmHm@wYcDuo&;px*8 z&VS%0-5=Fr}EP0`NJd#Ag z@Uq;5b%4XuJW%I*BnRHO%{&kNu7j;46YRn^ij%DdhMhp0%iE3-Hl1q#Xgd5e9A=F3 zXP7szu0M*yQ{Bt_f@}6mr9{hJ2$N~MK+RCw^{Q>qkHNam1Ig^g_Iu8koS4$jx5*&vZ^mF9rapLI z#A!E)pSsNOlx7)F&mPWV*^IG?T#{+)3+!A{>-@bvD5p^m)A2sh`Fna4z_&@g-%DUQ zetHJQ+dc1evw(VQyA9{QuseDX2=76Z-TCUrZK)Jfoaj40WyKkRc9~SH2A3bHDrOg1 zb>R^d^kK7pP)eSJ8U#A$yT4WruZh1ei0gR^A1Wn@qk0jQ05zBIRBNli{sv!A=z4Y6 zQdicaH)4@b-zu#l3V?;JAE*dRI9$7|u@?s*=glDHK(Q-`o@M0oSs~#9;lPB_U z;pgSLnYzzFmq24VI;&;CMXT9XBvbU3oZnGPJn333;+Qm70APP3ih2iH7!9b=Me-3D z+>7JiXQ_zhkn-l)AuB|35t#FHM?~Z{VFGpiR2F5#^x(qz(7c;Or`el%^6upz>(XN@ zOnSkb0}E@!Dft+pU5vLH^uE8@~45YaQkG!~X(*d_4tV z@_0^As%|pvW|_(+oz|R0%YWE%6sZ5^^>c)Dw}|eL&TUQklg`f}S(T~eRi@L{KLE>3x#JESnjp$=7C@9|HG?RRb#jrG1Tb%MmUt-K$|Td3)yXt_s+Nu! zK2<0#^Y)7q^JmUb0E#zvmdulI`31+<|D2||#A|s(<9Q5S3@=n}G69CtUXXSRNZc|U zQKRCg-ayR-2srEmE8s`MV0SA6a?=QecsqKxPhU~Oj6Wu!*5!kp)<#5S_DjVqyfNLhzqL=R9_MWkyfQ+zMc{ls&h z{u1i#&hTWksJL~;nv;KU>rd!gwIraU0!0S)$()YZVzjLCK66*PGU=~gI zhph&oN#dutkS?2%JZFca-mM7U<^8LN$&c4`W-0#=PPo-ckk=|mOX0W2sO|~ zVodh?=_Z$;V0GPCo}E(BSlmvL%yRE;k$U%jFdRC!_gflC)w7+FVz+A1n8lE6j(4TZ z^5B9$!?HV2Zy6>3)E}~86g09hZn7CCDR&u`t#JVE0}C(yRT?@3$lx+Ms1`Y`JjveDD%fgppza$zTi<%jv5 zK_{dD$}tXjU~p31_eQQZ&&|q;ysEejQ0(%(7?4BEyD&yf=!aO)!gBiLO5J3r1HKtr zsh<7tI*%OX|F&u$>Jd(#bQCuUns+F(RT%iqgtYJrg!G1=wdI|K%GK3;J^v0!PZfq< zHZL8-e!J#bZyA#=HQ7CkGQs7yM5ibO1Jo(ehfkRsST9$9`0gkU_(!S}kA^|#1@EJ) zp;2ITt@WU;SC2Ys@4P~h?(V|${z76@m=et^^YLIlOKx(selZb0_=f=@G40M}Z;0(d ziPK`%2SDt9P(_c&22$n+L}EwW>~{k~oH zQV~!viNKis&pQq_(&J~$r`~Tr6<@*+-kI+`j32LFKL)*-Q%F#)$)cKeE6qUXGao4T z9zWldmb)<+K0vMW2m2fG&~~-J!HJOFBgD}5G&%A^%z4U5m0;r8aQMkwwBNmQ6bUL2 ze^`rph@kC1xo~SNW_v@Z_o3E!2eo=91H#pIfA9)V#TdLY?$E^#SPe6r{7?O&b&_{~ z(Y-ue^W9Av6KV*4kXld>Hc|uT^3wnD`A*FXPhFYN$?1*asOdk9o?b<6tGTbfh;6~W|~@O+2)h~cjB(nJlni1FUXow8xgvPDO+Fysf;5#31n4I%_6G{&y}-Z zYEsN!m~JPFL9?jmaq!hhv3Cpl^Y#YqCfm*5)*yUH7BujOrL!5sj2Bmyg1P1VlNao% z0i@&`^TB7SWwl0+`4urx0};hOlAtlelP|L@cE3IGqxQ6-`xMfSewTdnx>CJJ`bm|c zUIG-_8#(~xtpXArR}8nrGkfVSWhLbW9ZF(e8!xsv?MEI}Tz9IV8RKu*00pnF-O@(o z??Nj354K_ZT}}nve=gAHC49C(@fY&NlZa)$AaV6@))mjklOM^Db=Ow#RT}f(UVu3Q zczaea@Xye36A1D@haQcRbF5wL8;gI*EQdD<3MP&_85{zHi;QLaF0VI@TZHNWc`rjE~b zFH|VO<{dSO_T6q#!(H*Ukt(~5U!`y&b$dg1HmWB{&Z$VyZho;`Zr#8|rJ73e-wQlJ7&=oj{bK8R9;~5|3%hYK(!TgYr}2P;x5Il#ogU$i#wEH!6^>Kt!M~Z ziX=dBcWH6=La^de+@)x7`A*;W{_C#0{&s$Ki@zlG| zx6!5htT)H*Ix_m%9b=j(0VYSeQ#Lb1geW1u7Xc`a76_@^# zN(IB9$Wn~k(q&HQ1u4)w)-B9A9mNLqS1YHT0ce~-NE`A*zqV{aCP4!X&zAoldjom+ zBUSt}-uFIFCD+t1ST|lw1g?y5YFne+F^gO2nbU+99nv2p7D#F{&f8=kGCki0VqCu3 zR9b{!71#fpWE_3QVFxk>lr6UBBvX?%pf8eTw$F9Pb41gi+Q3bB0sc*{HW~`i95aX z3;a<_w+pl-Qzc7XaSakP{Z;y>eeGCNG|4P2Xy;a|f5%vN_oMs`XKrnXFDfR1gB9J% zWb6ZO)079VSJZ>b-S(2 zK&dlQHk@?SR<&xR)V36i?*)AdB$A3T0wCQAKw4jRDJ(r;7%_RyI?Vn`2!I=l(@+wX zxD#}XLP{l}@pKq~{QiLIyPHB4_;gIVH1KzR*_E$)zB1Jh->3Bd4vlr|m>{^%f6|i; z;C!Y&)qgx{U7Kf;DYt3&2vkaXmtOG9eK)yfySf^e=}+5e-ke|F5h-8+xLG$5vP^5GmH z3J!oVS^>tW3=6z|{$z0VA4(01tObTf0AS~r$L>zW;yK5Lq?G77+*GJrGq2D(TO^Nh zfl_msMmoag&SwNaON!wH>**5k_oGxGSru@=mh<4hMI-iK+Q0ml6)mX$tC^mde!r2< z3E>& z9=)K!1=y$`32^H)n1<6?+-$zlf`(!?wz2O10Z8L+wjxi@h5=F&w(+G|kzD>y&!!Ck z45&rTrtLZII=UuvyYpYRjByA2b;;1KksR|GF^s#M`b80JbJySn;KL6nTz_~03VQSa z{{Ny_e+BT^)bel=)%Ug)N=CKlFr)ZgjPYf*8RF_T{qiw)lhC7|R%)wBnjR*E&yGc_ zUIt%f%pwE#+*;_p$jrQ+xGex+omR?ws9ZMiB#FwyMB5%TeCiEUHs@*oDjO4Rpt9K( z04f`?s?$5k$wO4V2bC<|4rP9-SmA-Zcw?noP%VR-v z=5g}FJf7u~U4;XB^V4@dPw!C*Nw1jU78kVjrpI$sATem|!rc&XKIuv3cHX_D;rmbF ztT2EAz}^m|QFxer9`Ska*~ahxMh8LhFFMN_|Dw~g^T)!eC?@wj;+glX4^Z*%w9*B~ zXl-NnEh@_3r}8^90}S)OeR&?CwebPR6+;IVE(9>%&+`bNEBT#^LnPyO=)?+-9z99o z7*mo@mO9ZkZvUAZ!02~-n^`Y3a9#Wdvi}=w5Ag)-U-85*8>lCU&BQeTmE8CY{p%Bl zRxQzVQJ_YyFn|OAY~%AY@3B*9Am@)kgEqv5&~w^}YXEEoU<<*zi3X6>08&B!kHZ1L zDRSI@PHlYt=M?onr%pTj;vPNmyHoDs(eAmOHl73dlXoWoBJWksr}pvxU}yp8ctb5e zE&xNPor^NJHUEPlw0}_o+>#svuJR|KL|btJaHI9WoA%kVyEq;&>9FznKZsX;g$tA{ zA@{2Q&jXF#A)ftx?%~J|-DpjU`lP2Z7Vydh z@G4`+JDaB~yy0E6v+3?X1#bR+1@MO5G4b$aAnrApQd>so;Q9Rqpw%Qozz6{{w`4pa z<^Lg>|0Ou%O$oERf}#CnXCR4cw=sSI_y$N*nsvQKuk^W`UUIjy|H|-_PrVav6KrlB z*!wZDbF=hFt<>K9?DLLTvvWLA3yw_uHXtbWXQde>wR6L(#TN|Ejn~7H!XW4=2~9|MBOt=Rc~? z2}CH++iB(5gVKL9q>CQn1B^Lb{c^4jnoMmn!nH%g0K=8ig()LPkEU6`_yFc&Yj&|a z*OkDvIIzGOe&-hbFMnIH3i62G=c<)zRysnzZOs*XdoK}*!Nq>(qtMsX_tPC+!0MZzat%EIHUi()I8`LPSbyU zN9hF9Y9CvR7&fY^b|2Wm*1K5er9QM`;xeB zOD+3M$JBd$^{I5zCoQ%BlOXk9dcWq%J_JQpg5gegB0#C`Af;4L8y!&90GjW+9M)m2 zOWQIU3WUG6@~c{mS6_HQM3Y^nURNywf_WK_@KK@~wi5@l)2CC}28(=o_>Kvuh@6Qe)u9+%f&X7zxP!M>sULfPPfAaQ-1RYpecm zihocE^l;;!55QOoSf9%Txzz%LDUj*e@()vhN)Pp43^H3~d7sv6YV$~kBP zMt8;=l47jdOd}Lyrm7u1Al3T2#JYPv_on^V#EKx@A@36)8U2ppK)(J87s%JiaK$%Q zNPYh!*o%HZ)nR{ZHH0HdZ9tJv!}ecE^UemUjsYY98=#^qd-cA{yj$~-?_M1b#Xw%r zaFzH-4J4{%^UFvN5<|RJR|bA7O=ydEqY`t=zgbJ(TmW;ImO(8Nj$xg{4|o4pR{|`9 zR{lqx|Cj5&w~Zar(Ek6Gr9B={mdZmwS=wm;Wmy5#I^!4(P!|7=|528^|EnzRrhu~e z*#A?Ohkwe_Zu(DI?sUg@esHa4Jf^fCT=V;>a|h&UtPnrm83J&tSO!cPV5*AtD-8U~ zk}ETdg*qZ;v!E{SY0Vrl< zT26q}+H;MirSJ%>q~raG<$Pmdw^X;qWm0$8bFFa9UE9SAY=*%<6mF<2&4w*#BP87T|j8cSmh1^D=i=R!sdY zf0Y%wE0jD?c31u>eo&P`*3Rt}ArfddE?$~^HnsYZ>e+GgKhyL`1r~HxE#n{xVa5s!u>ayy3)QmhZ-Nf%9dS z{^bdP;e@3B>X19x3g%tukRm)X*wXx0Igzi(6qi0?w1;Zwim_h%#aqqMEw6YkXs+E| z0OZqpwO960?&f$>e>U#^vE@S4(7BEGs1ft1F^APv6PTTgjs}P-5TrAUBgWZZtVnb{ z;{J_v_ynB2a0Bd+WfWQZf%IE&#R9YOydM5jiK3~(JKLVcJccx}OBDIzgjeLtnUp!< z6x|~uRHQF{LOu&mL&mF^77nA&ymYatnA2{s3~cXTu{-?Mvtla=;dO#;SGe z1u|CJ5;D^S6Sw&`^n}S8y2iAS37XG6 z8}sV~CJo-s-DBe|%9@{>+FqAhk2E5olMDPVg-%{7#c0mX4Z<{yJ_wxa z(=nMZ+B!Uwg8S+kz0G&8wx87VDJ^!ZZ?sjC3GpW_CCjnT_55H{+$P)qTROByVwYG` zXoL0cMfm2_xG<+EtKGqJ+i3LN$%`Rl-L#ygu^hLK#E_Uj2ip(!artN`ykDHYebJZL zj?ZnE*b?8JdZlP>xI*P3PI^s|Y=Y6$uzB@I07UxZqpPMwcKD^lq!O-BM6n|8OOCVwcXFn7mFPw+ zin7%Pljt2+V;qp`nvO6ZEiq1dhk_;xwmOZRK4aBu*bTv9JZoO3;x3JrT}4wk@MB_j zQcHw4Wx%i46?1}EPs!(z#rBdVL!KFlM+S~M{Aa#l?Rc2_Q+cH-!5bKhLGzXKn{35V z*0=lH+O*YHDT0O6TI-Vz&Sjg_Z=f_ zSV*C}AyPi$Q)4wqr%>^YY6NR0c4tj3K-|7Pn38aHQ$g4~W#q5G-R2M_EkBMu<3ztQ z&UWvIfG|`g-H)o_94iM&q{~_!7Z0+}9pi0}5~g}lEO|ujx3Ot)YUkeCvNp)pm=XJI zj*xAQz!;ptG-a%ORx}48AJpyf^|Adw**JxK(}S5sd9=K(t}A#*(zei3E2tNzx{xJ& ztB_V?yFDyTts_Nn{cFwtXVrK%eRDMx2C{F3{sgsI%r3lka_*9dW*{r>!^*GQsWEmN;^LdF|F(ZzB?dv0Q0i$@RYycJM*F zCW_;vU@0G;#bUv8gC;UqW@|(2TR#{0Sqj%XK$6VbqmsIsZ%8O-FNOp}E7P5kMA`@v z`^AX9a#*14jYcSq(9s1T`RwWWPzx;+$AOO{m==7$$5iI`(7&bbkz0~-L}@n;a~#jV z2kW!g`Qjc~9^Qos;4c=F(P#|r;(64OFD~s*xs?@VuPlbdNUh!!)cys(aj$GgG~FtVPV0;4o9=)DzPkS%%P4aOULJ0`mE74kb<>d7 zH{U>`=0WIs_j)Qrg!$e1)u?;7tnDuqcSARcN29aJSw#CiJiBjOWl@m~V~2=Pt7s-^ zS4rkk!9y;q9kBlQp~q3I@0FEbJ@N(i_G8ZPufU3FiSOlEA_nx+iFzEQ_q-O*>wnK) z416{i)_9Y%X>=@0fC}Z2GJ%yKqm=jOi7|m>g4KkU&ipU!b4%)RSoV zE4G6>!Iz@$jA5ShMAw*L;O#pBuY;g|%^@z~KwxG(cGhKGP+EnR_Z^ZO3&NKOyD~k8 zm?8_zW?hR<&%1!Zptz;AUo?wpo~Lg#{hj;;EXN-95Fp_O6NjKN~%w` z9eTiWlm_hRqHeZ>T>k#I`!${%3xxx=`*yECvk^PNqk0Cep(qy1nxE>Z9~e)O6uN%k z1kX`oigFIr&=b86jnEz`gw10rt3>bj7+JqYEW6OXNy`#>lO{eE!xoCgGe((LuQWM4 z(WWP2g2hI-=8e*)ixFP<)iE!(Ci$hR5QPBcxHa16kIfUvq*NmYiD{Kkzir!Uo*7;~ z^5_sWuAFIM1!svjEoQWWRUNDRt>?I};xrSo(D{FDeEMSO0*X4{8>VpGFY%@9gxA`Hdh^z3}^75s8c5 zq2%wc-RNi5#0-YvjqmwtFZ#_C23Y2nr&Phzw1|*p8y*1I!Aki{WXXgUp{X{C62B<~_L_-QUEfO%=sS{U{X+eH zWV%FtIJ@iQBhItJLYG#nf+p%rg$o^FV!Cr}jUCk*9rp0)zybp!j7jlTduZO@&r*KR zBc6SGm1Qw$tQ9}04s*rs#o{JoKjzw&SSW>wpjVJkYPxfSVjvN*TwCAc!S*$2xRURg63(cobJC!{7L}$b*yEJ@>w*_>={sv6UXGIVdPkQwv6 z7?o)<6i(6A7OqX(^d{`6c^=w_;@&7Y;-oLsb^4(+8f#g%!ICJc@~?zWxPGJh}lyAj)tX4f+xY&nxx38gJHS)@9y0NgVoq@v{CH zp11K8@cs|9YAGubGqVNzzb14`L@n6eq$$(Vvnd84=Cij`X#qY-S-(-)DJ;p-!ROu0 zyK`7$fR!Xd@py4mLM6zl#4km+zA453;p8NHy&sualXR#6 z*g-mR{P)6->)|mj(3I-E31xV=M;H)f)i$lR*L}(!IgWMgn@)Ha_)&L+4}nS@PX#N5 z*e6~{w{5H;9qG=}tnrG;Z_3I}=cdG_{j`ibwLYdZE8DywXpff*w>@4F!E#A^gS99P zGhg@{S)^K`v;Wj`J3K05nk}`W72_fnM4YJZ2kdA<_TecQssE6ERXaAQ>xLJx+b_J| zjpvHWFlyGT9wvRneI$#_c`uA-!@I7cc&`H4%HQaKz*5UL*cHcrP6S_vS)VZgIVYQl#8W5C zZNf8GNeIju8$2hUk53pQtmUGw5fiMh_b~2+V3O5j=H;UrG&}T$$22Br*O+$y~`>YHNCqzwAOs{6+XoM-dj3f$^hO?IG|gGb6!I*KJYJ9Bkw@iTFms_sgw# z<_>Qj+7rL%^SZS%$kx}=TjmxVuquN3AdZwwKYkPpD}qKKW%D;tafu5!-x}am=Gz}( zK8bnxo`Y8HDex*QBTvtyDK)^Y0muPaO*+uF4dQB%vNY0gcG;g3x(Z{*4j34P4(f)!luv*(JL$0v87%`?VQ}rgSJUwHz@U63Xv;Z1}1Y5Qu0%J1{2ro2RFKI80SM^)E6!ux7fUP(}n~; zqh=H9-r>U`Bb<&EdB7Ka*bT9D;OyF!SQDa(_q@zu7!7Fgs@W1yZ0(2OQUyNc;F%*5 z0y{(2Zq9>ysjS%InUD(_pcYv^dnbH z8|ThQ7?#1ksW=@^e?q*|@tyhBKg#;6LaG3esc35Tvm1hstHZnux~~}5NE1)KF`3sF zoEs~)4u_xQ<@E-3%2vZyEVi#;H&XBX!1vlXbv0Gr_X1Gc#sohR+IDgyKj1oc3+Px# zDUYDVTnFRl__i!3`(Ab{-e=->*z|P&ttWkzAqIQuLSurFEMwSAi9c4Y=TADShtdW#O<2PxHD%IULPTV(2-E1^DonZ_z_uy6@b9(g1= zdlq$1$nexVm=osz1w;X+!~KqR&&TkHfUJdG2jlgC@UnQ;`4q{*uG#1WJ!JexA!AK= z3zXsG&~P)pr*QaFH-dqxW;(OSfs*mzF+|3+TGfJ*m~WwW&rEs5l>Ag*udbx0P!-_O zdm-ybis+SYO}cbas1VMVh=*@qf^0Uu(cIWDMOJ?OWnyTz>=g`yalPIMN8ivWIiQKT zM`LJsv-v43!|qSLfA6}qe-Ff&tVWD( zy$8RBf?jWH|N0HX<4@hXH*_;^dM(RerQaA?Kc>KoW)_DNwcX$y7Td=#A7?PNa$?aA zHwC6;P2gDeF**Nmj``~loCf~;X!uhf;!eb2MJV+K&HC|kv~^})_x6WAXNEw_-uM{d zaZPiyM%u>_ND$vTo>DlKgDx!gItpK^1~U>LEatX04kCT*K|GmnGeB;hfhEOLZ#oe7 zruAF4;QmOSQrD#9Qpeu0m}@xx0KvK?K@b)_&S=fDu=>+M_IsNUI zlu9Q>k20sm1D^S+|WjVRM`H=zih@qJ_%n_5u^f%e0Q$^5oRRCw~&v)ZjQkV zqU|kcLhXZ#jIQg8rtK2zNi0H;83)7{c zqk1P#dT`_nEE7KZ=*EO&7KJpo+7Q*Wf^Hc&Tp&JU(d!%I9gjzWziv$0dmCerWqjYp zfRG#%u%+e0wcL)UG`}?GJg2p$?nPt?zuFjRLWIJ7xcQ!b;&TNdtf;#YatOvE+M z#~fH^>k9qzHC-o^N~z7=k*tScK$y{KlmN|;;ETKmT}@M0TwWn4%EEBn;Ig!!i&~?A z!du#kLD0PSbt|S&> zt;2afgJ>04tc?owDUaq@9gh?jLykBuU%mcPNhY_=aD zH=3*&0q*cCvuz2O4>eDR8p7Qj{)X?|^72et$%WDkB{FvIE508uz-TU%4k(e~+|8C6 zhkb)>bJZx=mz`(a{0>nC));*10IfycNSv)hK-(n<@npCvI5SIjJI@_n#B8;{afM8PO_4I`XoYav@>nc{yzzJ|7uRXrC8!iW^3PbHo%{SEdy7Ay-PVxJwuTx-h<4P!F;22JtZEVSI4xB9e{ zXB`v~o}1-z!ZyFbTkODw7n|jEuMT;};kIoYuBIuCT#GK8JnHlmqpmgPQi_KI5aO_1 zC2apDOfU|^Huw4qSrrDVofg_{UN9#ECrQ`1G#e@>#3u$e02xNF!8ZIQCrrRcr08yweSyJxPjg{sdt z)#_`kK_>(yrg2QO{HmE2$EJ5J#(P||9M_=Fo-SrGe?^J=4Bd0`785A9D^9ajS_=dELRDpEGv8NY@7!aR>73S+kWE-bqw3{NC;e*66nIkHG1 zkhILjh3_V4bj#qyZZTbeyV?v+^krZ6IdxsSzJJO2+Kp#|N5+Flexu1YgnoZSz74*c zPkW0hPuOIeNWb4BA7CJrh2LKr7LTx8&VEtIYz95=HppaC&>SQRS2_L0okDtTPzr5V znMh>`ln%dF_;ux+VxE=zy@*Ep(qgErxI8YplejWtXn22&=mEa|iWPc-aaTgr_pFet zlSn9BvPBaLrq#x>gf7ZvJ%FHKJZ&s6)HF=8W%w?J?Qk-QnhcQ?3O^Id@x1aeob)l2 zgMrbt#R=@Ms)_nE3dx3u)Wa7f)_!OcE2wDp5{-r92V7c{Uy{G~i{RPf7OXJE&|k!a z&G7l~^cbGF=pop0U>!a@AoHvOBEAq7CGLV5r6a*uT97&Rt^=oZ%?0Ec>DSKybI9@eQ7UL!vivZArZpdUT7<# zOK7C9?VQ)X=IxU&gpl~smJ;T;Sr_}kGA274oSvl9w%zlpRP%R6MnrSotz>q?{7MN9)++`qCHu4U3LYY zP!?-$g_Ln^cxzE(cl%qrE0w~GpGnCY@QAy1kjV_#WQM&E)<@(c>sOkT3mYM-gVUSZ zs{ha;a)*I&w5Ny`v_l(|bP-n2CKXLIUhB86AA_vg3r{g{w;^S>&8>t>??+j!PfZ-VXRndNm@h{Fffuf0x!Zvlt#9) zx=JUl_6v&;?-pf_XPu8>nYUp&3{0qvAhj2&BI>g)oI?;rhb?ey0)Wrr>)TPOk#EEe z0KF$Sf`Kt960N#pU0JYR;?`H`z3NDgs;>p>VZ@qtMH}`+&-W88!oacP*V6^e^?ZGv zg$7*wfmF_|rE^_GVlXfR>tGT;AaufPD-!loyPR7 zMx(*gXTzstWB8!mRQIKgymt1*qs$HJlnv?`-8*h?Mv{(MiECw&dnSsg(C)XCs|-1; zm%M!@h0KcK_Y~_r*_|tR?%@G#yp(A0Gg|FTyzO;YlNp=Vayb=O2#eZF_ftz2Xpf33 zjAazvy(Vl-L01z&)TiQVvisS+AnBA?+rLlrTFji&Bp638w8Of~wC*sdbJb4x)ko1~KNupiRH@Sw}vuZDj2XGpJv8_LCNLoucqMf+dg;^&yZ2`c=g>k%jtY=wkwI zbE$A2QIWw$7KYq4@~bM;EbFc!!xML(t2k2~ad%u!^DZX#YZTOBsh`)A9CMFNOBI(K zLpyo}>0{L@qv%56$MdRmbE&_HI>Q5R3Z?z0)4M-1+fh`_7^Z9(>T$db-Kui@(eBi> zV{jrelZA?v(osKsSBtMfyaQhs*M@1*1!Y;YDx7j?`wz2jMq%6x>*8Kv7@KvG8eB@s zR(r9`2MrLdyp*^`I_Sb%4qcV)SPBhsfMGeh6ml6-?5zW&BsOW&ChX6QrT2o!&&GxYA}hd0_NRerHw;G`f&OW zne4?7zzYWL`$3|bV($>BTLE(*7@7s^j>CAuxHicq>Junz>?cywVa)E{A@iO+4qwferYN0jfrqG0@9G*^hTf3(Z!pxz zq1Gl>_K{V%N8&Ea@MMhrjuLA*c-|)USMQ>VYr2&wIk9O@Zld3%m%#}Y35Yn<*~}%= z@5GqIKNUrPz$_0b04Wk>C*si6xJ zmec31zrRC|>sIgB8+lM$xEsItoj9{!3y~}lg}yO!A#505f*yWBW_6@X0CSX zsDZI#6QE>{;zPPnv3;Gib)7Vw!-s0xBkI9gfYZU(cdRl&OdPK zDtxD9(t=#IjLkcw!rbGbl{5270 zx>;y8vc@>4&ASG1qI62QDH|U$85+mAc7$j31E@1LGV?OGib>rrEJZ3eL_#nh+~P39 zFumIS;!soaKL4EsoBs82!9V8GHMhiI(DtXt+Dz0UdR@rP)8}UTH^&9e<;Sc;Y+cA* zM`s!ZRTGA?Ev1=Bm1AX-68i8=*mR?`Qp@+XB0G~Dj)VxkY>0^c(5#A7wrT@I=KT!&VseY>7y zJad*(^2GNVO2_ijIGVH<-;vkIBEh&)j&lV$HWIhFM?Tjx%KZ}{4 zqdanil%ktM@$_=eixZwm)-wFUWer`Jhabhv`$5bFvgRuI{X|meeA{GF{CGmLcvwb>K~zYXe$C%)>-h@b!pRjGT2}7ASfl#O(J)os0Qzx8uUMB$Pix zjxkaXsesMgNhte5f|9))y|o*6s3}K6@(lZE&?%}{u2EHVd$|>`h97xYq1<;$f96vy zy0#2Xj?W75LbICD25MIg^iriZ^}r|Y#mZh+&AmJdl-jLH4IahbU0l+-nwcy^br@~3 zeOJZTixsk$8$$xtHuPeIb`|>ucB|Qigsov1?2RulXN;z6el?+q8B~V~bcS`EHFPSn zr3;mI|0Gf?JgF|#k0~Hh5ZCVI3vbYE1Gm1{WaL(Op>0sHPrUKbN*@4Vho&#<7ZyS| zuST))Gp++hF19F^L>Rq6v9SgV)UxocHIzHYGpE(Fls=qAYc3&)xW5VuE9zCoP>8mn zOA>eBmp@&0?831qsdc5ZA7cDm6i7f{bX!|>+h*3w4?k>R+_4lGO~QG<5pR4its;!Sd#%g-8U-rS6a5q1Wymi4yR`jH#V(11 zR9RBOi2S@t5=T-3O0GM|!vueeTN8&+mqb2U`hufMj}vp$s!KQAeya&(k&Bs02b}v} zMMsV~M-I_5A2D+~@q1L#xn37xEMI-=QH(ql)?&R{))%?n0Ut8!wz~_K@xlk5 z{SN(Dx4OXIn64WT_3+uK`r%E%*L`kHs+nNiiv4tGX6w&cZ=O%^Tu$wa`ch|BPyzEk z56bH#w9MCuXPtb@L)6~?^zn1ic&X$Gk@V3t-@?Y-Xh!AE!zkVYkogFuSi@=Ptef?GHu)FR5jZ>axLV7`8tsfM>474DaYAxSbgI_1nd$LZaiy_3D_L-T=kmS&XFD9(m{xlkpf zpRVbTv>el{@iiIhbSkK0{NnwBPHZ2ZYqK9(^r4^%YU%+sQ_ZDY#z1wP_;1p&YVrtG z?w_AEoEZ{Lda^66=egh*xZ{M7aev#&%jG{yeyS&ztIM+?4Q~$Ascs-M8`=w5J(4cR$kCRa zsJ>XCF-#1CRc6JR7oHCoRL7Ba^RbcR!q|$y7NI}smyvpW2jc>kCeCSaa^lT02F86W zT+)ly*|DovB0VocWx3bTgEoX-zV-@!c>WM0gc^H|_rVbz-9;j7{<#nz zF2grzlo4BRb3mxzevV3eztfUWw^K$}Eqc^a@Q2%j+T^9gxU`&^ z8#i{siwtwoJW!10wq5x|cK(qcou18#x|GU$s}D@`J`x1O)s|YhSt-k?F8vZnOm8Vm z5+7dN5A1Pu&EuJSsH}=-PP<6Gt-gL&^syln3?~a+6$i52+cC6u+uyvGvD4z8st6{let2TpsEZ+T=^-7?s(d zur%wU)ou3P4rz=2yBuwL;OFmM3i3)+&lO%>lf9soG=B83E2;UU9yQ5ICQ5Xt2F(3v z+RT``fI>;`q-F@+`HA1*5i+Le=OgJ?A42mrE#E5@f6i>Kdo4%e5)4SB+|@$OdBUNiH`iXvlT)Pms1hHQQG$G6YpV!jV^Xw(vr%`%x- zt2NA4nLb5cE~?s&xHYZTnubFSxF_`uUgaB8Cv`@&AU?jR!fbT7<`Js zh;V*xo5Aq?gqQNGyjlBf&f{Ny5JyC|p7$kG@p{M1f_e!`!;JKlVa-gw?@Lag@p~9Y zRXAZ!KAnZMjA<<&q$@HqM8m$~zbYnX8!h@N+HCt5RU9uoqVw&5-(Z$Ei>4a+HJxbq zq$^HUB>IO@o9`0%RTym^!jsXhdqpy=XPvtk(&GFzo!V12D3#&2YogC-j14+D(#cZ|a z*v2h6m?5-O8bnw$5&98$w}y>q=oeVeDOPW_N?Ib23Aa>i?%WONJzgq?J}~BET^^q> za{qjcB_8vhNzCN;WXOC7W2=20M?8J`v4YN=y5Cz}d~O_4)Tw#=Oc*kk@2z@Cv-Vhg zq*N5qKTPS&znHbUH|Vk)|620d*xdvp8OCd-RdN}#txyuGn+5bL`8vUFdYTXi_rn<+ zHcQ-)qBR-rn0i~}#&PGTm(<8rU0;H&Ji1xcq}CwP28cs^Q3RP0Wx5&Ut9oNu5oJ5b zo5J_wGj{LTIUmH?^ZDK3ah%WUzAKSVU3IWMKKyy)hs0IQYAh0G@h*)-+&bmIogKj( zG5O&*5tGPkjiOvO5JQnloKb?LU+hD6pEC6wt#4q>G*urEr>J$UFOY?&1Ulb=R}yD~ zDGOLd^@+YirV+#yJ$%=AP2ishBo!oo6mf95@Gr zG=Kht9wuYC7_6yC3)9%}ReqyJ`RF6{>kS$#{=?naMb9L8UdH*GJ=?Jx`=YJMJsZlG zDa(Ffj(W?Z>1SK{9nQbwt#od=G8m_Ac6f(Ac}jod5ENZ<((P?8E$9_yfi0z^XhDn0 z#gk94MyZjHv*sd>_CYQzXf%G+syY6Qt`RxCD@SkF!`vbW%321-G8Q4w}c$&cjV{ z&`OVXCt)M5IEph~;wa;LBu@#H?I=oI8UatZ-N2Q8_0mi ztV22@UtZt*`a|+*_Q%{`lkeZK`3=$vn%+Ym@Q*|cNHIpcq~CO_;$D?%@<&J>eF$Y= zxTdXOdlwm*`Cd^9uPs0Kwc0xjTd>(jkm&H_BVJ`7i*!2~80&NyRUE2ctMsdx@p^9+ z$4O|C-}rf(*&ueDFh^_>lz2);b_S=Lk4AAA(GcU^lWz6 zo>A6nS>vl=IzEo?r@>8^HjM;>es0a%{c_37*9wjV2il`Vtl4;aWK(FU zi!lSJ6dPU?NnX$S<^@VN?Rlmy@;SXPFf}BHnX?XQKy@wy>z-r0Ac7Rwq)qn%+K@TH*7-Fo?TS}7%1 z8QyAmG?9#4$=Ih$V|-lTQ}Z${IX06MZ?mLveS8`dG!!#(rlkM8G3h2vVSJhtG=!4y zDJ!_lblPbALA&MM-(3`vG%u7H8&Q{>aAG^1eEAlP6|U>O!@Vi|17|0Dfyr;XRKo1s ziJ<)7#ltkJs|;rX0r&4|WEZIx&Ky%LyzQ0JjJUV;PSQ-iUV2u`3q7+L7Q&dYpgWEF z61KcnaeHANO4dZ{YT3^*W>xSeok z&w}S@gR$;XMZ^4c`F3qyGS?Se-g+_zkFU!w>+F2CE#wmJDSzV_Vc__P#hnw*Y#4h# zFn_Jhd=QXy8>hy$-;=4q7aJW0xrFJ_Vy)1j6yCrv)rz@!)CQ0kOg~PUBXZ*k^{5_~ z7A6fVrj4NNo_yjJ-kYCyM(Y>Y zZpdP?lsR!OO5{q0N@Rj<$!^BuVqW%w{GlepEEjymTjh{AyRFk)81V#O1(s^~xQ=<6 z6eybiZ(thS8gJ(82tB%oEG;c;y`A~F>+|>0OSnvQAX%=@=yj}neM}FH`EOD$HVJTV z5zlA)8@_Y+xtP+gX>$Z5{^i|2L~X3FndqX^k}A7rrjVW88mL}w^f=j`tn5kfA^R04 zi8{XXA${g>sDQ8Qurz;zZuGg9)ZAr{FZFTBk9`kMiCeL^o`kBsM!OZukj#k0dufp3 zo1f~vivIMT`=?(F+V{VCvUC~gpLo%GA=@!YwG9)J=6XlZl+Lc{F~uDhn0-BET5`sS zd8fkE#DC%>8%aYglR4^%I?LkCE3h8fF`BemG7#w{vK-Tf6iG4QXYkkeFk85Y)G>}) zSvmV$&r~{*9Qc%92#R(HMbq zZbt9@FsNOun>(S0;8Bl8?FP4`*62CxgV`IIE*DfT#xz> z{<7UR;f@vR3mKlJOoPt{(^L&ZT}ePNyJamIysV3HWgZjt&6hG0EiE-Ec+r4iauQ*38X7KIXBPD?#|phcQ(6opS|gGov&2} zuQPmq?$$ELR9CBSt79yafwa7dkpIVY;_=UL8FNi`e z>@_$A)(e3tzpMmniR5ks&oAnRQ=~> zY|bEcNR{I-=eN_vxc>(4xp1|%F%ZTz^?r3<%BAaxe6QMymS$N%(QBl9Y>QlW%Wzxk z++4I=>bdUjUCuKKYvS>>zdqx2byA&@fb?>S^(qOa;qI%;+Lpz_ZM*bon&q`!;;%Pw z_27AW#EA6{I>7&${a0iE-5gmJ`-jIWGHj=%@lok&zP&kY6I%*@MKrUd?T+PN*=oUW zI%{6W+`jyCKz}SiDdREXcR`C4*e zOiK-Kr;zU)G9A{wp0WPR=@#lLi=m9KLvQrD1pKuZcPC_E$r9Ios(^UHjd&}uIAi#e zbuh8<=S9)b&p#{yf5l_ph{U9>F|5Dmn9E~{lO{>JI3YEY69V|3_znxG$7kCih5H7o zB;Smv5I=m0BzIab$#x|6*`)Qz0OR9e9f3~BLixpSa*(2Wn zr6&78={@IkH1yAAU&FCp#l^bS2BLA#NlhAX*VGUj)REzISa{u$;eA->X{(jdSM!}g9$U}tibDw68l+ZT+yZgV$|bB>d= z3&yvze=#utD^wzL{XxhOLpYGgKv5gTM2; zU~LJ35fWnbJ#L!yQLg#RQJnb_xo}Z_1COvLNLjzuAP6sH_L`OePqdg?OdEIiJl~xp_mFY#O#p08+n>vt|D(BAC5Evh7sb z5qa)e((qTPFY`a&0$2{#KB{~^m2tuM_+%6M4D*A1_Xm5ecZ>+sis-wY^r$DXa|k zUJ!K4^*_Avxmp zbqT*X?aNyJ2;s9S)E%gptxI5G`KjEMlk6X}4SJHH@4@%E3_O6Uzx3Pk02vmq>Eqtv zb)CmE4y|PIzvWDR)KRtNH|4%xr1J_WKx85YC-2C$+}b*q=|b&kBR4f+1>CBR;2jPlicf|Hp*#lRLYxJUwOyZ_1+mxAUcmM7zX1qgEqW zt`<{bw9T`)re7e1jiYCRp=nP75M$e;YBr6jltTX86HDk;B1r|6Mae) z8l&A;B&ds#;$}Nck`i(0V4%kf1D<#GcTwKV*&F!aojYoxyfVyu45CU=jxCJ2Gy3OZ zGf$0sr}O?)$%qByN;oO35Gj0SmD+;T#NWwr=*t1q}F~tOs{dR ztp${Yi4S_$#Vh&FXbqHa9MN($*KdX$(M(Y+Z}$xIzPQw*3b-Wa>)BTtKA^bgH1q4~ ziFzI+uyq#y^Z_n$Rm4}sl@`N#w8g8^nLHdaI%GXN*R&By%|uWu$Ql{_g8a~8O#@#A zEU&laC;?In))?_a| zyz=4_8RWUc6%G zLFU@dDtx&hRNA}aZ-Ii=uS-HD>5;o*S+{^ z5~OiNOU`q>V$1@yoAoP<7TW+2rZ~nghBvRJAFmU?&DI9bAG2~CSTTuU3E)sY! zV@XauI??opAo0cXOQ~(<&w&=3ws{@I7ZNBl52@$A;?M7h2P)qHT>D}Z>fu~D$B-o#gdNci@7iobW>nji0BnUJO~ zRJCOH~quX(d>JX8+w!5M+I=vD+Sx5 zFTriGmn{h|4jqJb`jdZ3yyARuz0ilkD`<vtGcYVOxiLwh+>JOcBw^-66}#6yXgFy z2{&Ysz;r00{0CzsBbpo9KsPsmVIZjrlRi!dK-djTSKS(Vp9Q29bHz`Q8&K0Q?enYKYlR*l5 z{f;$o+mQ@FAFsF(6D;qn6GyL4d*hHQnRUIVXga=iRCg2Rr&RUzuNo0D?8=dwcTuMD z|J~COD$kK(@Q^iAhu|<;j6d=bVgGODKRGtGGrR05kj|KNYpQ0tMxq%e6stUu>_ZUc z^|yoc-|10E1-wEpS3x%6un*8BhnF~7~?ru(eV{cp*{cF&F>f%~7 z^~8rdV&$YwS_{0KV1>IE!2FF7!~4zQPtS9253Mn|M|*Ul` zPciR6Pt;}M`aAnD>OZ4NeZLE1tt91$uUcgvH(P};K39C*fA}>ZCgU#1XS%)AOVDSU z1@i=%IW+;FS6wQIT6+>q@JmTU{+t=zezua~kL1}YCPeP^XQs4Vdp#MyZ!NI^uf?%4 z8O%hY^Ou>tZ(wXF#fo`VyOQ;TiMV9~vESq%?`~Xi^ejtTo;UmsAJZhC-t^6uPxMsy z)B)dJsB}a4N6vC^RCn4rf3uYFc5bCTnd6ek#^U>PYO7U+h91|7^_ccAyR5V4xna*P zbbF&~<64N9$a_`qaUp+n*%c0WZtGJu2 z@Yd*?e`41RiGnQz4@Ww3#-$Zi%Ah-{kg31`{?w1SZzokh63kvthwWWtk#Y%9GDxgv zzRa^Q07a27Dsv?XxNb}^Xbry(vCNYLd`ovrAOT3Q1k&(Ln;-$GSD@_?lFwtIrd;>#WMQ7l!pb#s`}|9BeB?$XSJa#)&6FRtiroI2GnjuLs$Tc$2O(;A{&ejib*QDPZ*U@khEy6|| zP7w!3!bW4IXm~Fzl8*B+L9G-NewOfx?>a639y&EArR>Pts6(N!KK3knZA}gq0|@~< zvPfAW!2N;NM_01ey|)EC3TEX@o3{CUO8kcyZcXrHoE6Qze-E-XI3{U-xn;G|8O!Kf z$PmQ@&SQM%p=l(b?nT+{^HgG=-#s4I#1C}DaZ6hvLGz?fj9?^HYk4zRM+(IMw=X1c zU1z~R6YDcOn zN5-6~K0Jj>eoNQ71bL;$j8KXX6|0j)WZ@}-8bn1RxAmxry`L;3Ptt|T%y=pU)J$b5(Ms8! zHllVy3cn}m*m-o*BkFt!t8D%K2y*hn`bTI|;hVm*o-wk8&a~(rRdju^c!DR%HM!A; z=sNZ!!zl%jC`o7{pT3F)DSJh9G$pq{a4wcKP8mfadbuU{EWcy8(}zZs9u#Rx3=H zV+YR@BQAB@5t~#RBXafCQJ|hMJO^+FEOO5S3Y1p9`#jf$MAaf zfdf9k9USAG8R3F}2++B!qRMF!{0sV>GY#C(pf(72rQO74#G`I9>NoBN(&Nw5()Wl2 z&Bnvq(bnUyK_>iGnkX8OHJ_ELu=~A6KpcD<&6_$-IwhWD4m-#bONj15E(N0Fcu25y zFpaY4Vdo@#OR9%%5Gq<@WX#F}nln!m<$Y{ALyeM4I*0X2Mo_W9cPUXG73>`vsD)FG z08;n@fThA!5KiP%dk#=vrrb6P$oYvJO0Y5xh%%kJkJ?pBie$H3()3Z@;_uKl0>H}v zw!D(fl2n+oU6&+x4mksq2wDh3m~d!v%H&qYk~;DSF{j95i#(tlGCoZ?ojTOWGC+|Y zmz=Z1$pPI!VT=)IfN$D8)T37g`2iSHp4Nhg5>9%W7r7*upv`wYPd2{>J|$I;%yU?x zPax|F*q%9_#qCFp|x`_$(dsG4J=d$Vj_>e6BYoUasNqHuxBq+TkE0a@3lwi`5 zhp@*$_@nnXr~`u&!)0b8DRo8^RGhC~`1CsiXa)|F8G zPBKG+24$H<;L%ljhHWwl-Pf5=_Ke%TGcd{s0(uQ!3s3Uj zkv@tINLP$k`oW=O1PW%IrUOw>24=TdgQsqG>=P8TdK$ix8?x=vR`LqFwbITHzw3)t z?r6#;e?|P5f7;|UoA$6%f&Um7QARzRTE3g^{4ToO7@$d@x%0U}PDpuGd5>e>6aTlY z{_$zdhzN{{H-z(=90lMXq?m78j%paz%dQ57!iyOb>;x;xfp7Cu7%x-d+fF}U5{jCI zCPR8k^P=-EwE*hOI1*~1Y(^*tW%07Q1XlJu?m#tD#FHuJDnd9*!f!1$U`M=b30n2^ z-r`-3CVoN-(2D0w9dIXEoNfFTR7+KxLjYuqaZQzYVwAS^u0;z$8K^+)+9^Q*Yr>l% zb`yZV0=bm#;RKuKC03qWD({poCg|=wiVz$higb%$n!1<{2l=c%I>l9YM|0zkb_ZBm zCGg!!D_fKfL2fAT1Zq`hw;vS~PBU`ku9r=|?|7cs0u;D;GUe|k50^@~PY(j-MeiE8 z(Zf3v>@>qDxt~8eHC{@tllJI2 zu4W11=HXJ0G1euIt1wL0Qq4tiEu}#Q08kt_Mkt8@!>#Kw^e!lftg^7!%a|M~|2;}d zxTWk6LzORJGi}DzDTp=-Bgf#nk5LtD5j3wsp<{_eb&& zcd_C*F{Z44DIS6@%KR8Ht9`P#J%-$Xaqy4H4_@wyuUc9D;L5um87U!gewFDqu!#4I z6V1#~C;wnPE+(E8D&wE^ay6;6_7i6oLB0z8vpm(|4hohQcJC!?-Z8Hc%5p3F<`GU3M|uChtfR5NK>@VY>&XZtC_ZE zMJ<(1n+Fq&Vs%sV@7IoQRQ0G)Qh!LByzT5==vge6r9Up!M)+6VHHyscfY$eIKcg=) zhG}XCBg?l2`5+ZO{`>9z<^Kj>9DhD~Z2R=fX{Vb1J6X2(3Y#Ij12tz_vP`(Hqb?Xz8i zi5jx~bvdFsgb#tr<0FdiC9DH4|BjqUIX|1lyB0_actY0RKUd08*YCUf_z9VRCFx0h<)Leof=2cF?Rc|=CBsTLL&Qvk;JK1EzH$bsk%c9nXuFw5B~MJKgZwwstU3(Ub8M_hC1RT zclaiayIK$KG8@Jmxk+Ddv`mg!OK#aSKc>dWuP;;t5iC`#rxiY`@2{qJC zDYi=%E#)c2C|sV%x{tR`j+b97J8+jjfw&D0Q@n)QTK?A*j8YY3kl)WdG=~JulDPXo zm!`WH6QU3&m$u%6t|n=}IW-UkAfXcjCXBj5QYEOM0%sC3hs4GMfh8XA$HWC!{~qyKd;- z+T;HF=sjN72T)k4pS<0CbW&4Qd`I%_itA?GG`oo8zQeT>yP^+T$oOsNg!J^G!cu71AfJHM zve`Q?b18F1Tf}H$=NkET-ekf=*r?7cdrv524}xB0NY5Fg)`_yLvm5ed27X z=d4-;c!~b;v3ON3)0Vzr3ny&TqD=$+>7m=aY=`IEz)kky;Un+CRasNU!$Bpc@I9ww z%_-Gs9`5$=SgD|!`llq&@S=eW+pYf;J$Nz-TL}p^mOww zecu~f5H|PkCneIkdD|D4>;Cr!k?j+r$@d>)-mKr)U+dK++O$erUafIAS8S#)a6@!Q_lx;7*io02*X zrO@K;;aYTfO|-S1Eyk zV-L@w-AlU^r7XSpn{)4bYqgIRwC(WkBeJO$qF*?$cs6Mqs_oYFc=U;fJYG3aw8lD* z{^zL1NXyKNG`s8d^*6T_jpz^=7mSj{Rn0@F0nNpK@N=cynu(o<%#ZB#Jk9e}f{kr? zNNd7wt{RQH8y~^s?C|EpeAVmNoOb@6(rHj z@3?oJ(*bAWOLLT%tgcYsiyhbdfq!b*uk5-L;5z7G+B;n)VifpkDiW7>fKj!?4#g zrIBvv1--G#2z@V-FJ3LDx*YLRZ`VbV@O)M;RRH{*XFK;urB=m#ANKARr#-Sk4{NGh zXl0ukJ#Kqj^Bm;`^5MKnZB?Pj`{d~>R!c!_8e4mzSFA-C-gt%)Sba~~`5z05szC2v zJm`WD=c*!glT=&xjxW7>#V$GdopRtNyJMhGqh1d75HuGQZ?A# z=xq$*nu=ihqH>+c{Cb!r;+v|s*>LAhxnP~bnlet1RI$__z>6Y`kCBHGe#^4di1;?( zXQ#aP2Qsb;z|Y?m%F9=#@{HnWz^vm^m4HO|;q1+9WQagoBY3J%X)Za``{fU|ieiI7 z^W?HIr_r*v7RCkhvgqV+mV=#S>mB{*O9qqGtrBx7v8^EVb0&sxUPxio^ToNN2wcC_ z7^$AcHIWt-J%M|Id6%25?J461v$rvdpKq9EuQ2QEJJ4PggY#P2mVT0 z>ql40md{RBZ*o3AqnuG2nK>#cEEhRqLk=s~DdcH-ecv+ZU>d2v>E)M5FH0M>YM5KN zpHT|0_1s<`i^R-vx@MMgkUb_{;xA^%nt>prAp%Pb0m>ONa@3|zi;pVxzo8~gE8t2o zP_0mCN`D0&;7Pchm@j}n+*0{tmN>*TA0psR6|N)ZH!FDA^KKYVDf0(&EqNq=@#}uZ zg7=7n{?H_C;G;XwxX6F(^t5<)zf|h@iLQq-SIj6+lX*ivv+vT29IL8KiP(XXGN?|I zrT-aXe~>2rpQIqR_@7MtA5=u^e;Sd||H*7qqyNcSbF5@@`(G7G)5h2;?$NgRD!rGP z-XzhH#Ox6OygO=T0!~Jz=Uk<5;q>rW*V4Tgu1rb8>>bXEOdVPzTqXbjeM=_1orICO zMXM3UO(Lf*%Vb$wy!#i|m~yeS`0L+SNj-*!ewRG_AD9gdl|L2$Sg`5%#J-hMLNrvY z$3DS#3Gv;=3UgIQ1M$0U&&AX)0LUbW13EFf&_p=pwyao=sRJiI8M*yO`#{Y=d`s1}IrR)W5`lz$crwry zF#EKWSEz#xd>1I{h>X?%)9!tTS&~$<7?&nQ&567BZDOTa}UTIXjY=BVKHl3Kt;wX>;})WvsM~q^c6mnDq{{PGuddQZ(to z#XSO}LWHhTezIRr=SCdy9|sTa)@1&IK+t4hcn=S8S~f}p%&3kFF#S_mUavRLxBCgv z-lNDs#fzwb>R-ok6?dhC7ZjYPYPsNZ8_mXomYik>7s2Z(;kCsj6aTL1&|T3y@-7F~ zup$6*s$F+IF4iI)MX+NPVU6wdZ=b?WF(X`_>za_gmwpT6j>Pkx1Pp$a*TunFb21DC z&ygO6;6~a&@o16eg#BAqS&OLD-)?td=<<{iuN}QR!odZOop$6`tB7D@unNVe$uor! zPkgO^&T0lr+6>vLX;P=ao_}K6sr9dR)ieYvHEyjUl*A-dG*bEYDU`<5XL;`1BmcXS zH1am8zifSstEH7;)x;6YH73c#vcCE(<5VvvQ2ZB|QG+T2J}Vws=pbQPU0j>Rq;qdL zHF_x&=jZs6v1W&A;Eh-ZJS8%z*WrWaeI;M+VP>(oJ`eqjldxb(iXS8KWR}rDZ1wQR z(u`<1UWsQDzyewcK8I2VDcR~`En-ZH{|MTX!OMV8VuBkcE4GyXY)Pi5%i2np zm?x7mRdQA9r?ZW!GyksNSK%Z&!QJ}UyJ3S768w)eX+}sDm6pMi;WEe0Xdq2*g{!^O zd<<>i*yWt4n30Py>JsELQ^7oLKqgW9a>T>`71OFV6v`d<(KJ9(R8_f`$30dvjjQ_| zvsQko8FLvo24GlL`g+8coh z^`=I!^EpT-PMRz?#G7WzKF(^5Pl3sr#LVJO=Q<`uuW1RDyVgZ7Rjf&2xOD)t(r2vd zHM9~i$jt~3zEH)A;_>_Fm*j`MgaD-c8Hf5eK!Akg*MN7QjHcATv#=}i?drSB&Zt0a zReCFU3(h}%zV z+Quv4qTUImxm3WIX@ps6eNN#^#UDlmr_W48!L`#S;{wr^7P^IeUPm7awc2w@_A~7g zfwpE0sk%x$5$exrB}DH4>QQEMg%5dIRn_OW3tajtP18R4&~y-fL{4NHTo=Fpsf_k9 z0Iz9-uL{AwTlN|)gddUJlL2+^{kQOnj95(~V{IqQ z*c1vrmnh<1P@llX@v+hu(r zp|dzP22ZFYRa;tj z9z;UIBi}+CI_%7H5^B9s7uL<`+Z!gih)UOrbK`*-|Q5Kf{ing+H1=$-XQGIjA zdpy3i;T`?~k~OUc6i{!M)PH;YzB=KGfVRnq&?FDpENPujMKIqMv~%rm#)8xvi@_C*yr`n zn#XtjGD5(2;m#a_l)4e=onwyp=yhh#=}Z35jFY?53q_nP3f(RE2PoXAJxt$J=Ee{e0|#~N7#gm69jRbsG|J)zHgiG4|N;eqfXhRi9MDE zZ~=$xYus~^mFahPIIWx;?BK`#+BoDjuk%m*`z&z4IB7(mg#KbFZ~QZG4SY?rOvL{( zMR~BjG2S4-H6UI=_s!t6KL4B27s2pGe`A6mQqZ@TAd=TN149@k=+O!E-D@e5$;&y( z!4QCx{nuJo0c{Q~);Q8*=S_VP&YeQO@t(o>hmDxRK82Rm9oN@TmnmFm%QlEmfx1mw z#Q+aWV1I58gWw-JXcqQ;RITwpm8-CE^@4W!3%;MH zZ_6o3#jgu?6_3hiUQ*pKk87cAQ!8P?KQwlwhr<0Ih%o&|?`_tf<@OE5(~{VvHauc3 z+v#DFibd?V<9>}JUir}g!)cZBME23fr(%850c$O34Q@C)Op3{f-|hc4Ph|G9tQEpb z`kE;oUTj>y7ul|~KRo?wAj??LDG*-P$3kQ;-dM-i%K%nrq_r+ zI?(3=R~pzc>yqgFJ*}@KFopTOd8qW)7(|=)9cLGwcW7){Uu{wYB+GJ7IaUdrEohrU zMBP?F<$$xpz`)^qKJp~0hR%(??HopoBh4XMCbIt2sv|YwPV6QpD)a) z08f~6KLUDg9x7NZ2zC(+Ox)-3<%EY4t*lg1$X+*3|K_6yiwLqL3Q)Ek7~SC=PF6-S zUzw68uzoeV`c4avC$WhPfb}&eunrrge(y%a`_FbA|J=oPn?z_-OWvCfEZ}2G@w5P^~S|J&cpZykE$mz@FT-dkx ziq7}+GX(Mj2n{fE|Mrxs?c!Aq@k;RrT4sDREvV(V5q`BbukX>2CuN(8XufQ=^-}b1fRuMRH4Akz+{!e3n#P7R-9n=TluI?%6kRyThm4JLuzng2=8}W+P0!G zTbj1su~jsml!(l^6xb~!@k=m%o&FyMtm}srA*@1hU$a$OxUbFr1mm>woG12SlJ5!- z@UG-9ld^e*7wqTn`z(K9UA0msXi&%(_ceFHcfHg((v`dy2rN_*`>sR1@h3v?P>9}E z7havqr?kEZfXnu-`PwfTZ2RnZr8W_-RJBn?b<)yLz=F+;6{8WA)lu7=_`+Ypv--?L z*v5^5=32I2%T${+7l(hw8n?aOMow;hpOKDLVJ5;3+4Uw$=V=kU@7x$KL?S9DcMyeR zWtW7-74i6vjaB#~zwGC3i_a<6gqDZr^xYXNT5s6pPExhK46Ezo{;I|EsRkFE;#;S{ zOam`wt06~P?Ch${xt&|#v`*MrY>+Q85!p0!f9d01$|tg62@{X<@Oc~0Y1=$@PRIP- zBFxc;-#3S(7Ec(i>JgYy?PTUUV07o6DuBeUKoba{Y;&NMBU!m6DZukKc`u9;+@&fV z)oET*VVL`wM7TsaRp68givy6XG?3iMgw`+F(-QbfbmbMjPVXC%k0Y|_K_noY=9c8* z{7==JRlk98q~}C6Hq7OQNkdu!b*Yb^2I$hZRY4hWTBk*=M^4_oE==E1{|1Z-+rI>D zJTEAM1oY&sw&x-2Ys`YM?{og1XvSF>Xoqt8-@ERFLcbo<%SjWhNbT@M$sgX@jQAt{ zYtnaAcY>mpf3NWSek57t8c}l9xn)4Ia&#?Vyi+z@WP2WbvNE&Er>1ZAj6gRxa;Gt2>Qz6ReB#j z?|Wh!h%p}c%N!HekZ+dpU3ck=D5gA9yA5X^vkku9YZonjsFk_W2Y`sL5*IhoN=zvT zN>Y=bktxGy*6j&N>T}|*AhtoE1E9ZWj>TlJKjq|dW06jzSR^x4f94o6r-;}#qig$& zejeqKWs{1apHtGTn}C%KC!m*bT4maM`n+_!e;9#MGtkb=WeaTuD>fTQeyo{sl?j1; z<}TUWalr*{Ay~8WgIGi@=d8pausMK|5h2JfoT!=dQ<}E)tSDworIDx;5g6axT(yMA2UsyJmNo~%OWSO&T@4SbeLj~p!ExuIu>D9i_+fc0iFln^4 zWN-d?!YF>pMG!kLwileIlkp0*g$9^=*7g{nmzq^~6)3_K`weSV;F zmP}^yiB|GXopD-4?pUBb<=f30y8=S>WqorxKHR=6)7Ji{8957aob_@hGt0zSBsmt@ z%?aM#x6wTsG}14)*(<=GNdMQ<_ueUBbGJZ_c9ZvzB(zt*JH;DkK^76;_juwm9nl}? z?9w*NVCmwe;S(jFg#vH%jPX&n#WTFeaT)o;>kIpciw%(elwiRs?}ViVQwuJvY5*Ur zD#bdBtoBBSGnBS1O^lalCHluGGws4+j%+F-IS}fkPv3U%Q5^3uKuqx|`_yvJ8Vg=f7d&QUrcKlnck+m|DRtl@_YaX`~@x@ig7x|DkV7`4q$4U43Id;Q+lo2pqq%+PG({o_H=?@h5Fdy|OT@=q}{2 zJvLndbJHVYV34m}#s$bG;dHc6B~m9^Y)wf?hXpcbI_c&xEM6@(iqO1f5{tYDn3TP^ zKDvnP?!8z!xx?0>QEy*VF@*_+S#QnrL7Khk)$350#u0_UP96xsVQcK({*RR->c*MH zj&&N@f}02!)8YNQ^myU*JC2fPtJD|Hu;tBrO*FJaiLRaJf){wPa`$nBA*744eS)2vH26WlN z7`SHZAF=4V)(Wp$i$LD5p@6LuVMHah9dbupsy6{U-I?l#UoM`(ZhjR2A?`(+Ke;TKab5-c(@gfKSuN+>IA)yGNuv=&*KO7$*L&p6ArkWwSTeu=APp zLj;ii;H@&c@s=XV2KK-Kv)*|NLPwq}2}5@74%82;9(;fQj`I7$gNoyBj}p^x2ZW#fx|fE5&9 z-<}iLY8djq?jI-4piCmJAuDeq5R^l!po+V;TyRU%uWn#YIwyP-eZH&}rS%qu!*MZycZT1%!C z3*_(ijeD%_xgl0ZL0wx#{)Mhq_Sv95I$D)k-TOrXX$h~x6~|$0PplB}KgxC%jzVCt z#9(r|)jHspUS-97NJ9Mx!~5%Go1H0TRcL7Z)Js*B>!~S97!w1d0K`N!FgD|?ti&O9 zcsDpUF4-o+wRFVxaVqxUjEtOC{$STnBXjY?$t!bHAXJ`Ei56T^e$NLQq?YM<#Iz50%d_a)l4E*;^xvuNaq&sq!HSK^5hksRZmru({BO(?|CiXT1wla z?GEUYY~mZJVd50lJP=_AL6ESNXY+_td@UzZ+n%`vHpO#S-hg$dr=Hk9gWhB4+H)GZ zfiCcR+IGe30pL!plFF`Tuj8Fh?BQvCu@7at`n3tL)#z>BlwCx@eahduU6H*9%J$sr zWS|Qm^5c}{VTVU-9b{pZ8msHX>h9C0#3N!>X;hESTK^O#uMl=x0Kv1NCUS3de zcwGv0QUEXd5A9(Hj5YCNGHHqjp68aE&`koK=wu>k396OKzd=B0&aUneA&Mh*$lPWD z=+Lo^xa8g6E@dP0!z#l|I@jgkr`mUhM zejX43V|-H+d_~Dqe!5%jDR6p4513D;}g(D3m|~%b;1HzD^?$( z$z!?~6TqH@@4&7j?0{K87yTJw0uts5Z5t^ArBSxu?iyhaBWH`QhJQ;~5kXl3gT>{* z=rvFpujvrRA6OEzqId$T^FQT+H9-rXLO4*^(%hldBimpD`t~xExO$yHXv@eQwJje+ z8nKhOlE3>()#Ynde=_kZ(UE8y2)#leLe)OfucI#f8q3O;FWH7YLxOtB_9B9MKzmb+ zMe@pOzlZwa$;KJ5B4H6!$-N@xELh^R87aD~E-dR@F>*)Qq=VLe6_mU(|DgzU2>PK2 z>!dajgb0bogC=CoD@QB`?|~53FTGU8>Rf|`9JAuD!vC-VEvUnc&@DrDJm^8&;8a7t z;8h`*U}Co*Wcd{viH{#B;t!4L46trUk-ok43wDs_s(WvUAH1scRlMK!LIu4xd@l&$ z@vDukQ-3iS!Fek4RiUn+Y9nqi@ENU*{wL9rNva_~YSrqI$9~9>xuH?eq3WmTbT9M_ zmaA!U#K+GHcJMrwR(6@gITi>!Q|qA7PG%Mzv_Y3Y-s6Cb#bGz4w^Tdk{NgeBpEx_$VK z4=jxGNDxx{?;cp8O9YS|i+u?@F_=oU(N=96(bG-<2JkdWaKudwjj#~=0WFFsMIaV5 z)arHI99n2O?(zhi$w4aMPTmKN-5^KLUr$sGfZ{abpt@(GCTMeB=R_O5UoT+t1s^ye z7u4SpSKN$Ln*=a#XKR@dN3f1$2yXQxxbCfwn0MbSf=O7pGpqZrpaMVe;Yu zvK%*+ze{R}+tnjjtoR`XnNrE0BBse_$m}(r9dHV`weJ0t>hPfkG|#+g-2;JU5biR0 zQI$O3zqKtPiBJc83Sb>dOATHIjHqoQpWt=EKh~MYUV{(gXoK>==M1Lm-?;A_-M7BY zjP9aKyUXQ3oMal@7;zy`Kz~s9bmWX#!hK3%c0eDJ996K}uGL(whb@eMqGCc9d4}k> z+4}S0`dlghTv4nEfJd3{Z7bn))rD1~m7av?J=9gmV!Gufaw_}Je>!LOIAS87}XK>Jr{ zuhxwij(oQ~%BEM7=&$81>BZ&k+gO6;hJReSlhdwbFEsbR5YK)=;LyrxDS)E6&}lTz zU>KalA7o^7(sI54Vnez+)|iLYzlO0_TUpYNo59*&}BaVuj7Lniizz=S> z!M(V%tRE@>hEIw=RE-l|-~9dI5WyWdSj!-#JPlguafsm(>c3T7_wQ_hg{wMJE<|w- zP)06fw4Driax19CMl5L&goA@PZu896^alQL-6t@1*^~Qc4N|*&`UTYDop?TED<&J; zTcr1?1eWVa2WLM#w9CNXJskC8HhnAn-YQF=e?qbPO!M18w-|2ab_@k)n4IQ*qGK&A795H;( zotE`-^wQ8lm?Pu%$W@Ev{y;4V zJ9txl5|Nd`{srZ*;QgkNE2&L*z=V4%@Xh#emV{OndHoe1x0U;o0AulX`Q<9LPNZbdQS!8R&UF8GUio{@|-Ilp*VInNl4mlI2NG zGvNwzw7@Epxo!sjGMGKKf7;HBMJA%nu}bcY-_OD|!s10>0aK(+b^;~6oW(mA?PeCz z;Z=i=P>QQVn`PMg3n}b{M|mcmHQN~LezM#b7?t|PY`mbkpO~y&o3+9t%o&J4)A*@Z zS#z;7cb-+ra|v($WYM}a%1~a}o-N|KN?;5Ss=DFcP7vNt0W)XKQo4x3^`|wlTvLdQ zib3ua84gispZC{<%#28?pF%8tR@AC16I44~41|3}hMhE>sYUjq=3E@=trl5PYE z=>~~QcS>DK8l*wGLy(qku81_!&8539UDDsK-=8zjo~hGwW}eyIrq_&ghki6{@}*(6 zGfuPvTH?7M%~oNCp=vLpcu)> z=H7?*HkLp`=;V@>G220Lio zGY5s33BP$LtB$#OGB)mEpB|IGB>g#F^_8aL&4lx$Xz~#`^m|cam=P9^2A1Tf8P!Bq z>ZXxb{X{qmv)D`#UyXI2Ce2ABA!Dt17rjxH3R~(H`d*--S&TdELhFW#lW9b90l--+ z;EaQwzd(WMISxW3gG71fuGmRKiZqG%747pv#oWEQ;`UKGDi(X{DYD*W5e_O*d$c6M z;36v2&hgU{@ArTEW%V~*_Y8!U&+vM_4;7x`{_QUfX0#5`AkP!SCHy{AludV>6pJ_g zowd*g*Yir$Sb0vZ)Z>+M7B1;TviciFVREu_etUwczz<1(%f@tVejhiuSPkUq$jnj& z>TvHfxJz<47RH~-JU_EwV)P*$+8iEX@Dbs0<`*3z&Ei$-?!1;o$a5<$OWyP8^Ir{V zq-gjOh=sECWRw`#YZ!g*cMAJs(a%XxX_EL0NlfRwTGI1|SAqx+_6q%cP3R`Isj>B4 z)|ZIz>lh=if_Ini>+^)3WASj~GOP-v3)dOAE(RW14Y}9d!uDf)WQf}G>6gb+j*9i- zQ-QNcoaM3aN5w3%3uE`RE;z(*u5jW!Yofz`BxFfGcj0MNSG6y4UhaA=mHjJA?j3&G zc(;d8QiPRWzd;4(v#}Xol2`^O{_me9LqlzwHMd?rExE{KmgX*rmczMEv$3knDt%`r z@U%rSEIG=*0&Q%bw^STo1Xqnb?}oQjW`h&$@P;L?U-gq^3bqd!5_2VuoNSOQ)>sL5 z(|%DHV*Hz}cwIxZDAi46bd%p?qw28Lhn_HlsKd^3Y8iZrjltlARNI}^kerNzAnG-GyBqL6lB#pPiY&gV4slw%t^eTUzCN?HoJ&HR#EKz#P~)oT}-8}>v8e814j zwA+dOl8=(5Kkj$wOOV1knjT1sHSJxOt2hRRH}J2+Q7q}OGiR+Os;;<#jgBl)+aZri zFAiJcuoo^oC93ApgI6lp)kvjLw|&FsWUX{>ax^fgQ1aU(bKD?NNH$_)Dxb*f@UV)| zC+*kL&Y6R6lzxsr2vW_5&x|{&_#NYM2iPvi zb=V3yg$e|_T}T-Jq0DTp^IS$ld&8sV1Ky3dq)vlsT6CfUr5)SiSH<#?i*I}4Sb}LrIc@vr5 zvgOjQSuX4)iecF1C9aR&f> z)9i=;t2m7=6@Px@@S*Mf^CL@1A+wX`SK|Q>sqM?Fr#aemBoluHf~)G@CG2HC zJ#DAuPahsw+kRT9KFWpNzK`#!O4`0W7eij28(Di?(d$xY&+`5D3u*!{v9)!Mes;3b zoN?Ev=eoy@k6JWN?mpeI8OL=oj=Z|q@y3X%WeffoZcNMQP*{cHl9`!wk>WgVmI_;z z$P+IPc24ZMD_NsQW3nU26hi8X(7)<^_4BP0fpDhz>CSBPxjE-n=E|kM+I_byp5%Q> z%I_6LHW=&r-H_%AeVc4IHX-E9C9jRjoyss{OOjN1^=MRZ=hVtlS2V<(PHRTMr0962 zom-Zu1;x4X6w8JCKY>))UAcLxD_Xy>aOQ&;GKFH-{QJ1u_{X*}hdK&@RP9}*Ug{a^ zJ>!@!R48X;B0H`dM%no&S&^5hIfBYwoX*E>;ljHDeQ(t{RuZub7DS`* z+fW=RDpQ}^)Umg+=7@>ymmJC5PNZP-2ocAkev2+N;UvWqzpcZ0Oe2t?ufxgdB$0U( zjBfKDtE=pBIzO8Ddu4pV&8mG(CPa6gEQEvm{&v-=-DLeibI_`nW2#KI#9Ot&$*l=$Ey3Qdzuy@F7k0- zNs&UVx5UzvQrur%7|$KUGWk;^_^3~_C4%`JTU1MSPde5$TFgE)=wku8^#l zpAZ-Hr^eb<(0RQ`?5$Ff%hwE{dn6eETT+|9tJBv$IXmY1_Nb}I;XL)NYtJAr=g01> z{*PX&q$0e**8Q`tG}NhuneTgt*OP-WY8qr1`)qi zw*~(CVoI;?VoS``ot(dvAnj4eooQ4JdU8i(PXU<%7Ja`VvIO1`CFT|KJ3a(=ON)P- zkixSpSyKGd=M(QNC#pl>JQ?_-JY7D#Y4YkWo`Kf6XI3KAsmLwq1Q^lVI@APls&F;d-3@2uEiZ7yYwSG7KB&Ql ztryDdoQA+5d?HGuEFBfy=h}kaIMBome4h+{^gl)YjB|87h1D_qOvZcL_m5(7K2|D2KeTx^BGPO6zfw=#7ncR?^{Bkj_Jm20F6v)?5Tx7zA8}Lmv*qJO3U^h ztpR+Fk81&S8ceJYI4}&(v`G^_=&hNvHE0y2U-!zu?sB^qHVDx^jq#r%@U*@uwQFVJ zc5apEI$RuuXH#;w2i!A@ihUR(F9+q)R z{tms5*9#c6l%KT}Ine1d}$; zt5J?!5!6R#!6w)s_?*S*Ofya`$go$%j~* z`ZIn4)a`IsV*qmr>d#3m&|SPJdH)P5Rwg5Rh6C7?t2H@TC4Cdl|4gxPavdM4JM?jv z3{V`mjBX@gP+M|2xG8zW^gLqGi;_bg)*aReIc~h~Q(g9B3W+3{?T4ur@!Z!hp?=nd zANIq%OVXI?`6D6T2QRI6br3Dqmhu?By~C<{4CJxEV8aOx?*R_C{emA>(puN;X9DdSS3~2=&xsz@pv(r!@gUoi3dZ@Vkb9im#WpUBf{-j6)7x z4ji?*y6^RQYo%>mDPYYC1>CE`P}0=saosgcPQCA^=x~ThgS@5w??c8~`I|(3nkt#} zPdGwcRmxt3fS5!W>_JKUCC}-1IB@gR4mAZYx~kAGO6m*nv-rp?#I6)`Zzv;3emm_p zh*iT-ed9>(LKcON%eZgZ5wvze=Ymc?aIW#M18~op?eA`&j6F-F@IW_=ud73aNg>Qj z+6fT6wb}*il}7GStyK0@72&Nk& za_x|THY6-CN&Qxx;=xlKsP<5Y**~*xvKux9o7Ay9qCyEF>t<5Q)n_~D49uP&tK@X~ z*=GPQC>XM3B?fX>j$Ie-OEf-ciDKlm@k z9HN*FftnT9nUn!o+A*H3j)k}G`|4X0a)^q(K-7i7sbLU}tbAT{0V7@$wGp_-v4>qNd zzx1VD?Yve7ty$<#EXX3=>A$c`eZ|q`poFC>+KUa-6frwR24gW5$^jVZZ9Jhu2#Rx~ z4a@M`Mj6XyDQ{3^+MZ7VlIIi+Br*+04o{KS*1XdP^gy{#oHEdWE!eMlX%M^@2v)uw z|HToJ+x`Tw_Tf|w7~9qVX8?a&_Os3MuI{V4L?Ksjsl$vXq5qtlJ}YEs(n@SN1W zk^Yz}g39`K$^`Pl?)b*Rtn!0r;B#0>EAoIXND6=R+isv=bPByXoabCFaR$e|Ry$r_ z5wy9`Kii8@b6#f{^fHj~l3m7n~c=If{c;y5aT`2p6s)pD}+|lwQesGDR+iFO_YIW`SL7 zH?|<4qLQ4SaUm3L?GoF#IxA#ySWk-})dNSZ5Q7N}SV60M{~63wd&)aSxSb4!*Xlk1 z@yfNFna>}gXckun$uhW}&4!y_&C*xyg+PpRo}HSYgJ^M2X-805AyqB($7fi9C%Qs8O+c+pUi*Y$`hD(eYVw6|vMG#vOz$-an{y+sphUN_jvFiN;%!m-I`@>q7;4l5~r# zSzK7+Qw;x0TU5an464eFXDN_d*3pY3)b?bNAPJDO6;?pQ;W)iV{=yi8!w1bZIKc!W2!?jB2Pi!nf}|z* z6lRpxXX?X+->;;8U>Vd}8D-}6qf|CSjeh1OHO&QtM?5z~3}Yy$P2Q~WWT0TGr{1pe zw7pc&O#EwHR8Ll5^~T}rrj=BK7{CR$dNnFA{E!+q4&SWvkHAOWH#>xS7R*n<{FO`! z39te|rIYw3x&hRPukR4qdP*90=v~8BqqHHyFJNpzrvzMqRW2ml5TMPmcrE^)b`SP> z7Ib_bpp;?RW{Q%ivaQK1`hd}X*u43)`z@eO*Kc`9z?6{hRWG_7rgFO@HdGK$EGE@N zyp%bg@HIxK1Q@%z$4(XVfk9#MsBvRH@ZCo+$ha2d8NLEtFo{~=C9E+>i@861-%RtH z6=;<+41*V-FStbri$GPi_6btLNbT!YjfrCx$;yTzB0eFs^z7ANNf|XR+Z0i=KZPxq z`)Y8@thA=;9jG=*uC?;(9B3v=nh=@SE1x7bjcK9aKT-7khqHM}o>K!-q z_f1pYTM{ACeM5rkAkgoN@HIi#BbH)z;`-sIP1|MExNw6d^=~OLIKc^>~K zkdm@vf%@qgswIL>=f`viDmsM#(+S=T*H=yKF(xv0Q9J>2<<@T;lwdGzEeRtJTvXiG zi@;rbX!uob1)BR2!#m-0V)r&!1i}NMZ+FN%j7wyEreYlT8|dNlodH}|au{{P%j!G} z`jomVrnjQkzzx%lfiYJixK_)ma^u6G4TktvVW#$v>K?QwKo5*0&9L#NTQ`-`gzB=o zx2lA1Oto#_GcSWQqM7$`0KunNR|k+fv?1yg&*_J~rMVp%po+S(8VZ2ogKu?YF_16z zj^>-65L@s|ZM70m7vlXIfZ8Udb>tV2^t=l`KZnNJWhKsnYf0IuAh?#4ynGc7`BGk4 z1Eqz!*gZ=k%m;($xBkySKaEN|+QUHm?=^-bKtB}bNYEnr&7T4NNGiGIdWU=1REgtb zAYUQzHO~Pe$P0gl0xny~L@sUGxZsdjEeh-jrchFK zGyGaegV_;WhHevi*GEZv4{Eh^xG`bhE<+Qq!ZM8fBzNCtgF#zgCj{W+p;SZpcg4~} zVvW^P=*)qi_Ai>ltb0%M2Q2s)rXQo8-){&1P9F0yNyHtw19OQmxKj8OV1dehmnO5I z78=@bv(_NU&71-9AtMJIRskh_f4nTb)zzc$vz)$AFHyh$9}uhkPvqzIHR=3W>&yKX zYhQ#K7={Xu0ozz+=mklBWFQSIbN*b(J<@v^ye_l(5>U~(p*gruxzU+b$Q(Y29JgbF zc9QEQRf8^}Z4T}PZWL$b^poB;8HY(P>lON&6M$t2CXA_N89)Vh^=Dh@`6D4S+6*jcP3(cXW%VdbmOz)D2 zEhD1M1-&VWg;(3Yr5jHXXjv$wBvjdF3}7}iSK0%z4lT9s68Y4iy-0VMUmGMR zk^<;xuecv{$1Kg>urnto%>Zh|m!_t&Q*dLctO>gRUb&ad0v(ZI(tt3+7kZ*S1U7%B z$pdo!wKT2iQ9n@A;;dS|`Ae}0C=?Ygsi=vuliqX}ieQCcPDiryUOY;p#UqC77 z)vOw=G)mi|+UCvpu+>AUQf@E?XO}(&sXPtVIbY7k`$k-bYj`XzD~{1<9oKH@$>$#5!vl5JU4tw93-MGj^-B2w-GBOnXei z(`6AL4;ZDUU0Ij#VnA@Lv5HIs1n|}~_>c73r$Xu@<)w6MEW(XtcKy{ZXA31vjJ<5r zE-8C>PNpJdn%2zK8Ar|9Q+2@cO7^Yhld@6Enu_7G+|m~Sts>uTULTfh8z-IEARf+y zOUEmFFg?h%?Wu?7$_y@I__JmlON-GE(jHk_n%YKuo%`+tAA=yxGoG4bBnX?I4}cU7 zf6NeQ&gp^BymO+ z>E49w;yeB9*zh?EE@-3=gWIMB0{XXaa*_}cbIULV9G3&6}eekgpf~I`7 zpGp?0^4{Aot^n6j$W#hAGGG0e5(06zFhwC$jedEivW=6nw_PGCzhEZjSg%6>E%5!d zcgF+}bX}GaR(6H1af|3UOg9W`@gjmc-git|h?!WfQGR0sGw1xNXwayl(&wTfKm0NU zZTO%%4<~!hYY}&NQ_A6b+c`fji+c_&A6NGxY!Jh@u^MeOhb4Y3f^Jw)rNbT zE>YPm-O+IVwIT2tIN_DPF26TUa+1%lww zjZZ-ZcqaF#)rhN2c_W?m2^UuO?XlQad5uT@{c>5fU#IQii~C}w2MpNFsNa-Z7X;%z zPm6DbM^B=ybenqxxEcA9n>~EL#I{maG$gC6BERqi-=Ox*q~y9YN#(4pjCDg+PeqYZ zp=wV1ux8ODepb6}&mK2Peyzul9eEj}U?ilvqU_5JIZUyIBHbAvv#zmch0H7dBE{{V zdv?3ZyPUMRSy4ZfgE{&E3o+Pf#}n;mw2iw}JjQ22M7mXKZPUdjG^n2N8C;w9$^^he zHe?$zHY0Zy7LD42r%*-XRgw!Sglvg(43)wDws%Ka)vL&lVw6ga*^<)WLWg$4SK{xhXYF zFnZP=;Y<@_bLwcy$G#R^2yQR#HBCQl{0+9sR&@yFYLaiy3(UB1g)T4d&< zXjcWpUQ*#26*NiJkz0BQJ|)#Uv%zEP&bVi&2*&ms&1V##z#k`eD2-FS%vaStwVPMevRhinSl6SjpYSG-Zr&+Rv#Y zmL!?$!Njsy+V(CAV83+AOSrSbg*$(UW>}EKsw^Bm+@ctH=j7Hnk>_pn!ZLW^2BgO%u!#1UImOEATkERYhNPz2AV@v2pQ*chRcOPmBSIAG zavHhLs3`1YVj2uZ0dwx48CFfNVnF}A{Wf>U2fxS0D-@B|msM!edLV?Azg3;9YlLTo zg^x|+xxcXpn?_I~bWL#UyC01#$%GVcWB4QCICFLGaL=wn+YB%=D3p)i8iiYuKi8eVguZB&R=T^;Ys=Izf-)RITJ8MC;?g= zejj5q@ypm!Xd}4c|5j{kH(C)5xPfdr3TP=Ays=H@?@8*Wx->Ba3V1lWfcvIgb06O$ zDzL60dhZwZsr;-;prG%c&4F8*b7er26erqs)d$s)(QV)C|Ly3k#K3LVVa?5o!g-*|JMLCa5K>oNq5iWEHZ?B5J?uBP$k(?B0k+3OX_ ztL0_?>XDA3!emh$>+3;3^*#W1%;)*j?XO@r!G87EJ#dKP-#kE*@*Udc3(sLn;m8W< zs8A8Sd9I7DW;&?ZpaQs|p;N#I7_;fe$I(t@Fpj}#6pS-j!qHCnz(s|NP@?Zol|zMI z;SvneuZhx@rhbe7joLUJ5UWaZctJJ#tGT3RMbi}FI+O&uO(4o#T4aNE^(@tn7%GNQ zZ?W{JN{DMRAdLzPK`orfXyC?@Nd5co3YU1X_l(uG%4o*Pjboop|MCs24oXWNSNe6P z?eQ{kBG*D=P%Uk6F4F2l^SyrIDp=a~N^&HYM!zJp;E5t0bk#m__xHOX?}Sqa0>#MA z{6l=j;P2+$gK^p|!947k__R9QY_;^nfiG{r$b0B^tD@CXsPbqFWTG1OPdLS>rB#Np zxg^n~;thD@RWPJPo1w{jqQTax?C@#W*BO)YxeIZ}>X@qs#))S(g~`{fxLuIO+VnSH zSuCMtf7d2YHs^@h6uy9wz*rKl{TZ_IS+;-^bErYqPdgU88np61s=O1y#V32E<^qGk zQ^Ld$y?U0EZ_FO2t-PMI{9F8aRxv$X0=6C`Lz+rPKc-LX0`e(S8^atRWqQ1EX|*v$ zZ36wK#d6tEm4=4A;jGW}vo^KKKk$R!>M4W!qBt2u)be2TQ`wkEW$lzy*x{Q3>!X26HJ;zoy zNXI#RXo5Z_nX?y1V9CL-Aqur*OLjz+aUz&u9a>q#Y0*J(9{i~;^PAt=Znu3(4S@nu zUL{!)7ooSO+OjNz-k&?*`fR@DU=>Mr^1>fRy&++#y6}87I!8)nH}~Yka%22k&zsQv z`aufG%f|smz228X{z_5#a$hPo88`jp`=_~xu*+Aip4HyHR_1$XY_y{>ec)0a5t!@J zpy6!tuD0XC^9rNaj%nbC#a3*FHQF)P*2EN<#5BAO2pvlp)O4^Eq*&c0kr7ID3FE$6 zN<1*bjXCA^&u1zmR{br~eF{-%f18cQe-jtp)IH&N)t_=?5$JGsPA@YRHA9}AenhVG zD|GBJwrKb&mgO-#?JBIO>6UfiigSYEj5{KqWGj?jSn*dSq&hb348N6}?7;G}ZEg3D zPZ0r1Dy8Asd2+t4#lW&~z4zCjYp>NO0<*DWd@ZIM?jL=d>95SjB9at-#3DIR!VcABri+L<6E)0;}{Uo;t7z1f@gjYV0LEX!y?@a#Oh z>@H+?0eG*ZR?}1Dj5toy#qPRNA(B`bk6-W)xBKSq3+-!C^~LBSW-=ZQ&&9EH{Y^%T zDgot+Sd#%|E~to#Of2WX2uFDs^pk6{_0FG(Zkd68Kg)*mwLgfHno}2rZ%E3`v5iTO z?NNv!^|vz7QHGS+P*G8B-)yJdfeDuwHjW2-F>@{A*vu*JE$aO3Ke@BJbTYv8tvREf zAHAk*Z{5PC2fakL*tbaX$ZJJotWDC#MoL|3e>t6hi#{af9pN0dGKreH8>(^goy{yKqF!4RWOu5xyZn2#6*<4A%G_G;OrgZs{n zv`N$9ty8c*=OKqFPW#>d<6Cu4&RNcR_H{Nc%I3vdH?nd`SF47gF&_)`Qejb8Og5vd+$K{Xj7F&4VcA{inj-Ix*rHjz5znuVX z<|+T0UFXc^5W@MhHQ4Xbb64E`2w5>Y&lH%IzEW%%jQFoOrn~N2= z()h`5_*Yblf`~%G*{5itW_P{tjFacJ3NPO!68nYDA}w>i{B0va&V|vg9K16K zT|uUDv+zESR+&+t8HF(yE~Sybdqq_?7-Pgq)jOzU#6=aWU^@DNfn(zNXGH&1WAnQl zYc!2T4?zQt)O?DtVSHK(Ie(r!bfl6r{9{SidLsooj1KHY#=fD%KuO71G&=MC->)Pq z(JjpS+i4{!(Y7p@e(OsvqY;`ji4*53g_x%?RpG?_tfE%OxO{Db&SzosTUAm7-QCQl z{V0qD{mO!Kg(R=d9@G5kG4QL1)o=yEpZi~OQodY5errqcaSpvJI!qmoJw&bxJ~W4- z5C&(Pr3b+e@3!SVR+rO6#NXz*#&`wP+Shd$S*+eFpc`4l?8;j>Vt*tyT{rE_dT(_OH}4>r%72ek#iP zQdj+lWDwCdgmipi3ARo*R??4F)C%%YE zVbye?MzeS&6Noc3?)YeNH!X#Vi8WpyaiIilCU?+(eED%++9mpa%aNS)S;Omyw6@6n z#m@!p#tG@w)wwv$b=O~{opMpfg0IQ>TY{J<2Ze;8FaBaR>zwWP_5{TQdFb*!a?8|+ zf8JzFI5Wlb$8gTrnrT#i&K7n#=(y5Hq)CzH=Y~+>cq#CA@u}=d5`1ylgY~f;|q>Q@7H(8ph zx07zHG!jMq_edSMY{2ofu6B*tFUFc!2-mfCZLtH1vNz_b4|Wop)n*@wW`)5hn-E4Y zRij0~H&wwf@j5qgl$dzc&1|HRo)~1VxcL#ym?vl0WJ^9G>_)qFQzbEX%vlwvQ9kOf z%fijJ1F>z5ao67^)^mhAy&fY`?hx=6PBmjyFnOA4{SP`u(~pVWqEt=jrglkI&45tF z62u8%EmRTGy+vJUB)rLZo~?s^ulUrl+{rIsHX)#2ddCrM$Aspb59uR(<>7qx`gbpY zVtP@HbCZFVXaC9X?d-(6nCQ`ESB^hGgPm)dc3U~GO}6_ zX4Z7Nl=K@sIh;pzVMG~01UDxJHU8_W{WMAB2rUvLS}TApjF7;6rLQBqQs3YwuQ$(& zIwHD{PdW}lP__K2EWW}gdxa;2TqN{)~?q<5GW`YkFM+N5*z zpNxvRkCV@((x(COR5t>To!5gcXg|A>7Sdt=9WV?cWOAMG=}v(87!=lIMtgCT*K95w zun`Ojc_fm8XbHv0s4*V6?lo8b!ZOCVVgbZ49kjkr&&W<_(`&B+hkz%W-)uk)k5L;< zcGncbXQd{8blLaQfa;E;m=(0^9x^2QpCCW#{nXPr*_}#4tIXgB8*x7Rh2;T6(C>NK zog+(Z1nv11SD16h{e6PZ3o{|0ZGbTSw>CkJ3Dm1Afm@D`>$K9M=CH(0BJ776?e`=NGiINzIJ-17vI5iJQrV(DcYpH3t^GbAGjgREK)pH60O9CP;O#R3 zzd&tZ7{7okwhqf_!_{1kuBY3@{_HZ`q1WV%%Nf7Jfg zR`z;UbLWWZgM0VA=cfKMB%swyy97|NZ`90u$j-2h%)i2P?v6+1MsNc|CDC{C6BlUw zO#?KTUr8$a9t+;I`e5R6__Q@+bXf#@ zpYGfp>!nNQ{hQ4N6m_5(h5u8&Z*3?>z`OtK!rN5v1G@8>mzYhc_dG$S4oz*xnKCOe zKu^=-KE<7*w;r2x=U1;jf9kxC?)QB9%KckgQ7#NNx~x7rLVlH!boTOj6Z*XfiWg9^ z{d$=EijQg=DRqVI{0djWjp)W36>ZVUFW=c9p!`t6ud>|%Xf~5O4K!ogcKn3Y3|kn< z1g=+&$sbxOp?gFzJ+e|HogurPV$+=v_Wh#i32LjDk$4}|LgTCp56JiZTp+&FQ6li@ zuYzUFcJ!_;lq1F6s2C-CAT#sI2)H7>Y)bi?Me<+qR6`)A?CwQF#N{a}LOSV;kgf0f zIp%97NK zDfx`R!vhWWfc5+z4EA1wI1XGRbH?d49*0*y5qdKAErgvv{RX97aFpIi4Pl=_ef@dmZcoCsM^&N`6g3rj3PY8+|(}7N*7w;U-N~+_6Xfq zcHXue0yj1VI2#i9j!2s21eo8u29+h&{?4crK6qe}X>XyvN-fi<`4#r-Q<9ukDAVSf z5oZm=N5^k^JVIl7J6c1-$32S;8&+^M$5qs^nv9}=QtMjJ%WE<)bg5&_#FQb z+j2Em{~X-vYAO?1vEQ>50RSbc8MnTJVXfCFZ5X4Oz)f6V(p&);y5?~B!Pog95&D+* z%9rdKsBPk<^xk+lcgQ8#i1)4#bF!rQNS@P8@;hWk^kj+WZQ}ibQ-4pB_?r8de&9JD zlYYOcG6-AY`*2|#q`HZYr|DqG`>Z(vw|2o7;UOs`KPZqM!Q{ubn>C*UiCkcRa{+u4 zUk@9?V!dL;SNc=WBu(h6ND$ebV&WTb9GrgzIgkQ5rU`}lgf6%^C^9z?jG=%<5T)U) zL%4Yb&wQtHY8uA;GS>3y`bW~~X)NI1vow5SpHUk1^`K!nRklLB-OBKKa-klqqdE4O z?5utI%%Ep5xH3NqO2YzH&U>p08t+lyiT<)F=M$z9!dmPz=C|fy1fJL`nLfPjKG@}x zvDo#hOIW{~xsKnGqMq9FQuIN9)oeU+4D#Qzr1|8(n=Q5CedH@lBJdZImQ8Y4ycC*C zYfK`u;e8@{r(N*KteBn7cp@@_Z~b?9UHXntA?JgX!mXPsZ*1%2n5`X4jq7e&`k9p0 zE%wYHN^c^~j%AOVYGv$puwdP3>7?UwzSoiZ@5q6*+>!EkO;|RI{YtUre}>m11OGh9YX!bQ9yI(y()RHH zkCvq7xF4Fi9E%Loj4G)P`1|BxMKB(|bVUsOLZQ^5cS(@ssYXg*+DSj1XEN$zZo>nm zE~fCLfDVDKn*C=XE@9^G&(~b|zmoQ5iw|4QRxeN?q$J-bXKm~VmLkk z7V$oIzRo^vg3(tM0(tSv!^3d9oY$*E#QnNRsE)%b(*iHr1pGGXs!_!|G7<(0kx?C$ zI5UWYmowX(L#rbLgZbz~AQZGe1sD-6ukW@N`pAbV&~dW^H5#Zsc%Z4xo{9fu^!O?i z=o7tQSCJowK#@Faj*+feR@ua@$XB&XFBr7oM}F|)IXUMW|Oh+DqP9< zLJA~8_+IB|hN3yX6P@S5Z+mjyRPsZ+_!wEiGzh3NA|WM?SoV)uFRV3<3uJscefnmBo9VTxMTn9pmFyzXz+jFlSbaa@U(Y5w2Os6@!-B zd%^DJqI!9qM{>PR=y0a2PYvC6(MtUDCYM#1Irac!*f&xbr`F;q|$}r$@6U^rD0GSN6Ro`_I+=Sr@OnFIXgv0Y2Y|mX4zl zVqU8l%Y6-dC#0fQ3v>;(O~?3l7T%%g%Iy}@Ok`q6K0WrvZmS)$4(2GK=$5b~MYLYa zdHV%ks9e*hhWXi9uVCa&j@g4Q=r}hm`pHw^HS__1vsdClbbTtGkeWKHF5){I;2d z3olX1U-#LTBDK@CY_%2^M+amB-!bzaqEUM){<@pd{NWdKbvZ%4<)6HoSUWs)m8)@FcH!B(k_KFP`|1^GaR^_eSzp&=c(>FwUV({{87z)P+Sqt z*D@@MHPB7#6}oH8NW!X=S-uH^| zVPnr^gRDB9>RHZQ5UckiYm#S7z%J5Ulipr&LvI>7J}vpnT%F!c@%#mI71{3h^6>KH zac~@)>ym^Py10(|`umL%W;Q*JnN@#LGqN_O17VjnHquwaKm!bv(v0EYBp<1U5Uq9k%I?Y+YzmaNQ zQ8ibH|91Zw&b4%ZdKD!LsZ<(e*_q4$uknS2+k@3CD|KjfoX-8!m#NLA1G z4X*w8bjy7n;{w9SHnrqL6OOF9CRAI4h%_DLzszyWYG@rwI!oB*P%X=}g2<|dD!~Dk z0P1lLUq!g}zz5Za1gY%mD1vEmLeHLfT59ELimdwYku_(GQpVdX%)#a#7CV3NP}fwu z$bM|zwDq&6@U8hwPn|Ku$+6#5H8;q~wV%mf(fI?q&x)Gj(%Z8}U+v%G{l=5K$#sd&Ls)4z6?jC;)!`P0l( zEzzfw`q9>!>IWXnX)OL>KF-2{rc3g3^h!SbHmz zk5^_iTuoBFZz=JP#Xppwi{O0NHG^;}e!QFb(_$7Arr$|@L^Zouhx0RK1NdOWv4PsC zB6<7V>P25HfOLIh*i{l>$A~*IQL>nnc}b_dgZ<=A0`-h6+A;<=|1B% z@9%n8aZ&kXcMP&`_-wolHrMuL73*v8q3$C|eE4Gh0}t&4tnA+Q)x+yQll4Yavn_-y zwAwR)A@~}Nqx_j)X<7&w7^mvr{ZXD`<;G0;Bl1KSJ-YANlR2m859|LO0KeEd`R}5M zZZ-PPK+8G>wc}2VcbMxK`4u+m577$iznx~^5Bd2xdEaG-@o_SOFrF-T*f8=~rjP!~ z+?|NrG>X;P6~inpi2UU4%Ev6I=!d(Qtb;X@8MDJSV2_*RAfO|6^ucZyu){ zpGJLpA;2EW_hwe4F3w8Y+1rX{EDHZzMP_aDxTr4{KzgKS?tY8zn%I!Qa-%iC^!p+V zS0_bPKK-O@Pb(ZQqYNOi9F+`?N-ipqb{EtK3Xpck{=sGSp#u3PB3VSq=6JlqE(pJ0 zYPjs;E=Bwp+dO5tR!AABHPdrr6Y0pIq4%<>T~i#sn6&85(74pFERg?u7W~{sr|lgD z>f~??Q6FBw-0aCyYnFqMs_9m;0A{qNk^ zG&g5Yk7FxZ_MLmjX0SaBqNwbK-DbkEhac2*8)egH2rbJ&x=IvYQm$zrIDZEE1a z!)I8%24E1Ww3i<(&B;?5D?&Kf<&#k7R~x@6C2%$_n}>hd@=xLQw+ZpNcMs!_|KWz$ z#q?FLTWE9r>QJZ5v1cFY;Km?B@bQmIi>k~Di6eEof}o?F&R}_1o9+z8yNWyB*WP9` zv(t(FEyAx3f*o)D4;S{EhQLC?p7|KE@4Wv8(;5`{{`sKPqLtg1OPFzhWK?)x=*tZo zq|QZ!yHr7XKLhD?@qXgfI~Gu%H(wMV!3-xvuB%T&Qo*dX*6nYXyqwyZ)f|&4*%lLI z#` zfAQ|vM#4^}=UdEe?Q?R)rgIIgwcJBB28FVO;XhV{FxB+=aWh{D;8jLXV(AsHtz9Tp zHP0qD1hOD|MI(D!e@**P{&NdVab35yjmj?yZl@Z>NW_zb&SA2hvimy~=63Wyph+d2rGDf6mSN9zkSp)F8$#83}SI`!l!ho-s7Ts%CM1j-`T z@=>}oMDp%n{vCKHb3Es@Ey#jUc*<~|JE1T3cAC0|&X=cz8ghC-?d(uVsAHKGsDm3a z?U2LV3q0gtarbL}ont4~^`G3gc7$;a`m0hPJhf61+Ne zXZqKIjo5e0zL7&L?5amzfZTLO84R~|Q{?fs0Ok*||0{0$#EC3tSmCu3%^hz92Z*qe z?69ryze!J={c(EFPSYYm3#+)sq-x|P2DVkrH`!49F$>1%D6*W9fv%ZGvypr3J6>k- z9LZj0jR0dP6(Pmn@vW9i9(-^d&5?|`X642~GZXTg@BQGq*b2`bpD@Zv8|0ml`7!;* zj#FF7fU0;8GqS%FW4g7y>q`7FdGVe!ZQNntoXW}l27^M)2Dh9UsB5*+9sef& ze#cNmNBI4oq27*qwJlI)zP1yni%yE~!k9+Y)p0O~O6sC{!Y5ypfyvj}ByG?Jb^h;k z!+B7Vaj|_koh#5sm*KTU@us))y1e}XKwHf?jFK$*x0V{u8{vMix}-g=5D7ws{0QjAul7_&?|o zrOVqC1AcWv2+%OR%Kjy#R9$=@^ZeU8-Yhj8|EPu}?)bf(@@K}xT)?STpu#G(rR!*l z=A(gp$4zzM@>8K9(%kjst;r&ZCqjhj;K(zp31rIHGcShJ#Q}*V9S;x)^~EZdZN8o~ z6aI|*93798UErR*jMX32UJ6`rY}AMg}FpOb>8rRzdDz6W+LVcp|kY& zBL@)lWkKf(+}&TwpD-RzgH#(o&L{M>`Azdo@Y;RjqXS+1Z(*UY<28!dD{1IBpHBDe z>Kz}O&rl}o=!e=^9yR-5XS%QFD)xz_y|nJU*#L-UF!@6 zayp*OX|JzTq<4MrI0FtokQ}Fni?-9L5*_@V+st~|A(coS0;cl}Wuq*m^)<>@$b}TTsxe4v-_=#TYoJR*AU8>6=8bK zJo&~k;9cE^Gz+Qh)LHYYmX(gNjEBZm$jmB{cm?`0L)O`j9|*ss6Rhlu{LP}YyTn%g z?bnl?XOR#F2BiqmK{_xaXLz-t&YHuTx$(5V=U1IQnYAt)B;=!6$}8KZ!(Xe6gzRjz zBwi6w1n~}4edurJ(mIEoYEoe4!7tD29I0wFBl~`bWa}~Natti#zrq(BQ!w`Xb!coM z{3X)Q@ zAvMkGRvamt$^Oo~gOA*{h2g$et)pczu8FT~kxNYZMEb03==0;$I(cb4FNcQdR2pLQ zd>u1tZzb)6>OPT^+VD?9bo#{!A9pPes68Nx`XO~ktr|mgnvBlpK3+3En>cy9_ezll zSJjmxl_CcPdon+a$L(#!DCh?Eb!z)J6}m!B$MSqFy1(`@jWm~?kAF}*8_L6x+AqTS za(W>1aY*+y-7Tq~eVM9YWOW-`_5DQ-h$G2t!2a`iQ=K)86UawUDaAx=*LU6`{ALxw zAEZBdujj5_+_s9;NDVnhz2^m4)V+^=R7UbvjQ)F{g9I1Xpq{n_*vMiA+U*ph=wGis zXZW4}lL=S9Yj|ZEJ2x+@f^^#u9p(7cBRfGmB~odtW^2O4oI-R zz5_*me!EIv*LuS(BCb9^NSl8k`_rdU>i6nN*So#l3({K#br1+8BN6>!6ff)%{#D(p zRrq5GNhlEsTIJ%g_giVyO}W(Xgel^JVJVF!zPI!A>FUX^)_>KWDEC;@wpAt-Ab3mT zoin~C>=PdmpOTno7tnh6rd>U-=DjCW@b! z@Fp1EdZ4!PtJYW=Cyj$`a6)!SmxV6d$vyTkui4elN*+oQe`8(Ac&nm)mx#TLK`Pr2 zjDHo8VKu*L1ERRUX7e{ZXJZ^U8NO}^_l#+KR#vyHY)BG+sVGR^x<%PJSI3vFgIf9J zkR(ofB#KLF9+pg@#5oqQ6fQ^bSNoh`tLkIq~F(W z1SDWt&qM*Tm)ow}Bu5l>j03tH&0N2e+g?HH2Y;rV{tWjuowX&Xm_*Una{C1PQOWt92A!sLnV(X*lW#sl%lbF<_~LtEtO<%$t%&udm>fdn2N<2v$aZ(&!OG0 zU-^{j4|Sk1JTL36vBNk*hQa4;#HOqd;QK3{?AJmoFF41WCv)kX`={c*PT+=y;9eyOQ-t5dgIAgk0R0ad7OUw5#O^i1=#7r@rccD zU`4l^j>boZ*=PCm(rdL_HFQ^#!g*2XLcSCZLcq>ja}7U>ugfHrews6XXa2X|G|6e- z2o_*$-6tUL)uol@ERO$dFSU74HTU{aZcILK%*0Cf-8*VRv%_dxSV0dncnkSYp~<7Y zyR4KoT5aw%nL=2Mx>m+Pt&n++Y1)(~)xMJ?BpIXCFvnW5tWehd;L6tERKad=@{StQ;9$R47!iyJMbC z*Ylp#IFVz10D|SDu!b`Nq9?RsRXdxnUX3x`itPN^d_!CVSVw$z^y^MpDe2jSK|%7~ zaYy4iovcxaHo>gZWo>wawM~XQ7Q+Ol)0`;71Q1`4hHz^@$c-jOHmYcTb;|3HS;m|5 z-zCVnQ3!_9wkTC}$~#WLUA!Gccz1$cZ(h zy6)t9eBb#dW!?~Hmyxb?^CMfw&{ROq$9qp>`?~oIV4c^lE#)ESTOags4kmS`*+q#i z@81GW)o4M|*lFiVwjz73p7h#7l2jGwWL@QV8W_N`rU7OEeDj#?Gp|Ky@BLc;KvPQH zkkJ%79iyj`9{n-ahnpw(DrTDJI_@g^j-Qd0TAZ1z$??g;-ZD|=+rCUt8LNwvFZ$SU zsId0rDt`Z0qH7(%PBa#sSgrj}o%ZOp#=A`Gcu!5eO(5=t{z`+rKP_#N``Em*m2LkL zDSXz&$sUvYhcnyR;E2&_O={WAwOCHZ2-q#vSbL<497x6s^J&65DQtjohca#HYD-yu zXn020m{dMR-4Ih=Wo>yRa+RtKiiC~Z37oRwMb=Id3GA^MsE*Fo)_97Q)s|Q~X|EN1 zkD44=`E=DMw8u75pcc>-|CdW>zpe zDPol>St*3(jD!>2ugcm+{wIkJaiy zrU_MFvWR8`$uEa~636%QOwdDfaeHi2sdJ+L;jz(Lyo#}+@6hZ67nW6Fn>zpkyJ_V3#>U zuNZ-};<7B~*MGr!!)}zm#%x9Cx2eZVo!Og@wIwJ#XH`#b<>#CvCWqv8*G5ko8Q704 zoA~7;Avw(nwS7-0L{s%@el+2>ML}}5Dw%}p9oqUmv&sX^U3TY0vvq8xXRl%f$icbU z5!E-bfUB$g-LGSSV@y8}@+DC}=bE{+j5ex8dr?AhW4zC>w2UdWhz?v@uWN1)4*6L> zXR(2Q#VK|g!()-8#Io(-eMDUVZXuD!%gWPkAqj4=Pa|xErkZ{arV`Sxa!!kXmC)kb zMA)xa%t-n;vSInvL3(-A@10atS>gWHZ_i6DH&UKidMQ*31i7u9^$(Dvrc>dQ+kGre zJfvR!b*D)Qkr{Z3Ug@^_UeO%Y<)5_eTFE|YiT}`!DSuocvq+!Zk;XDSy8Fznf{I6~ zKLL6R`$+SW4b=v}UO)O8a(+9LYzgRk`=zU6I^&}Tv_PCz#5*7x>ReuVq4$+?U_PW9 zu6~pANquq2<)w7_GZL^ZS0XO&^GGOj%78)V%E9BL_4ThIf=>jKT)uR}DHgO11T}_- zIDb@qVu0+K(%^Z$Ly;sMqt?RKTzKoaecrXbVnewvgsoK)ck5=)iVY}daX`KeiL1r- zHQx1RPe)6tDYLO$+`ArH^0gbjd-LTJpJLTTb4L1rdCm7!1E`782aU$1&)u(ekK8}- zHtv0{`|Lb5SzR`#5Mjds)vz0mJpLw8TtAVo+uztJQccIZt#c_|cWU;%!Bw7GfpjK5{Ia`DcvubLE_GpfJNC^hY1t*q$n7tL%RAn_1L{w@c^iIr3OvVRb+0V!Yw$8OW9 z>ip1_(-e|}GWxJesn zZxIwxLTPLBitm$BbKvWjXp;|pjoYc1I2(QC)%V(5z{Ah?m52fj2gHSzHZmqj5QAo)aQ4^fiI>ajB~2UW%u%p7vh|n zKsJHNV^9qek}cgmlz9C??}!_@CJa2%N*qqc*93AnW?s=I>owIO&bM_xpVK0T@rp^8H_a+?4B) z)AUYU774xwB5n*nO#}v&jc0#gaJEoa%ixjBxRk>2`jeI2PhYR{<-I94)vB;5r?2lP zY4-kTE41Qr$=&R|=V-3U3*>z~rE?d0$_=KO!gk{f8%nk68d9gbfqaH6alhElc_i6U z2$dPE+@^W$+1=&BCdpJ5K!4)&?t|R!dq3;t{O8N{r_cHlN_m0G*o@CWCAHjcqC};w zR$Z&JhewHb$Zq2G>!c}PWJtWv`f9AL`SqI1SH|H#z`M!CFZ(8SXOo>vOytkk&M9vT z7WT-?c3B%^P2}%iZv3iPYp`Z&yN3-ht50C*?xi^FN=}(@dOo47p-U2l$GqcwmtZ5M|QZ)MweK}ZL zyswa11!`rYPBPrdHFwwEpOPBft^D-7xVFI*0oD0YlAJVaJX>(b8~r%hYr3kzcih>G zlaaTJgL9I=%LT~OJI9;IbMA}tZ-lp)256qOwrExTz-abk26JZPjt|5PeEiDjr+Kpi zl3NGkP7cKMkG@KpG96v;i0N0It*xeALl7(GU0(^`zQ70nmeeB2*PduhP|OF%2{zlB zOAO3ESNtk=y4FIwzOF&_Q||EBuFyviC}!~VOE-{dLFVGB(Yw!D!|FV?t|No4 z>i$@^9;HD4L+Uc;$e)Uyg$L5!Tl<_PUs7OxqbGKi8vv9|h7w#D!7{qU^;mBC(_ zSw~HGUHgo(#LReF4K|iwAdPf2w_Nwj+a+WLvEmPm4~+Ex{mOWGlR@C3vXsYqEx+_~ zAWvsjwYm%VqW;$1fPT)@{Q0p%Q?;R4zO!*roG1GgN5Gx47!$Cd?`!;)d2&a1~AjZP0mPyP7v zU`$&#v@?#EugG2OMN6B6ZN#q9PEQS~^P{5Fngr!oTP4DLzNcV2PgS*wB4opTtD8Oy z8>VI=mccTlE~kylu@i5;M*!i*;7#8)8l=lKX;-CTNK& zL*Fnoy}>~XT1PD1?FgNWs_}N_q@0(4@lU&ydKRs_G$UIQPd`I#Lf|O~?~z`p^Fp}? z{MYl_74B=-BUs_(BgD4s#g$lt4ebTm3EG-azX3FwuH%57^4rax zsL=CjMX~N%?$;uMD50Z`A7K@Ge;ea(G%9`~dqf4n+3u~`h=rz`3Wo*Mtk=?l=#n+! zwCsv%t0Jve5Bw%OkE0 z>%`Hd*}Q1#p1%X9sk&WFt-|QcIy8K<<>u%XJ$$XptbpJBW%!)%_Ucq7$kp8d-KFwswlj z+V(!66hwUTiuJh7YF^Fp`ffOoxKt}wmRixEz9`c25vAv5faW~FwnyI%8G@m?sOo}3 zxbor_3PV_Hza5;3813?XWMH0cGdEo#aC zHhl3hO;=j_xs~nK+{tjmwIyOPdcy^@aqGV3Rf9a$+Qn}$&Awsw8#&WTGPpf3dk#HT z&RB6W=<-5SOoN3J$zu7_&c4_;hr;60UDi4I>=V&*bFJ0ThUSxP2Qr5;bT*9BeBWSt z*pxXFkJ#ns-aS}hB8@d@BHHUa)m7Oz0&ISB>iu0r%GEDwdW%J*)o7R&;Ye&+T!HQp z9f+dsj)LQX7wpbh_j)=;7135=z=GSRau#6u*}?K$Y*R8Rk-u-Zv=^hmdmq`CQkb=N zF~AG^Wyie{i@T#6=bAuFx<=pY4O>QC9Wc>#6zc2y$;6e7TfxFn>iRyoH6trw(sK3|zw8`0GY& zLBRyYC8yaQE@y`5Ubk&}^e>czjZ6vB8=gBwxjH6&l6eh+td5da7@l#ki5v2_y6w%u zTish5l^6TS)x_kmSnkgD^( zjU+?$)ZlBwZ6o{8>(^J`Armg;3;LEX6JB0OzdI6*L-v}U(r8xjDDWRNd55gX1Q*tI@gEYmN#i%>P=;@7%9c3>|rpV*iigLJJ>A zUx6}67r?+(4V~yworb%f&KG-8EVoUGupKDU;hp`S-(d6tV&Ufwtn6^%9SUgS*1CE& zI)WUzz}-XVWkI_{m#z@icQ*s>13K_Um(C#2D=r(*E}>72;sfQ zS=0gUqO))ZU&O&TgyCu9N#+?|Idss=^-|mm7>7sa#ey{~6RIHw-05RY8xhp-y0o0M z0qO1C3{{1GTm=`cBUSbBwXV=CaF<1W3Gkl3vq#233{t`_0}b{Ln_hGp6TKVd^-TlX zf1?5l|24TZ>;`l#=ze=QL~xJW%|3EBGkH|PjoKNVd1+t%-@&KdHqeizXI4N>z`v-k z*Ce)F>Y>#iyzm2}&hPPcKz(klsA+N6;pvEF!#RTkXsm$+bg=p6+KFBB+VY~|W&p~F z{!9%XypM*h51>yRsx(afJJejgFf?!fb^X=pP><{rX(HQ)p%0EJrhNZo#XzW} z#a(h~D{aY}Bv~!b^W8%hkWY0#yClwNkO#u{ZWi$dpb%J(r0}-v<%XT9;EBvQM(Ngz zCEXl^W2OXFe8looM{yyJ>w&uXzfuxHygPrhcgFUTQ`-J3m{wGE zrTD4m_r|OepPg`+w{pYu7R+_du;|o5Cu(rqRU#9vQH0^vdp5I$5)tFLo|$rCUgNqa zQnTA*OQ|b0-0GlKZ`@#ff{N+g?mayC=JG=&)&Sjmx;Z-b!`4cRRzjH+`k~0h)%%=( zs$_JpQYCwA%LNvPuA8cW1;Q?4KwBEhpq*O(UXVT76e^C=owLb_bjX`D5LwhcfYq&+ zA`K5X^fhiXZLC<|AZUFv{iYDSyA(Yd*+mYxE(DrV@Kd)KNUkCOsd>QuABIec%SkjS z+ja{U)?Gs87zc(;@!A!L7h?C!l zpG!qXNGZJ2Z;v15`dJy3c2Wmj{4k!|MDVD2Wc=4sy-ib-zJnNyP@*Z6^>ld6w-tC- zb>^zD0x3F1g>z!-bLPzGV$yQ=A34H4MIt>RKC^lc!pTInB#o7ZX_8;3e;Vs>?c8E0@ z5M}y*D$1VT(sBdDdA;TOMWuIV)h)GX^Cr^OJ5dF(b;6M;o-;%87qE#6#Rbk*0C zZQT^FveS!Z$%H1V08mKVNBT*$R=XK4s%5%~ye|rNYbs=pchpykQi0zHGtNy%&rg@G zgD;2jpy+XU0(^*9M)@4UKb)^D*m-rzD~|wc6(M$9LscpoL-}1=wWe(&8khXH&KuaX zZ>!L{`#I%|g@uTtw7J$))b{y2`nItGoOU6A80ahYaJ!xS4a>fDVl5CsM~j(TIheL( zm`IGPd70Mmgzi-HhpvD+T>91o9Y38Va_<}_>8~%YMmzKQomM>=rWA&EBc|PQc7hw5 z9Jqk8v6r`z*+qjz;oyy* zfK7bxvYKm(%8phJxha{(o|YV&f4;!rS2<(lqXD1B(*p0Z-%69i;hn^uOY@%QtWUIZ zTu(n14CvOO|El3l%#_|V3)qPMIvVJ+J$lufv{;M66uZLJMJvZuV^CH6P0wMapRRc` zDNAMk^Qc$?T_{gmB2iHhGlg*Y<9dp6+&RY;q)t3<+S&Tpe#s+5DXQmauCyeevYrl- zVdYl1y@lDvE7%X$4bAb56=&Al)+D9hLt%h|){G zZOEF^{Wc4)negw|6Je{1AE|<>OhoP;FqS;O-eI`a;~}4u=Lm)U0mI`^-KcFv>L0Kl zg0n{s3d#jB6Ug0)gf(W|M3EYLPz}9^BH9>SQ3Dm6HRLV9F(vKSm}3z$y$QPAi=QKh znsFOer*P^FC9_#TiLGu_=4>uh=0;F$M&RKe2@@7!2^R;NXYl8{P!;vmlQt=GWTHII zELf`&Eg}!)f^!a?;~;N4eSwcMNxd=~&98t5g7KFeJca?aeo>}b?@l|DM?l`oH?=@Sq9#=_3xn~q`~Al z3BOaVsqAJYxNwf#!;oI7^m};FjWY7o(Hm@Rgs|wZMn|*4qtjs@Yzqo7r7hR<4nsCv z_~!`rB$~SE7?z|fv&QZua>^bGrRP1JMa8BeP79NxBAO8tNp|~0>4-`bq*YJiD3nNV zXfCb$q<%Qkgf+@AnkQx9M?lhW=4)IDyCpN%1b+-$hgmZ=cTXe5`;iAN=5mn!-?pV( zG_-a7+Qy&Zz6s;~T&{x-RUCydK~U^Zho9-x2OlhM8ep&UKd;<=3n}_JyA)_Wk;HDm zpkY)Cm{2dR%Zc6vJF*b_lt^Y*kHMV&&g$nF#e`2~)tOy}ZmNkdD3sRF= zTQ2m;{$8vNs_GQ7t!;G=ak|`m+as^KxTrPtc*kC8CjOiVa7k|^)oPk@vq*DM{`%cfOT#9Z$$Ut zlt6rpyWkOpZo1N?AK7^Y9@!$Em>o0Uc?0ia0^GsXCn^!z&ko+(R1Xul#FoX*<9in0 zA@o|?Y9C(!b1i)}bfx$eRU#wqs9;L<4pCEjbILvfaiS;;tmC)&P-WDpu zBXy%rS#paw*K3RTy9)PSUp7H<&=n#d#Tfpn6L{hSnmm!LSM;qfk?L3qY%I)9n@tTH z)o0r7mll)BJNa9rV1r0g;TyDA>)n?UyM6}6Ke}UX`@Hg)r>ppRi=S(oN2P%?B?&B5 z0#T>JeM}JcRX$2+@_76jJ4sS2C+m~O$C~K6Ql%8mscc*Cy`7x3kQoH=Y*N@jhUjR9?NN`}kvDcJ-Su7AzRFY~r zO-#dyEC`A;eel$+fkLTl82|I)ppDC5MdETue#OFp=OUGi3AigmnBVi4!SIks}tMO=oJ=|Kq*uJC(##Kzv5k{7__46v}1tS-|y) zuDoQZ^~6Lczv*IBOFdtPa$_NL)>X`K-Kd5fxsUiq&3O(xjs>3j_j5WI!mC;#28D08 z-u!jy{lqH~d$IJ9M}XEZmG1dl{w-?^$oPl$kE)q(Kb8J=tW$km>^YrH7v zz%pvb_j^^G>$b3rw?yvWaOvF%nau;@2nM0(KfOIk2Y)1(e#JN%pT=(K7|!jI_JxaK z>xR0Axrf<5StOprnZs$~ceUMgAKS}`P1P!oNP8bz|9UL>iRbGf(}vj8_aRP5-Wk=K z&u@LGrfK9b$&x>xXObCx8nH^|Y4FG(Gh1kFrCp6Rnm&^xikwvextf$rIrip6nk?4{GD;p+FqGGl{o#SIV|Z z5ZL=;Rx1zkhB=~nIqD74Q}WOJ~hA=Qxj3`}TZy0W@yU0D`7yb5v!5O;V4x{va_}3kpH3 zsp2yOPVaM%BtV?Y6bQZ&GWs!M)|>DtOJ=vBZ?eQas?`+Od)_|ZN=RreOS%2E<`_sf z30H4AW0}m!zj@eYyFS!vP+ui&c2`wMP}#Q`*1W#d&+eJ3h!O4BzT_y(nRk=c$bj8^I#c2y3-Z8bBv;CJ4`UEc6<~NT$DCl>dB_miKVIK&#T8W_ zrBeMa(jA()#u?A7l73SFZ>BQJSiBbQamjI@9a;Cg!aq#TxN7@-^2SjSz8@7G{3`}` zhE6y8mx7^fg*EWX8f*JpFfLfx!iwau-QwVU(`06GOg5%_kKFzCcS=Bet9moSi~^1 z;$gzU6yi&(2H++kA)Bd7) zZ2MQ?_r_+Rk%xxlVBM~GnBl>KvMP2x#j^dC3Bx&B;CMdp+UBUafmGU9pO`HHr)!<9oL~D&*HLHYa>G%e z_LH#XjbBz9!o;Mbo-7>kGRHm=30}X8!Mta7+?if9pO0`%^F2pMb6|oJy?>ls5t7PI z*`_?_6u|SV6tV3}Hr2Et{dAY(YqNw|l&jB%hlNKO zlgkIBh7ywBf+tLDaVY-a5S!j^;wsjY0qRr1Lrr^`l+eG>eCb5OOMY`!5|)x(5m;Dv zv4{zBpBe{VH`LZz(XwNC<#a$9MM{Qm5`wImHUPD|LOwo19=ae?{yg^}@jtZJVgCec ze|=G!qg>Z0FugH{IfvOK4*YhH{QrkuotJ6|I|B&s3qYZGp)^lq1D%ZMgfNxvBZ3v% zmAEK}WW*ZBE{zC&;fsb(1dsK$^LP&Au(rP*TMLiBzZ1-}i6?;B+CF0hsubHi2p4~g zeMeH*QurY>PpC0_0wb1*xiB;EIqvgzeC8q@!j5eBTb4W|)5g*a_?XlG`1Zm7TOasX zK^@EQxt>H}5OuH^JrSb)^uQu$)`%kopCs_QJ$RYB@+stA>6`San~RjV_e9XEi)Hc| z(hRyIRvAJNjzLDIh4T4uOLu6fnGcS9B2Xt-9P1fx8^reZEswkGe9 z>k%&Ku1@h*((B<@axwQ8j)v{_{2JcqxCj|eIATo~Tz#32zltva=Ud97UFEC~;4=U} zGu?B_wQliewTYCu73e8kU6Nn*Q<7i3996BUaWWXV(6g3vFVf#xlZv_DbFEUY$eKhW z+W4|;V(ik)KdpP{U||>Utco*L7lh=st#Uf)|H{|gb&&uqY)sWqL5&EZe^{5NryBb0 z;wh@ApY1}oe++)Y=Y_&YT>dy!uN#fXVIzgN#f1pY*CJ%w@|h@b8btXTGI{rdGA^lu zB+_+?2+BkCnK_?2@&96Ci{6lPOW(2H;H3=*5)lde-ae;q>dTV~jZbK;@+y5=-8H=Zlfnqv+rx@zv{ zKT!=C8RQbRp%jdTPb(Q8*%4V*diw7YC;dGSX2rc$<@a!QyErJZLw=&Rn%(#Ew>an7 zxBe*bGSus9n}t8R?|{5(kYgy4KbF0eAF8du?&I#C!Al$XYAgtprv$nDEQ)O|g?I~) z6hewrl2q~_*dQq5yu;;LR`39l^n`np2cRbaz21Cnl@Mr4wEtK?M?Ysr3Ko`>Yi{LX z<*`|qLn>-8R+g(L)evlty-3p}Rx42};rap~E?2IT_nWz6Y5+L_6akP%JF%nq4Kg?R z4QJrU7l5!_{`QBAU`H;q1TA5=;$OWuk=!&L>&+Pih!vnxfRypbjD1IzAM8EQr)?6i zeabG?43J=m{gXY+JV#KNTbPe&tFG5S1$xAKVAKE!*-DXmO#RsXJRB ztmO?`j99#3mWj! zCsfGn(V zu!!K&0yV4Kc6s|HnszPya`9bTsv*Jga1oI^7e3g1M36}O*eAso*p7XI4zwC)lHB_- zqCdV4b*Ob)towvjA@&W`zZRXUXB-rSvLI;mI%hvW9{mlLk4XLVAld9C?LK+q??kU9 z0~4c+wlAZw2}bjg8;xcjOVnk+eXVJ;%7;<>jv|uHJXyNxfhbLG&F+-#<%oPd*lDi$ zrit~faBzPs-i#MD@FS?7T@@)hU4je$gYvq)(0+Tn$Jxe5PxP-oQ z+c_4C!WLL6@t|Ow9yKp4g!4wl>ATBZtLC+jsCM-tU4!*~#j*>fE~eIxOC}}C6uPL+ ziCnjfKO3neOlH5OC3|zbrE7%>@Sr{!>S1s(EWoynR&@1B!20NuUsP*%y|bE>xXp-`?)QtI#b$^P zm(|WvHkS@j2Z^+i97*CVhT=t!fB^k!*txM0RCs2m1_o@279nhcLMN9DK~67CLv!s` zHd3lZZuZmQ7(;pnYL=hLef&wYM!_o{k9z%^1iRKcZ_DuT&!Mc9%q!lICI-Zm;NM*jLg0}O{ldwn zF3-Lit4Uh<%L*;QF}&R8@Ks7{I^;jtcV5OUzZ4R5`@6HCcAVVCFZ`~5qK^Pi{dG#W zXLhZm_w<%HOYFGX&j*ZBKC%fNu})t*_%Fm+7TZlTsDzp+gfZIh8@;l^G?k=GdB_xO zy==mTF?1ig_}KaHMZP6g`*-k?D18AF-pC&+VQY+eQ=IrZ z63`{*pw^2eFv=?4Z1s-mjLixOVAFs^8<&|bkU0`^K;Tea1A>IcIik1zxaN6a} z=h4t^x?3zIYvmY9*|m-B4d15h-&^b#4Y!uC0wdoSHox@{)Jw$+z~k%XTEuCp@Zy`4 z9P8MqQo;|w`s7l%4EE_&-CG&nP3!?TG-X0AY`K?_RfFdh1le9F2IOo7}*+H%x zJvJC8OtmT4nXy%`15i|^AH!!nI%_DK$h>KJE(yIQcvu3(!8eic>}wBA0$pj+{!=<6`CUTWP16}gSE`3%LNXiVM3u29FSdgQ2z{-!sO z`8BgLD{zlJhjR12chHg%JxV!Dh#FDYoO2OC& z1a%Nr5H$x!Yx%2gTJV{kDTdDJ`IE$!jwbDARhZ z|1tT%XF|*u&btsSwnx);AiUIdF2?NnY5(uFL935R{vTm~{GR)tA2tOlzri0P0;c%J za18(Hz2NruToko|z_M~t4?PeJ2r=T;en4|yu>+a&*8t)&_CVmiScgCk=O#8*fTYnY zGTgcL5+jOVWJC9A{*~bchBltTgUoHGCSdh&Pwt6HI*eieEBz>JyJb(V$4Xd}?cM+X zr0*yLZO6)?{PXnRvH1i_F5lxK22MzGaFrftbaXF28N=HM{C9}Xm4tloFr9mpfiy;n zW7xa*umW<8*is%A2I2s>68S$Ud8GX$3mf;`bTNpel3)`HnAICq0513aI?9cn2|fK+ z694x~kD%`5WB{ZO*)RtI@qVIReJb$a-z$N!MPVkin{nZOdTJ5C+Rny>T^sCW^iun2 zQb1Tc{W880i#DESP$-u6Xb$Gdy;e!XN>;Lmco_d5xG5;Z9wXVjU;ogr9q+%eF``Jp zvk0VYe_Kh$c0V?tVA*SI?AZ=(ZGiF{RRDcB?wG;t#zt&HG)h>c0sn*NA>roLi@67_ z9a?WBDoOu=AJETz`+JccwCxIqgjSVCdx0uBtXB6I-{4o0Z$7Sn*eXdoMtXvQ(QW`N z!@Z}NWkzgP7zu!kc~YMIi%ZIO(aL-O*=@i&CIu(v1m-}EFvf5{V|fSLy`epP{+~Wx z{41=Ypnjv*z?R42ZD$+9BMInUepyM(hRrI8A%ptgh5y|lM>)7u_)Gu-&A6Wbv)7DB zfF0Rxa`+4o8P;G263`5B@w}T)blaJ7nEzm%VBWUh<9hTIGhdPt&%`s^t>`4Q8h-<%z zc{fj4U>iLAcOU)V=}vaAIb!^G!r$iUGjQJs0+PhN3Igmh84gpR^_@cV2$E|@=1k^m zBXd~)-1~Q;|J@y1MkK%Pvps}9j14I2xPyfwf-m@gu=uZT_#aX|$FKk$`ag^d8`1nC z`Uj6j!rCQk3lC?5q5*XRs9lWq_l{&%nEC%%!~TEa>j=bH_J5od04#eY73AS?>`PT( z|K0!ps^9;o39*MTJc1a3>49ET$1l?2W@1>C<~s9om2v!T9g|{U6iZR|SB0X-I~B z*CAkaa`6A%7G(Hy?SR4fZ-)Q?@4EA(V8b2-F6qFa#{e`{h;%N&sonK?ofpB0)$X(lK-*K}u+m z1PDp)4tS2f_l`ThU*9`22JD@^=9+Up&ok#*N!TQGn#;Gd*?50UQ$#tZ1?&g{ngypX z{jt3W{9#%7>9(zbu7*AFa;iS#n5hP!&&x`{8VS5R+6XMP`zjtQ z0!0AyzpWwwcmvv=inA}D%0F&EwI2SlcjzCDpUVfQnG5axS!Ub)0oW12U_UfPm$6Cl%;;`vCe}qY%IXDhjO4JBw`9fW_=_M3Xe&c<)xRei`0N z;{8bgz}qkQ0rENWs}DB?*g5iJhw48&#{c;8C-H*=AhtckCbiPPI8#iePn@mTr?{h` ziO2S@HMVmd|I)jB&j}LD@Uuso)s;`-&ZkcseLKA4*rAT_cQR%B3y*$?P(*74~9yR*B(M?jL`#w zP@5sJlEMZk2pj34>qVdyz@a>aRyH$2rlMln!@7nXT_U;HuvG=R>0kW>j73U>paa=#X@){C7qJ-%ly^0sp>UVh-IdA$;jK0;*p{b=NRXrMt{SK zr$lce57B^l8g2-`K4hqROZB>7Pjqi|SG+5(!i4ywQp>Wyx&ScC(s!wX%~dcexX`T? z{U#g7UALi41;CBnhL_gE)63J()5X(+tq?=oSDYnQdq4ATtkkNrsk@on?KaTw0w#)C z%(*rY{$u6ZknxbEVAqyu7hnb$W^S7T7-s+&!;FDEH2{3&i@c&nEderb{2~&IK1O`v z-QXSJUFTf|u=Wj#Rl|7XUE8P+BGK#LQg94hik9(@aR zsGC5=ngJr_#AEQ=v@Y9IZkOuCJ0ae1<08nmMmYU2+&dlUgqgy*GC*tD)_o%|d%;N7 zNX{<;CCcek?Mtd=UL zq~5Dz!2|pYG@=^JyRULiB#UdwXSg zr|oy!A8$QB`2~9sF>oa+EkYG9As;0!0o%c6e-!@k!gI?OYjUh_5{aquwY61YGT3eh zpWTqwf*%ZZj;#DR=!7F7=0RZ9U{^y>bnbUQUIT=3F*N8kNnv5YOFd1Y<|`>>c)nJn z=Ii=7YBRD*B|0;7e_?0GsM~AOQMaj0g;oIto8VylGL#@UUj5gQfB7`Or%=;5>=&%E z!7?<2Cycb)v>XBq&XEtzk*D)=m;MzY|M+%fMik=Vg-3l+O~o z76tMUJAO@&^xbx6Y~n`+=$8~M_Y~7u6A(TP& z8%gVAHgl*mHkhWr@~yBnKzm-oBqSP^7H|BR_cH6Kb!|*@0Kh*wSM^@DgWeOU*-WQX zgL*D8g3Ra)Q&{mp|JOx+536vvS1`TZE?Vq(%W>jyZLTAUpE&q3ES*AZJoge*$+pI2 z35-h|LV$oud9~!9HFp7oG=a)u@D@1bxEBciJMzRw5UAlYm%t>op+k#ui^sqnYWczhmBQbZ@z0t z$m-3|1S`HZWrQnSyaU&Y=w^eTi@dq4QIuOKztKlzBU zwhH3n!kJz_108FML+=}VuZKZ|^LI2oPv_tK)XVq0nyB&0NKW6OSMW&xda=*hKl_%S zhi^PQog;o2u^M;%>Im{ip6J;^gRg11x0sTLZYRq|c(oTt__Q~Q98P`D$hqW5$32|% zR`sk)EwAFANoh#+brQ+#R5M8ROSwc<_L@MQudlc z%(jzy<685iVvGmoNpHTldp!}Tcu_42)I+2_r%L8_cDDZ8TZ-ILV*abS5fxFfa zE%HC(rck9icHl(VRKLu8=zsK8J@^&o!QU9Djrz~<3hdl(Aya>3*)~~uZ{g> zEYPb?5(BVj?NSs0v@WsLqf&iL5f@Y=)w!pzM-k=e@K&i zXDN!e+%b>*>kjq~O#}1!?};Jkh=@kM4Q<<4ESa2!Orh9w=ezdK5=JijjJl+c%C_E& z?h(pWQABIbcJeFSa<7VKgt;(T#)dg_1WRV-Lg0?pJwp6Sw?wP@>RA__yGY+{CPXP- zO4OpNjfISku#+XMR}s^L6UtvN`)G_@ZWx1=w-)bQ`AnlBf5PVlPbh&})rKSN)w=+geOP={SfVGxayg|hzs(behO#?~UMMtPa zKM3l*ci0BM0aceX~WY;gLkcZ10(J$-EvQ}4=k-b&%Q}&SgxY0>9Lt#ij5b2X#Eai*Q%dOx~jV;K%By@H2&yV06@UV1}9QC ztAQc2Y=3wyNL)(%^j$DeG!sKQ9y>I`9Edws-?4?G6M$)2LEORwe=r1Q;sRWWBW4(=M71E-U2h7|6wid;YULFdZn3JxBa*d$`AWf&A-O z%R_^2d&}mcK>z*t!EetaejSUch;DlWvSR#pd^;tE6OOQ+-HDD}za2Yww%Yw0@|E9? zPyKd$FS^wd`qEF{+D-xo1P?I6oo^n-BVJ~!GNui{nwfV`Sc{WFp{+0=h!Y(;v?~B~ z*h!PZYe3|#HP!%OH}!y*GdBR|kkF)%l<*TQu`RHGk*s4h;AyiO^{oj@5CL15CIjFB zO6@55H_ti6a=EQg-M86*a{oKQ$lQFyme>#W12X0~w|*Ve#Ua#ai@@ttOIpi0fZ2!4 z+M?~Dd)(jiaN>pv0*L_)VKX`is2>h&3o$|o`&f7wMLcMaxHK%K<41(@3cb*O~{s*A$ndmc`X+}?mv zIk^TDwsNLY;KL9u0eagL0tLuP|Jr;BP%m}I*w#fLhlXJhKu%PCz|A()8Z-`R8V=h~ zm#vBQXN2CAzEQrFqImPANV~&5cbCliw?sehB&@~J%UYt>RuEi+T)-?RxHax=^J55P z!8vDPxAnud%@-NGg`t*bIG{rSvA|A_Tse|y-jYn?&+P1%6SmG-vD0;@udaTAt5rcu8<1_a%@32r$Y; zK>}!^ocYH7(@C%`L@!ewHLu38J0S(z@l$|)TXx?{c{t6BLv`b!xh<7E*v=4(Yy4T> z1Bu)6Nh;mqMc?>8`9QbiW6fr&Z9yKmRl=O0g11$(AFu!jOggzOmM7IgTbjQBynq9= zgz)4LqaafaNPSBPs!utN^mVtA+^UkacK6WaooJ!l<#dN} zD~?8zXxm0AF+*2?es#%1^?1vfoU(C#4zYK?yjslU$U22X0FX`Ub_d7-Z%;Y%aa$L~ zkb$_Zu9aSX`Y4RKux2%gHGORvU2Q&kPKMr@PpVPhytakBIcNs)1Q;N4}D#{MFn8 zGZ)o2#(X?F>0e1w7(%gS=W=o&+df(_6~B?Cq|FX^KKdyp*+D(mrGIKIOAeNKxnC+Y zg@2MUQRt)8YCKqSmVvfoDbPBm8M#y@cr92kn&4>7FKx#H63TQN4)%!-@L+qa|DEC^ zKiwB_zA6SMN2*Q?a)XKn9v=G?6E;biSBeZOy?xX^C4_&P)Y`1lnBYZ61gu6o2+M}N z9P$fKbCQlPCEV{fDIF8)C&hY}2d@m$W1i{|6VxEDrPnLI6}(=0qAUI**`xW%ki@Xk zMA!baM^MPphaYv1cE%vL*lqgbB;br z(Vd9v8BMBmB2Kty>T#>9vt}mW&$YWr3Yt}B&DXt;Cd~Wi++O#a;(r4%Vc}LXrs(kl z@uKH2uv%~s?gyoZeTi8x69s(&J=%HqB8eif*r6;hrd-~GcLU2M`;qW@U`X0}C!XM> zi0TVA#h8mZ#StvPuxV++d<0bULcqqnS2>-aQDk?y<;XFdC**5jHu7gx3t$CfB{Vrr z__{f+P7ZV5k3A)pU})3myPh;vBEu%FsN*zkf*-DTClO$ZMb(~;9qp-7mW8#xecwzB zi~T+O%nBMU`_SILltJQaq8V(gh*{iUw^7)aP)IwD`*$3lMnZNv^p=fk<^2i({HR9O>x_s1ja|@MAevg)|zzIcBH_bA$iC=Dgo6q zb_?<&cxFzn->uHz8>8CTMBNUtoGRqK)6lq@kA;e6$mxzgXi*Ke-gyI=fJd*$4v*be z*oB9YFHu!JL%&K@t?<{x#o$kRUhdRz#wN*iWRj)8oqj5Q3L+?wZg-sD)B_) z!sp^+Ne-PAI{KEd_bLSc;fL?pwTS*IuY&>}Vp;ngr{=OU2{*J;hx*l!glTkY!*QU)^Lt zA*FoD!u^M-(dgcKmQqwk33_9nP6MD0( z61%2ONG7AuD_8td1J4Cs(fHhOM$|?zu^5%0FG|qz%$`05e9D}^`PjGPz{>sCN;F9F zka|h-A(Rr{*RcDIzY*|V^X?tSs3NipAvp(M-ti_N*eNGq6a-esD3z-Z=|7$3g`%9o z5NaVHn0j4D1d5KALdD==C<303Fik#47!aRY@4vr#+;g%58Wrghzo@8*si{bft|O;O zHk`qrf4EZ81L>GJx2V3`{)WK=T5R{}PUosymvU3S`Ef4}IKyf_*}a?c=@NPX*P~EtHIW9cj=EnOPVm5bDyz$C&wbjPgKY7kpY| zx=pWU`p=mX*@ugs-t6c6wN-HqtMfcxEmat&ebSz%j;!Lw5Wd>srsP@$qmKr*3a^ea z*Eca3km{IwI3wIK}lfoi?|LfXCi*BYZ)XP)ed)(z-kQiUr9FoBgFbx`Uec-i$dYsQ8v; z!u-fwP~Th#Zm7x}4p@0ZgTq<77HY&qJlvUkD9c>K>Ltf1(KzinQaYTSKBQftD*Dhz zD)95jL}S=6G6AhG;_V|yD^(p$XW9ge9Iuj#L@Zi%iY+jOHp2sW`PI8`i;DVGO_o`Q zfNVgO<0AH2nzN&^`-!=ta8~TauTTi#Yg+AuuU6f8dN1Zgc?k_CQ9WSaJP_#36ibz> zt73Vvr~@H1lhl!N_HLi5(d-5DT;E|cciJq&F;7)9t71I_@|?c;QC%q@%Bkf0yh&P+ zXn1^WgSKkz!`X(_fnZwDNe1d=L*sk1A8XyBC388kAsfb!u5a+K_hPO6(&XI-soCyC z-K;rT1bxh{Zf*>1_T6Xf#0(8S<7ik-HPbA!#5U(p1Re3ro?&EJ4-GenqLKQl-odEs z#{TzaZ&x3V@323iPU%$Wq4{sDaIvZ`vKLkLeEmBycgt&=+O^nNl<4LVox&dTDW@;7 zTRU?TYM3TpV_@$I)bFx&+~jeo zY^RdxXLFeTxUc2-`D>t_K$>P_%e+QzCu@d@UqCjr%r^*w>gGbm{Jp2@Jckjq$`hkH zwAIb$!E{}Cb5L-wrM}ci>lsY9wVzFPz(NagUW2`%v03gZsBr>F(LuD0AO#8h9umM8 zZ8Dp=Jg*t71u|KH2boVbssP5#ydA_fe(wlfYC00{=$Vyw*J@(h!@U~iZZ^#2t)>rd`C3zuiPhHvz#()!Z zF6~GD9`@Ss4(?&6Sp()m^`3(cTTC-1S$TR{s8ap4v zSobMky!v&~rt)(T`he9B(lLd=R}7uc#chp-tT|yGnFp<{e9RvjPGf>0!EUrd?Gsib zUx%3M$LNG&bSiGx2ge&) z^O}+P1U7=~aUG$*qoEn!re|-@jhdzr$(nu&EGFhU>nq$5VwMaG*%+#vP$dwYPOxO% zd>1q^BchNrwhzIV#tdni6?Hn%$W|>FX_cr8Zk}Z`eXh{TA4W`%`2VOJEfo!_U{T>r zC*r#1dZ8-wX>zLoH95X2#?x$6Wz^bl%-3fsahdHoRgQ6Y#EqdaK50$ksxfNJ7_2b6 zr@`7Mh3RxBe%VJ_tL3Q#KnKRER^08^r`pwN)c~#UQ}~jEWsc-UwiNL8p$y zBW?*Q$~ffI02gE&1785YiW~y-X$rA&;G(Q}m63{gL}Mk|MGWk8Lw&_7K9cap|69Q= z>>gsdz9sVf8w;{fj{z2rrsxGARm=iVGbh0mH0FY^BRR0=CRR8*e&&Ad=jzzXi1V+J z#Xt;RvCDgaU#l+>K9r~A)5w`qXnadfZlqi{O`*Yoe3+7*Q-xsf#|({m#xnX$;zMPTD>_Pv~& zK5dyWq))a;xweQkE-;-Lp;jzXZsv;Q?T{8&>Px>eF8P=+D3~HW0(@*q6&@MltKeJGeE$ zyjF$wB1B2aaNNS`**Gbws{V%d3VqLk>Vbqi#R(#4&?<-D z;12+Z-CZyh7%Of7`y}J9XNyps7c4;{603>JHA9Y@iQaY#JV@lpxB=G%13Eh2`XwV8 zFa4%{4qRn`)y)zieOq{qxXK7za6_7lq4C@`i#Xp@@1O+{df&T|#JYhXeb=#$5eaY| z8Zs69O@nNN3rtOZwJcA0KFkDB8+z?osDR5Gz*klnk<`zj>%+1{7Vpu62#jpTyl+f3 zA%gy{cTSzGAvfxtrC;AV;?x>&m52}M4x&?8Cs+MsbVup+D&7AmnVtBd82_w(fvv1F zm@ENbSk<-k4ed6rzvrUs&OMVi8XsTJ@Uv{Ij#C^)5%h6&5-5 z9El$-=cnrkZRiEb1&Agr@113Csoi& zMlFzSoM-E_unaU;J{qsQIRyy#l1+CGjTpDi&_Gr{UX#xNialr z%D-*s%qkfkuh=V^ zb!1v;QFx}k{*n*7-g*IkQ^r%xy($vZhx!}NF~y`WLz%CwW`h9tmI zS@ABjj2l?}3ctok{94w7jtv@4`CMEimFqu4^+xj2GIW9Gueca-m{;^1jm-C84}L>c~Su^MlcPMJ_W z1s=&>F<4MNPl~8$2-N(H&o+vw!8`d$d)D;YpKcTqfMihSaB)bf?D!h&z+J2vtYr0K z+*U=8<6@V+fYDvk3Ckxb9gXSu1MwEna5-s`CHh*Bj04#_&uXzT9@J<&D=!a`5*W*F zXibmvj15>|#n8NK#LswVN^@hm1Njt1tnn&Rpnw@yQiP9;Z4Y={k{T)6WAFo= zfV^oG<2O8T1zXu`k6QA2vwW0d+-Lv-n@E<(LihzVi)84>+VBr4_aRD1WOgcP?i4tV zSkoBckfY;@TyI2yf(`1v4Cq4nT!bO+NOMWF9(wVCfLu@i+G$YvRmnxoMh#GLpT^>x z6c|<^w^kgFG4xT>1eydhTs4eEni6}Mj-Xh%ILyh-DUe&H%n!m#WI39$ z2{0m*XI0MnQ=n>q^$~I&ES$Y!*$p{M>LhY+QXO(`42@_)p#C?eTvz4ZEVmfdK$#Ja zfqAqCY$IS1c13Eio>p{<(X@Fsvnun;j)uu;s+BIG;?;#xuAR*T-=H%bXHfok1QC)=>a1;&5{g27C7 zRMTOkheY5b0o6sa4+>}&2KA=BMk0u}$#}h90~+QmINJ#Ki8i8J^^%$Weq|V75!L@M>?UYn~ONS6(x`@f;3OJ zo*$C}M`S%*J3OP?2K%ZwHLf+Jwk`rd%7Qo~M;X?GF!E$kidsyxc z_17fR{@iSJ+^nqZ47tjY5XNy+!m(bLfnswZ{UDMdBfx(~UZ2wfRI@z&**8s*LWo1g zWIdSL5X7yO5O=Y1K-A}VimgIWk-R!n?W+vO%^I3+$Sr8&%l0ujR%v96GiJ5wC6Z*c zo;v4#p0t>~qB=09gVl6ae-wx;%UV%Y`eK2Ns)*VJcgT5uM+3~&`5J+`qanlfr=!r9 zXS?8z;y_FfcTyaNuLiiLH{dH?x5o*7KS}Dze$cV^Qv2F{c->_Qq>8rW!2R@y$RSwB zp>wa1(SS&HjW`UOOQyN(Qg^V*qKH)AfYt)t@OC<|o$I9?`0*O4ThXwq!I5l4nRX4WkBMZsga~|>0`JNa@eCSw6&O1iH&*^A7$lO_pz;L*-K#t0dho!@ z$2ko1gihW(p|LoJo}8_1qk87g*#Z@ zn^T^?wuzCVUD4db=fN>LQ%MIuIjGsFp1NQK6?c{30%|m`pJ!MKjG**>xPkODaz*Cu z%5+fEXXx2h;NNgutDPYsjcP1***jQe1SwuHg-UY3z_$4odk5Rr+2cTV1a^^!&&4hm z5IY_{K(3>`b#0&F>x-Fi+jx9dh5KGf2WYZ)K)Mki9yGr5a$F?)9n;trh3~yN_2)r+ z!g8HajlnK%;H#c!p&#s!U&Z1G-yUUyMsxMK4ufJ}wNEcyMn`JK`{N}Zoe&7gXG)hE zL3wnhjD6Bgv0-Soz+Ex0cGilZVyP(>a&wA)e|(QXNT&LsyK>+$&Z%uE(0Gc*wdk&W zBD5@R@NT%3NXkGw~z&aB{$#xbs{&&ufsxyD{1$wupUg!I~~v+uCn4!XrHyAb=E z;2_Uh&Y-c^%ShlmTD|E>eU;n`9wp{*#<&4c^eE9lZRjPPsd7ZA0X7x=cat^9^HHU? zM-~2ILc9CmI0MvpV@Rr68!8*eIkgdh6gQl%HiVugN`;EH=|S=WC3&C@fl+rf1i9$A zY7DJ*dMfIHTEvOsNm}Q!-ff`L_<*WAa;(XuHqQ?_JV4#QHT?&uP zBu+GCf;_8w?HBfo#4a}&t*Z-eYGE@gc=yKO@XmRgsDr4N%gw~HrdSa5-5r)U59=gp z8BlttsaOpZ9UH0=^(`r`z3&7*uB<5a@O^2pp=%nCVjR+i==9hRWL%so@B@cG0Eo3I zJ<Ybtr0*?jlUlb#aKHkpFT@46zdUw~kvz5Pnj_+DqTJwu=I zI+WRQb5OZfo$TFnfOG)C4YjZRO~EyJgUW9+EJ_>j^^$~j9H-HMF#V#MBm^HCLo_ByE z^!O(d(=Wnn!;y|UIc)s0K=PN%0s&V;9a1t^pY6rz72jc@4vw5Ai4*I;{DoY;3DnfV zIK(ZWhd3ujCc`YBExbV*XRQpt&WV%yiQsF^j%4XPtK5u3APq}NGw1I%0#!XI{uAfH z6kw^ksGx(zeDVG>DjwNsv_5je{|5GNqxGT_C&Wk##E7f*j^wL(o2Cb&ViAUv?2Khl zkEJBW^4eLDY%+v8 zVBKty*nRLf%ODO^W+QWV7=g~Q_`+B15~E+B0wq1gyzp1ZgbKlH?$u`RXnnWZ8?K_0 zuUU@3fX3SEnMj-oJ83@i$?S9j-C-ZX%D;}6@PdOJEk*L<@)_)q@gogt(Lr?&c zD|}o-7wYz=J$K9_BhtNpl+R5He66A?Y^V)?A+L2$k$7MgM#%`<%f--;y2Zy z52_O)MHBq>)P^mwhR(Uqmr%52n4-Zi!^3-ag`9vcKB@-v55QvVHLVGqd zfeo_cfJ-$dGOb7U0PjoW-^A>RIY;Po#X}^Kjp<2Z9FsK9G}Npgr?0zen3BU3MI}f>6cQ^S+wl~#irl&(R zAzmp)H$gG&v~_=A{zHALOSe}C?tvgOc_d`f&MmG)i>yeB8+A*%v3Q{)>ozHN)NyBb zo&F8~7#GT}~-$J=gl$HHq=_q7w8laW3=MyWohBs*PTz2+ zrAjsQ`JjF%LN5E)E#8?CZrth8>r+`#w-}%@=Qbwi5ExTZ{zC&|Hp6V>&cX%G6|%@z z*?;zorA$LkGM|RL`Vq)J?BawGqs&6Y8$Mtxh$9#)|6;bvObg4TTX&O?EU2Gu68)pX zw5D6v@?yMAe>=0JEw~OIz5aQVl_Eq%t}|5j&kS5*(Nb>rJCW-=$+{R#r;Hy3p5&YQ zbuInVIp%c;BS@VPwPt^X;91hGx~^_Ag-^%OCE?||vE$SL+0J|&U31+u7%m$Z2T8^` zObz7R1)E9muo1OLWQLt!|A)fz%ZiteNlx?bO zs!J-&t5UW?w!HX#ak*RNLg_-8NJX%tekJNX)WWmqZ2zCI)YTWOwX3Rg@HzFlYja2D zxaVMVi}3?TmQrR_dOVAB%crjr98m>o1AcC_;fb17YWlPpstuK^23Ge}*Hx2Jn^Pej~nkgTcv7XNzWENZ`#;abZRZt+dT zRp-f1&kYSz)Daz@dc=?EU2->CyeTG8gsiyNO}@FPzY*BICp+PdmQKle3dA2W)0}Pi zhINa0{{giv*Kk3(X8PNlgke&>!^*3+khJ01Ww7Yts&86rNzf*?HB6l~PIA{^b&{rs z28cdiGv`kPw_t^>#IzHVM}s!9dl>qddmGol^8(3E2aqa0%g^&KbM@?7%%9C?8LhhXg_xuk zx`L`&hQZU`i95YwP*tC@XcrX`Tkten3)kQY;7vIRAHWLAs{)Z4fy)2Sj?Og=8Z-K3=0)hNJ#0!JGT6c=|`jyzaZ zDJZcV`K+kL%K5^sZp>kiH@sS3)?6{8#g8$1?&utM#6(tLSI+CJj2fy$7P430uZ9XPXvZzxR#97!o!v>h%{yT9>6q_e0Lg7@;aNF zdtTrdv^V}iYUqzYJ+Qn6o69kczmydhuqoKz(78E>XUDHAE&HqmZ0=$mVrM^&mQ?n}z3%eZDjn7%x3^WaWu*+o7(%lUtV%l6gXGn{{VXg-u#s>$=| zit_F-y8~gQ8$wU*J*4BuuSb%ON;f|!{GgK(!!7@)?`{OlL*4CzezgE6dJ<1zvvoBW z9k`E#bVcon_R=|#)+5eSOPlt__~r|h9|G@3JsspzwbhpX=r(vH;NEVAt>%2pF2r9v zO&P##B+7@iCyon6oK-#q+;D;`6_P4FJWaX^+<4MIdBQ42(Bp_3_NZG6rFz$#2meA- zLt+!t_b=XwLuxNtmv>u4`LfE+lkXk3wAHA@0(Y+nmx}S-Q<{I?aN%)KsVJ@Wk@CK< z@mrA-9zxGEJq|>-98L*Gq&#-K8-48Vb1LGLc!Rq}=z`ZJy-ouZ)s=4Xo zHo)yH90K-~j0qk@&HwTG+={c;TaZH9xpo zly~x!+GFiy4lOup%>R8_E|S+h23tKK$iztnY4@Uy`{R|Bj8&$fa}&$Uimmu~526~arEY@*E=?tXe{O3{XP1}9;%%j^Tlqxmq;g7lw(_1_JC)84I)xvfRv#}Y+dD9B zG5n7p0_@gQRDIBA++g@=9YSuQnd$on@5DWzf|hopKBb%_X#TJG`Rjkl&xQXbKV&s_ zVp#C~M>1s>E1N0@c~tEr=AWsT^3$*ygZvEAA3{$;5$AY-2Dejt!dWPS^AX>}o)$nc ziENbZsr=MGxOd1-bv`_`RFL+;W>An}3jrFb$6q|y3}v8Q?-P2OiI9$Net!3bv4>0AzRD)VZvocyqiS^xdTY-42pF+=~D5orkx*nZ~S?3|BJT{7acyoHhn04d$;D{ zyblj9KR$Zz&~Ckd;)QT77i&fTQ4}003LZIg@22XRQ-s0jH@6QviG{rGJJT-U*s3yj zGeyAgExwIhK6j>F$Z&FA@_9MwQ)jU_;_%|9ubFMi$qg9)lG(l>+o30I!SBrIqqQbp zbEbVoi>k5<`w^mtd~}A*5rpTAV1(vLH}l~e!_-OH2*HSy-*UtNSr#`KL?lM9FFd)!T^D?+d{V1Cip=B$mAS)-$A+J@W`OSEHAW0gU6M{S6&1q86jc_ok8 z>^*BasB$T`XmyU$YF@DK;@rCR2R5Zgf(x*Lr!&>M(t^l)KVUMakxu>-0+jV-r{J+o zN)Kj7^})Z$i>Ee|m+D2=G`JD03s2Z-0l_OPaz8fba3u@t4N^{3L6fuH&&s7lpG?nJ zwwgl5_RWm#pV><%jQau64~AE(qO6I#A1*0OxWKOtLNpn%mW1N^ieqECqKyLIM|TqT zskw(b$*GO)A_V*L{1sCYSY0FV@uTN{6mOHK0IFaqa5pNZiMmrwb0;BUDewXKnIBt| zDV;@`od{xZzC5f zU|i)7!YN;oCr$@Y_DgynsBXRn&7OQH6<>h#)(K=-?oI;NL|#+R#Y0^^QVU%Gr)p)7?0D--m;55GO=c~a*kZYn!s$upL+&@r`eH(^yMed^{=zYw-(z`e!He8ztZfr1L2KD_SCy5Ki-{5 zFUh`nrpYgeGAF^YHh)MR{)TstF&)zVc<+7V7iSsISB9v3)3-D0yjNf3yq)sXo{cZ- zSkM837U6e}xG>JAL|O2^?SF2{{m`yfq~qdv%m>-HOlY*fc(q>e?UZv(ptGQuSt4Ax~*L^E6KCH#6ILZ6Swc@QLf&h+*5llW~iF)xW|9y%I+R2V%M?GTa~phT;T_C z`@rEI4|cBXrkyPBVoYnI!&9y2y+6*T4nwZk9a#3xM|HzjB-CH>O z*wB`EP0_eed5PILXr@I%d~i{`e@@rC8u^zYeAmq*Iu#^u$Ny!~z1OtL^p1r=R@P3Z zxxS}+JYI1t;%<^&{9(Y)DvB>h*egr7>)~%oK)aP1>~Ce9ltv3$U29CYPbsfAN-*`e z%eJv7j+e;4Zsc0DcIR=9ouYBJu2Tlx{ASqCy$xhi2TB|F6 zR*ZEdJ-kOA)Di5ZKYVy9AE~X|M{CoHNVdP>cH}^kb^%(arZ@kSmalP$>LHmo>4%b^ zVZ#fHX2c&E8Wlq0&uG7_IeV+%&xTHKKK?Ss-aVjJnD7nmmZOLex8&WsTXtTxj*yot z);xLgk0;Tx`+vOhC)qKtHNUc6*cLYZYG-Hoa$Hhj)}8R|52fj9X6l)5lF>$tk^wF0&KjYSu`&iTaW z@eaUuIUBoX=Nq}F?=!Krxe66bH8sEa$8PhU!;!L2$Cv&89{^WCsK2SU@*%ZcK=+Q9 z%1bJ)5l1-;VVni==O9^xYa(-POGZChYAtIOn|S6)9tI<^qW&PS923oAw1xt3xoHF( zB_zMH07YIFphKzWh-Mo4)a9yHOfXK#P0hI`w6{@yS|Dt`z5p^Wp=YCoR-_4ZHd@3A zkZ<$m)N%)_4XJVp32cZeW-zBRv*nhBo(2s``b32(4NuexIn`)Ir>p0qxut4exLL8= zRODRLT7EB>E{&EFoI0gb4e1T?2=pwmA+XeGSD@?9L+gTHV;nZ4suXBNZmX2jPvr@P z;dwoym{GavIa@C^g(qdwkhl~(AD2LmwZ12u^dU?%Zz$_GXhkp0CK zGt($Ha!}Bm$uQ(xyIQ02lc`j&+nskDMYLNTlyd^(`Z`-$h|)0>jcrbrkZ$FP12{aX zF4iL)sc6(du^g8hty*$Mv(whGsh#$Go4yZlCc=Ii|LeZ1cs%FLl9EQ2-l^`fP@N$e>`6r zXZ(nl!EF_WgR$=geJ2Xg!7|M&5JBog9F!KOo5sV0_5cnAHmWWG`4Nx9s*6!YCIhj> zCNc$#)N9Xf$JeAl9w+LU0Gt_`sWzipwQiH9A~J%{NZ6I8Bf3;bo;=*VD;ZSd--ory zjQPoU=zI|}T0Rd1G`cine!5h=O=yTrQy$`ytb`~xZ@E~^Y={hVAJVK@k|DV!y?_eK ze>SQud>d<1`_#p)eM&vOZk|d-Uzc=dly+Uxx!ydpZPj`ua{U-)TFZ4w;Ck}&+v;^m z-a4`idW&^Q;QDgR_E+nf#PwmA(_^knLcbe)uia;_OVYo~QRG?;>ymht^LQD}Ubp>n zRUIk9Jg1;^u^Rft>rLaeOpoi1;99oJdPIX1<2`b=|zzw%^u^y>0+r zH}`HV$m@>e+ciP2H@>cH*!8hr*W1oqZ+mcEO}F(lv)0ijT3_pBT@8)zhB5G6?xod! zl%yf^H9QFgfPJ*!XYlV6qeQ~H_a)TyBtrp8q1MwxEjKc|M;DXpND+b{UDqg)PMK22QbK!g%!= z+lQ!~Bf?C0P8a7VBQ9YZRWJ_dQv__O#$$w=F!e02wj(cwyZgB)-Da|l+jMZ(PEsd{ zbgtnfrBo4}BPKLlqpd-4^2QTg5+HUxG%TVmwsG<{Mu9@p$Ocl3CJYyV(~V)omP^x2 z)~nE2q&meFZKl*-g2uPgYC(x4Q`1@>AqZ@VE6K(|o)m1CT2L6%Ov3x%Dq4#kuZ`vj zM&KUX7n;~|(iUg@PFn3A=Qsoj-@3C!`DCYFe&V24J|quRL+CPE)rwzU0n!R0&HEY| zqrAB3&ZH(cmdSeDF4fC4fNersXNq+UUTi|CnPSV&rd`*mmKN&`YJnhijpoHty9~s! z`)bo%Y@>--jHS6OE`b4%b{Hg{b5H?r?;VLF@gQcV6vr2#r6Nq?nQL&1YsM^bsJ50k zz$E+=b{G*Y)eF}+_^KxcP|JLa6!;-GRfI7nkOy!5(+xQ(2BV6v|}25=5)y zVUpA-c&xD^a(H3gcGy#`j8&*2tAsia?$_<4;RS!3@jG?VtA#O^cY7(!age}kicTj= zlBliRBN zge%g#z<#O}FHyWSvc-*Sb|u!1$n8q4>nB;+-XrNYPSk3pW(;G4YOPj{BQV7)thTv` zOx|Osl*gR-LPg7)f(qjasr*P4<>wRx2pME6S-F4>Td`+{qlLuOuw18Hs>> z2-^}=6(NX{SC=}Rl(D;~U6vSaoF*nt6B8w76TgkcIk85nbtIfP?3{0{XOA_InQ$Pp zCpzP0>kqd@)1TBk16_x>*8H^l1D#g~W%o$?zJ!2wttKxCIN2iYc@i}5;!WQiM6GGv z1SoszoYw@!o1@dW1i>R~`;vg&{lQs(O2m7ko!10qw?@0~36eK}rEdu$-5Blrgdp7- z?Y>)Nc5Ac(@<^?0U7ttb%OHgL#GN2w2jr2;uIY@|BVo(L^#o{t8?~TW$s7&CR}et* z;((KlfC=7(XoMNB3`l9`oIT>_fMm*tU?N=NNqP^CboAlK~ zS(kxGm{25JuhX{_L8IUFEkPtHblzn?4fpi&Uk89~ihW7IR84tDHXaXaw8rsRu@27( z6hbsYm32PfjMpPcH;VgAv+$fiAtZ+|5Qu`x52^w)~nBhKE_) z_Y9Jcv-q+4P&Gi-uM!1SC_v-|Q$QZ6y%ZqpSBd;I_)s-~+jY3GTw*zLlM4sBMu5DS^7EqCrvQ-`OaWy{_4*Vb@`9<^3X$31T6N5T^&kO2CsUJ^ zMdb%ofgZUX;Q5jGP&Gi-pCO_nXIZ8WP$SQHHIksQ$ij01g%FR>o`myx`%pDN*6$PH z=q|%D1%;%ZCqQ=;R-HUvoy;jckAM#usRn_9@`8GY_=3XFv1>BOgXafYBg$*Vrvfec zLWBOW*FSfd@ygoeVnoApaZ@1u5pRu2Y7Rw>{Nic419{JvC2(E^#WQCVFnRS*))ino zId>LQAm1Mnc^*b*&OJ&|s8BUP*6$FZ>|K7TKSPwhIS6~6(&ga86k^}!5;zq%3&@f= zuZ;5MX2NNibVepK8IzpVOy4pHYSBGkLXb>nIPU?{hIjo;#Itdj;N;Ck7xIkPFV1HM-yA(4e3jWj((nu}OFm=c$d z^n=U1gzwczl!RpwelU`8`W_$^h91-pAO~o(exFGCEZ-|6e2&(-9*|O+yfP|1UW-`I zmnCps8O7b7I1CDR_=OkE?aMBfcNHkRqTY2(>QZ>uQGVy4o%KF{0l(|G)zHTq&6Vu> ze~eqh%y^~Z3J7=Cma6p_&!C=-mci_FvC2kfB^7IK80d;ace@I@V%62wgKsxm-39p0 zwIFwkQnBqE>PYQhQy5a#P#^EhZZZ>h$PZ36AvxpPf}FURR5e{u)ynZ`v>^iqX3(!f~n z0`Dlq$x7_;P63MkkdKW<_%kckBw3*NE{lKodhFcElPAs=XD7e^gnP;#8x}i*6YJpY zE_X27mP^egG#H97Ql~{b(BAWqW!fn}*D94Gv#(6K#6(6dtb%rn&9O!$d6)a#xYpx7 zi+K>ejSz3lz%3q+M)Ur@%nT3`I@4-gTA5ss9oD#$IXtnJpqYuoV4{H%T52`wjpUXP z1Nd~W1Mj!>K{gSxpA_CR8zvIe1P_D!Ovo-;+EH61{A@dFx>r{v4QyB@ftIdOY|*7Q zbO?)`TB&v7QnQ8I)Ola!Vst6pS2EkIRol3Sp;&HoYLzn$>`&t0Zd(HK)>&VPXjj1^ zpFGB636!H0%`Jf2(cq?P*FTXeg5~3a(4B2c>uER0d*RblD(-a*xCssOoNoALENKiF zFD<(fjR3gEvYzbWM2NT9k~Ew7R@^ORE(ln}Gc72D6+gm9qNsVcbkW=7ENKQkZQy>c zGQ|k}o9tI#l#NyCu@g5UI%qImUu%y}oNhXfY1e+M-D!F-cRwy}`%iGrCbQGk1s1(> z<;iR_D)ScbigpWSc8jWe1(m%6CDRzuu)?$u9(4I11FYipjD&o2@Pq-B;UOREUW$H5HblbLNU6O5?6+3a1ZE&tP0<94%p3k&m*BeQ;RTP`k zZmzy=z4Y5-jYgG+VWjW^{HcG)}HJ4&CJ8 z!@tw@z|6VsEOlc`Ip>yrt7rX89iMOU$u;K{zr9FwL+-j2e0>bQjP+lfw`2USPy2U~ z*0t{v(9YcF*vT1lI&CeSIg%4z-vuN0hii@bQcW)fKwE1GXFMFMlCIQDjkQ_28z6*u z2G?wIfk4m+*!dJ3l>|1zB|K{BcEDM^l=;Tg*l*{L1KP@6L;B>+HSR#UM!}|9)6LX< z@Ts7E4@X_x7jlg>tm9B+J&f>~bsFKU*Pvr+{l+g@RlhDVt=q6N=UKYg>`y?RK=>SV z--;#aDdH@^Qp5pC?9sr$th&(lh%%rtmv6XQ>#+>cKC=MtrP)tiCK<&__S!-#6WN?aSTrLgj72x<=40?xxEP=AGjG&RA%7Sbe9Q+|G>ewE4C< zDOaz3+dLi)u7vx}GUVPN_nnF)_l~)5pP_#P-Guusg-2T@Ih~Jh_zk6cM4Qs)<{DDmP}IXew(DCH^-KZnZa064q(mv}+m z^RL2D2Jdd^X!0s9XQuO8e7Rk*oVh29Ki=qXgz-Vn#!AQ3h*c;rhR|WFMy)CrF*z#Z z++>qnO&Gf#yKKl2q+1%;d`_uZF!%TN$#;T zW4>H+)gu*$st2k*+Wc!epzY1eyBbUhpL_q9k_tUvEO0exEN>l^3V*HYnO7~`VhQ*B z_!{bIoTwP9j_69N8JY4fE>thk5C;mF@8**$W%xd!PO}yz_raALtxD!5D-UEZA@q%X z%!^B=T+8Qikrf2_vTN-5PSnc{+{QJQfC6rn^y{m%=CRyt)9sx+pLeWUN0Sb(v$P<( zPc?&l*hNZT!T{Xpl75+oKbZYJ0E%|lbG>JMYb-j#3B*C`Hil8kc~ThB?|BQrhVej_fjrmw1jEzEpG%T zs93wHMBT*kz^Bu0m1?+ue65_PcEFlB+PBz^7{486k^xpJ;!M(Uaw`;cl@#4gNEZuc zb%-~2m0}iX!r2=0C~h9QHJU}b&Mt6u&<(HXndY@!#DH#*ZHI6}R6P4=lc6_OXfLUxl5W&u5 zy*+wAxaaH(xCajifL_48|BwLag}*k9)?1@9&o4GjjpSlYzQWZc;^V*P>eWlMO|V^B zZaUQOE?p>T@Q3XMxDvd*a732T@Rb`v$Qe}j+VN5x@m{LQ1^lMgbc+>0K;al^WyjnX`#IA$I(Q|4iN3zR*UYUB*u!!77c&HEzU^$qP?g+4XPUvaGfZ5tO1 zYV?V2@8#ik#NY5T<8=swr<*Rx9h!4XQT=3uO$8r$tykDLu@GnQ7Lt(6mZ1(FZ+7U5 z+vZpe_hL^~`8w*EMiY1bLiR3}pq(Nl-9=cUYth6WXmrqqn4_)ie7b{7nj2w+Ir^Ju9;Kj)s zU5ZDD3k$qX@mq3b6`fS=aXBa<#mkRFywr4i!|7;0FhAgev+Lr z@rS{Mj>}KNf;)#{6a%$rPtY`5RVK!l8F3R+8Rn%*LS~+(PCGCc{)YohJ!T5*Va|QoLNP7x6o?(zK`EscLY z79y~N%8_js68}v4N~C;Nipk_%Za*AL*(*6pSt>|o6y`EbubU(rFDKnzZ-A%Pz|@R2 zU~&fno1>Y4Y1fy5CBc##Yl|1e>WW>Di*dMlkg;r{G#Po(Yn=~s%*W*PqFH%lGn(YY zPczG@M7DD5yw9*RCVnM8CZO;oz8$h9hb*mc+`e$7!c=0)AT45=m1=D}N16K0+Ly5e7Dka!yK+np zV|wyTp(58utzUY^dNnCT>p3khQ#3AuO280N&U{9dB3{c9+vB}C*wYqqLf~@*c3KMA z++J~8j0DClhkGJSP+l|RgP3~OX#yq540Gv$^olB}?)P#R6A{j?so zZ=oW@IQx;F`)BW5^2T&+F#+*qu8qghg^xDouwgY^TRFmRljOut5%CZX%ns>>rQUcD zoL@RA@2Sb}So|ja2!zkZdc4q1cUN_KHR>kaqxl|$d-K!jLHsrj-s9wrVU6=p*h!O} zdgqciPGh?AXy3=YEUShMxVZ+8dP+X8vvl&M6(3|r1KTWUX`nnPV^FsgrKnQB?NMDZ zvoIaWS^1>pUUV(U#7{9M>t_;)s|2D0o;^yFQ=T!(5SQjW&hW-r05hZ6U)Cv6M{p-A z7Uc3zeA2mz886M`I2&ebLm*rdyq_;MC>}uen^T^nC$) zvP7Y!@=2v(tBUQ-_%#_;r(EGH9P+$Ps+E7;a|>WdM5pe~u+P%*fGaDrhI0+Oa(=JIjFl-$A)=OL1b z|MbQNf6Ti~Gjp*5lQA<--Hovf)N5V*tScm1_B66E{cDYTDV5rM29{M=BD#=Op=Bk( z^_MUDC^za0wQ4!JX(bEgn^KM^{;_~Wxm6^~gnL20^elGX$K*w6TA4s*K?GY*AH8<9vPDNCO5Y&7DwJ791D$MD@57odt) z8s*|bD|#|*h7t&#qG*&);%h=q=fhn7Ss(=B6$U>VJg0z`>!N&8D*!^cN5OlVeaVzb zCV4Jos#^Dx2S`jqhCT&B08Eu1B1~8Y2%&<6!5Gt3ZO1=VYrE= zC0+wJ!(fu%Tw{u0tVy)Z4YJZ$7G-h(eEA{mS96KIYn3uE4&vRZBothpOI15g4Z$3i z3i?#lj$DN-<|`!Q5F~d!vd0U8cZbJWfRN*>N9@jfc_0bk4oDfFj$~XwmLd*FtdMwx zk?Gqo@<9Et)Ttl80r+TxFP(C#T~3#0^*9IZ)TtZ_M@cmbr>f+jlbVr(zeWU!(&x;d zg}SY^aH$UGWAiWE3N$mHhIMcaJm}dP*xUhrsx50{)#NA2qpV0d4Y%Je2W@W9nEDN6 zrWp)cIJf=EYn8mlCfkxI4Me8qd-Xa~YrQ(@*FLv)$sieWfolj={_JL~0kP?vO})-Y zFB>v|lI*i#8w(3SZ7pr_OpD9SJYIxKdm>}sJCnT04DL#;QL;@(;+wHAW7)jqSvYHx zNE)?zY15 zcJo1U#ji69XYtF8WQN#jV?^F#*CLkN_KXF-cFb7 z1VjrDw!oM?8THy>SQbntU}&>8`>opI&FiuAE|;;7QAFzWRED!wEW|@uO2=d?X|r(? z8SO}0sFfCD4pqe)@wtl7ro0q7>-d*pk}R%wA=# zG>=~bsPh&zXx?#+oG*AVlXi-1&%b3hh`UgvCR%U*IES7MP!?k5 zrXM+Rrg&!h%n5lte(vn)_Z6pSPMq-o$4^hsT9VoKoEtxTV!|b|AeZd;^y%q@$@J9J zxTT#tJ9*||8}qrTV<*mvXYTAd8~Eh->4edlbEi+6W9KGMPn@njh-&A9iaie4S-RBILY!a`0+ z;^ibJUP)WxmzZ&%?=tRiO^zMCJH~5T?WraRR%%C!Tz!tONfBR@0*twGV-5Z@`RKJ7 zlh)ddHR?01>T;DX*XAN~cIomqP$&d`nYAypkD09$5}XqxIV{BJ$+&Uk{{5q}PkO4< zJYH+1CokqG1Jqccmku8=8#y%?oh+5<%LkAK;7NsML9-f2vV|ufynND0GER~UK36}V zA}CiZgxKzur(R*a4eBtDAEM=?C!3cO_`~>78ru7eXSq+*BAm3gU+)$SeH^j1*pV+8 z(Z>=6<@=n?-ejLIpqfv{<8fSFq@`qk7qc9&MTJ}UH5+86fd}XT69h|jaMq%7PY*qq9^O# z*UZa&3QI?p=;{Czv1lFN)NRVNHIQl~Rnt^oMX> zP*>~`>z4Lmf)4qp@A@H0q(f)ola=7X?w!@+EtW2-4xm(ePu zY|<4E7G+N((^W@}`42*rr1`Djfa`ptvSN7c9vRTmH;rHLjnCW~cq0>fK}=vEmgBg< zF!?x*v(_Tl;+H#dyRqyY?F6X(Fhu4%5oJ08X_C(^xL;e~k1gZc=Tk~_nFp|xG;wt`nfrKcg~02w7pi5h0Hlx+1*}YC=I~y8OKL8AapdzJgMHGlD+L$t|2vYA1&RH(Xp3e&BG{xFRG~4 zt9Zc)9@d5O#6L@TmpmRqr6mXV@?(*YEy#Lw(YuR*Qch=3Vz3<`7BJ$iso25WH~6*< zG%SuMtcc@osXan;Q_)DnUVCDM+M7?tz)W2RF<3j3bSHQna3*ZDYX`{c#@3E zUQ`|`LV1-Ip`=Q2bna}`blih-=7a9>I8c(#GILDcViRL?fM#CP>IfyShF8!)*Hyve zB$1JAI*^i>0`tjKa|y!pNU*|pA=DNy5XhF!>B>kMY6T?Rz00zUhpF&Lx8Zidp6GH< zwb(-~?wJ;Qq-Dv_!IBF`=E&9nQ= z(>>bG7VYeYlwCP;7LIaPy4^+V z%$jt#*z7MLyKBS#(yzO!>#pCX%SG8Wi(tvZu2`fC7Rh==x>S+O*4xQ?cdnkN(PjFt2Pa)Omy<3AvclKJY7geR@HhFO_@@&RK{c7(yX`GW`Z<+ z5Qe+-M;VqASh_`;2$`2T3#tdDI!{rQgrv?h63{?WjJ1{>v9S?P6P41`Q_4!V%OW32 zY?S^U08Y*@5nFt=E8PKLIWsz3NG42c(E?aR)y1W@@kThAj#LimV#4Pj3K&6R=Yyw0 z)2{UR=~^ z_v5sd4NWg>%pJr>xSeb6w8x$maG_)lH)lSdgOo%|n$O^U> z#wHfvqf1epKNf||4;k>caB_t2+*@31(KJ(PFrKWoV!RqhPOiJgknQ9;BHMx) zErs9;fTM5o;+cvG^r@5Z8jexh#TtGhbu# zodp;oJaib!Xu*tOH28i1nu^&w#~wObEFR~j%zC4~vfSvzJTYsR21e(Z?udMLGaju# zB+JF($ttyZ2S&fE1<6ZhjSDeQ&*!rrb}1r}$Zq3JYn1|+KZjpDg>8NXLa^Dub(Ebgl0 z=ClUJcvSIv9h)bqn`x#JnJj|_K$f_ZI|lu8?3+0!DmZs|Z3NFG**l7qz6Y!c|C^lL z=cL!mOyNA~3}kHzESB+#pAnhgnE`92%`)e+Jm=!*Olc9)Rah*s`GVEY0unGh!QeNLh>39+jrlQLMZs4vHh853Jr5w`lg2Ye)v2F9ZAZx zLJvEqmCW%{vyFE*(|2)gSV&DWShM%-CfBW1Vj7i%;}6rSgH^FF?NQSAQFFdKL*<|o z=s7ymAm^03x59ZdI^^()tWtKf#Wz;B9)&E&!Z8!zE|BysX@!od{r$*Rel^ zoZ@6_qggx+E#ur$sXpDJ?NZo#y0_8u@I(R5cbEPO$3(h8-;>6jvW^dt*y1L*#1j<3 zp=*6FXsyf4S>)e71G;7v10U%wzemxeI9sYO(iHh@XC6PmM#|~Pnn#_DcB$qWA3*Ui z%{H{W0!ePfmeF%pCNW6%LbcVXFWU<(WYe5&j`*Wg_A21xP#HVCAyEd&GP)OpYxwau zZ~3n?oh6^br7N20c3H(Z!x6mu)ojiXnW%s}UTTlms?fE?T&Wy@Gv3dT9qvvZ_p98F zWVy|&WR)!0LYIZGUu8GiWz`?GndJqkMx6p5&Hz)k4`}2^yNs)p%eLGlhl&>cLLS=# zqYC+fgWbh-;7~5x`@7`8!lIjQDcsT2pE8@z5LLQl9x2QYc3E=|j{1=vJg6}{oFRIk zOXf#3W~D9zvpACT!W6dR!&0UTA@QNnF8jO#IZO{7>XHGA=M=7tE>XY-96-wMXqK$Y zPVG=xWfyfBdOEH4PUlO0T&!VI&VChA$y?9cJF~h zD!VS*ya!k;e6Kx*JDU1aX7d@MF5A2ZB8AzJF5A2#ERdO~jw2r$_)zeJ0XSuSSP#-= zLwMxK8mzl)509{@LO$Ze90S}b2JQ|XA z*%}@#=dkRuJv_P)L|q!yS(Xllq+Pa+rTcSOcG*6bSU`N=C9RRoxWAjox@;R4vVtXM#9>~;q!Cnd19m;e z-oIuHqx-uZZSPkl%RI7rmW?A&xio0E1MvN&YsAs*IDCIrrgPD96L*@XN;0}XtBO8N z8tZ6QClzL+UAD}lqldbUwab=zbTlh?+~L41vMNc3uF@E?dYK07vN<0ejn<5z>&5E> zqjG@KSz@#6gtTYe*?xsfQTTnDhZ@D=Y_%Q9H+rHLL{_TR5cI?-PpBPAAZF~LCXs*{>>!yB%pO(vi5X_t6yBROy2d`Kw$ zpp==UU1O8Z+5>X0RV%pioUYZ`&(h4cS88&dgWZgX`KFKX(28hePs53a4(U}Z?wQym z`S!T%63#O7C+w56X34$W>4$=7uGxYoW9JNF=13wa9qsh6r{@Tfo>S!D>DfX4xQ~3= zM?UN`Ua8E=WH#;-E0=2YQJ%AnPQ8*G7tC%6^}kAo3maLzN72v;q68F^Rybe!;i=>V z#@i@B_4t-qkmtE(lP+wf-D`xF#oXD>JfBub*51?d!%zRv>RGKucY=;LlOqYvRxIz6 zJu*peOY(^Wd@$BR@QXBK>gRlTdi(qZGYfIx$?Gbw+~Fmdv|cq;Iv=^EH`l`NyyHe) z$;p`il^sq=Sw0Gc3+^U44wRhcOwR{7?B#SM?SM@8UM|uGhH|Zh*`yRCp`F8y35<^q zmr$Gu(t`NdvU@<7rNl>N&Sj2Lo{26xzSE`U`AR7O7~7!Q9j(+L;SB`T>ZC_T$N0=D zOJ~7eSs*uI%QBI7&o#~MbvcQqu-mV&!(n~q&PE~4+{P%xsRz2ydc{@lWmU70; zDxj3O@k85|x1aWl9>gtYyc=vemPLNt2rmo!=?<}j=>{@L}x(hTq9X5NWrrYwL&Q;cfOfAFW71+Cn(s6~e*qFp^}$ zo!fDwBIFO(ajOdrb_89Ie436gZ;;NIKWoPyv6FAvN#&uCl#>!~qGLGSM^+Zk4D@&6 z0V>}5u*h4esBSowak7p(d20L-Iob&il0Jt9QEkO(N%4~brE)v58Te*1ta*<>Lk2zA zqfxDf*C#|3fJrxp-~HpGNmzQ$Z3A z11WxOk`&L~LW=+Twi>f>z`)<)NmDXaQ!|mNm=SniFl~5m!Fvl2=fmF>z=N?0kf+Q6 z^9;CcfGh(xHV=aDZh-G6_)}&S+`G*_dOry7J(oXxHer(nY?uzbBheuWco8Cw!CeA; z`@4~hl}QL&Cypn~B{044{1t|80Q5nk!?5?jTS_@aykkhsBD_7AaQ3NYflmoIo;P#g zD-rJplT?~5O^5?;8!(%jlxwqP2`EY+ZnJrj@@57q;MV9pGUn~)fb)5H8X%WCa5@E? z=gbVeEfdWWV6d=E--E{7H%?rUXPt6X2HrMjVP4J7SmG)hJX_r|X1iZ1W_X!OgXLe$ zl$qICp){mQWA>DYSJhkqf01ITL1~$7OArEiL9E+q0LPTojJX}lu?%k=Q=t&}cL8u6 zfVClJa~Ie~l>ZjtJMdlt?i^>y%u~$fcH~wgDHVyjNE%Wh8DPno+at(-lTuIt>_rM+ zp>(vs1&UjyD7_8Pm9rF&%`MBRO@7ompxyj1$a4W&+-3%rulgz&6jAbLb9C z0PZx=oiOHBTQ-=Js`-#pGG^cyNg2~RLV0Pz|5~Q}?lT|6)8I(|)^Whtvb-0#qYN9A zTTEZiEsMav3fOx@o;BhFIjJ6}va6BKU|z9?#Z-nZdS~q!0Zfz1JdJ+@WR1MIBvQ(3 zJ#GLEFCD9nJ?bSrGBf>xBj*>^cX^P|^4|n~5*=yc!e!x5q ze?MTp$GpqDo!<9C$$byKf54b=EvHS&XPj_uk)C3FQCK_Pu|#Fwgc^Jw{7vY+n-nt5K|`?>^8AZf!UYZc`pi+6$Wk ztUvq)Jl|2J)}~E)ejGxvG#-RpzXNjrAow4LIPl$U>5#TTs2+2)nMj$_gt)qt2};On z0%C00q5hb|T&F6OtNWn#aBaJfYHma_eOE>g-f7I`e>v;0J1z|Trjs+jg_>8}n57M- zOK}b&sR{0228Z3slMqWJ#bP^?EKO{hRJ3uDj>9PC_gk8+PrN^iyG;Z5yQ^hs8O!=)!+tQF$B#j?AJOl>Fy&%?}zIQ>L z`0tDvJp<{&wsa)ZkB>lVSg@$)Xtc00U=fa(w}Fz(LT`M=JPf{+2SP@mC{MsM4f%T? z_>RNd8KOB3G?V0e8^A}X@aoiZ)Zh(kVV%kedzm7o9$VWb(0=TF8q{vyC+RfXkOIS= zhj;FQuw^m37>{))!EeDf0b5zy2H5)VQQcCMUf@0{!xG63YV__l@kUIOT6l~P)2P!Y zX?&|sVcWH&-P>;KI`*N^r{BFceZqHlN>`>NC{fi6w7u} zjT#BF#ll_bWc&L(OcJ-l-L-Pue59?OxhsV>Ne66iTcotcP*$;*o+eo}i$n#OTT@Jn z>Q6)Z9_SbD$j51^jm=VOwY*h_C*d49pzLhhQKTB)KpSjV3=}PTuh}w(+{V(fv#z@| zZt3Myajt6A__Jj13)%`!y-(wn^xbRYla$;W(ydWSw};d%a=Gt{L@%>xZ(A#BU|Gf? zs8g&Nd9-V#Fr>0Az*_M``bXEo-sknz68k{Wt&_Xc*2t}?VJqZdM?)-Ih-E5on-3?% zM$)9C*>K!`cM*P%9@0%ccluO^l+-)eEj6;d7OCu6ORLn^#-Z%rp4I9$*`Q4)l_J%* z=jV+_8%e8tcRpoIIp&_yY|o@+XOYrfqEQs~-sYAx_gM_r^fJ{D*ETb^yXCD?cp6a? zd%$eA_1ulq_9;mkZx1EU7Q3}KvF*#1;agMQ7bz{vqS3;AcQ(%b868NmsO1Y%FP1zS z2Rh(|*y;MHoxern%somTCQ0ip8iwtHw0Fby!k3TR_oeMc8r#~`qtd!$scd+K`fxsP zTZVq91EPzWa=j&w4@yE$k1ItzZnLWx_7k_Jp#t0;`M8AVtvYVM#Fy1hv)$Lmv@OcQ zL#-vAL46PDNT!Zm*pMCz)6FzOek( zq#tlc25t@=sM13@*lk!JWDanbTSo+@j1dxC&;qBu%Q9I?sHe+Hf9tlsDqhiJm5$m5 zx7YOB1`nh57aql}2w}@+ne^7qPx`ezm*yQ>3^}w1LtDzVpO$EB?pn?e=6lx;V`Ept z4!CnESVI(RZCHc)?c)+zsuh_RHb=WlkrMJ2KQ5<6-ma%2pF*kYZ@(6gwC_wu%SGea z*Kfa8ED4X%ZevT@-@Cf8YSX^B8yl9}Do305`0Zr^e`^@GhtG_zivGCoE}d(JDoFX7 z)VE*D@=Yz?Yf>uXg=>V^jkSd5qN-9qS7`3NPIf{p^$Ew7Sy-S6x8~Du{mJk=d~Ke# zcZ?-%QBF!SJ<>bY;+&y9*j*~TFgwwY^9+lUHn-)?V1iyP)nl!7Tx-LC-#+gb->Pir7LxJC-Z|oj#uw`F8|mpu&hGhg=7-jT^38L{RrXH z1q8oY<)g-<7znTJh<4LKssmR$g}i%~pryG(^^ zCda7@v!Nnq+POqibtCX}yydEh$|j;1(&Furq3t_u72Oj{6VLMF0Y{6bg6}mw-+5cwxDoOqz4}7SLIhA0d9{lkzmXN2tkiG2!Y4&|oT;ZRvD6{6xomK$-fXc8m1f(#Oo2l=ZC|Fvwb%}Ow>N2c z)}c-f%4-1SgdtZ*YwW_A8Ay3x6VB#NDV_M<=9q}L+G$C5B2$*V_xQ{6Hk8@Ujc;u0 z^loj5$ZV-l8X%5c%H;bk3$#dUd8ZRcSl-EW%FZgu(ZTLa4LOm@HXih1H)M8c22*Cx zIpCQ=JA*;yHm3_7@P^~tGacSW)Nm}77UfhHWjB8i>M7K)JvkHN+j)8QBEOXH>s^P+ZUuKk%|6W?dAYwVr3g@ z%LU?O?zQ?~l!d*b@wa+-EzxjD?P&Dj5Zj_y(uF0~bbp~E4CNU@+bdGHTU3k9_RJLQ zTYY^F>fEknqT}gd(XQQ1nGlJ{<$ebB)0wh;YpBt7^9e2e4Qu#h>F*Z5raG7b-mJh{ zZ+7~Vy*R1sZ3b4Fvu@T*vZdvApI^8k#%!-q+*O-`QSM7PFFe6% zr@2d#+lpgI#xf9cCFT2zViDQRKOx@V9Avg*4jl>YN;iFB31a(ZHlqe(Z&eoEDH^xj zW2yn3{}#85i^kcUvE>E+^*EF_;Vkrfz=RENalv`|VG`F)A zS|m$vS({pWyWLD>rQV@hVmD3M4K_e|cer_n`$pT=Nh_k%Qm3W9-QRe{E!KjxO_ZWL zv|goXyw>OTuxH6o3@jRM-I|V!oaxFv^VBZKluk#xZm|;MUaTlR2x$9TEylMEl8_0W zTlfl>~vy;+UxKr0NVbb>6m zq-|@@eP)#{m)qU?s8Vci(5R7nx0oytJH=o(u$Y}qveB^a%QT&15nqtjAUiaVX}hF1 zxwnmLVu_X<*#bg~(aGh2C)sVzWZJF1?c(YQO3lYDTT3s%B&8Ez66^c!u->co;T`Fi zxF~fy+X~qH@M0?3!$otFB(Nx!ZIO0J*>N5&orJw(bY;QTHX3xtwzFfSW7~Gp9lN8B zZSUAt$F|K5JLuT9v18qR&iDOzf86)pJ!*{_HA;KceCB-Ss!jCd8P~&Yu?$#8~BNUAJ>;b_H$z3L++YP4g=C~kBFJMXj)z^%7;AJ zcX(%u=H~g*$~gUNd5u^FH5+jDjP|z4n+>BV*L=xOUjOQ&ol=6dcON!H-8iiYn7V)M zI9f^Uje6dR6411iDH`VA1UIwJs*S+y(x#o%e z)ne?2`&U#Z%5ysVZ?@S;H;?*&sVaY=(OMol-pbnd!1wq_)hBPYk1O_)b!2J(nxG>G z6Kmxkl!E*Z_KBCb7T1ZO05oY*p`YUC;mfEZN+=nFhkkbfye6@k?&;ov)KIUTmPSLi z-*hJfPPn<#bD7)>{(uC(PP2n!`Q)O;>*?^t&24$Ubc*<&fm$W~MUP$`D2_sG9~131 zuJpdWeHzp~ly0*;_{9Z3#${b`3qHCLW|nRJW4fm(v9xrX z8nTtAIr`hz7HwX?HR4bD`Y*}fekv};(6h(+*v@_ZJx}4Y_kCvXs{3F@Td2e8QKiu` zjm)yFJ0p7{?T@e0I_@9e@9Wc%uN7^zf!@zqeJ~r`{TDQ!GY9tfm;m2)HWAMn?y_~c+j?jN@T<3t8`vqnPWY$$`+86t#qK8ErGeuWx_fV1_>ds^ zWqR8d&1Fbi=@53iUJkmu()!4duiiS%P&KfV@|WUzNt@b>Hh7YzwgP1BJnTn`-AFe* zU(xlrD27$1`?=j7%9@|k3)(~P(QO5a+TgHQM}M#{I$kPw<(>^wZhPqu{58ivE0RAo z={_sfKD3M9YX4s=z;*vW=}`omXI1@pguZU#{ItDa3+e`mCU=s;;&ICT0rVIL0?o*8 z0rA%%NS;i?hPemUX4=s1e-s#efxtuwWs&g-0meZD8<@>>da^WLt|1aVLa{@l1wlbx z!x?##$xN3hO00KU)!EO@@Vt8Ui;4vhooviUC4j^!#rdDEwsGF%v9hl1+VUW=Ft!4w zWmsmAF+5p@!^ynEFChmu#A&YW7+%WM`y!C(syZdnw|A;_BU5FWl+G z!?w#DF3*HdM-10T<1kN+e1Z1d;0^6AM>9+gxh)9F-w=@7`GkRM*TVxAbBOC-f`U`jC->U9DKcY2yO};;^7h8OK>q96ugVS>WMic-VmOPhJxX; z2KSX`o}H)b2If_$%h6-+@I8KlCalEm^6Er37*MOM zbrzv~(tUgcl>>?6VMn9m&aSrpb*>=>7KuM1*>^>d^CXN(7;_g>BKpavK7A=hQRSwF zyaZva5JFJ($&60KAvJ6+B>^2CXS^9d?2;2$Db0S?&e$i-uUq_L=YOk0%DKHwEwUVe zqq00E(hALgM9%4qDf)>SH!DZpH8+d;=z!Ok8yv~mh2HG%v6qTIb&!O`yi?9423^H(m-y}2ES*C47Fy6?#9eaF2*kJO9f8uYuO&On3Uy^9&a>Z z&%%-fD?-0*MEFy4T~d7-fCls6zvLEpDCK`*IUF+q>LQ&yqdf$}GJI^ISG5Seu9aCn zAQe8TgRxspqJI9Qrz^;(i+o0=%gCqG1&FJ!%@J_&=-?5or5sBktmSBFqD?!o;7MF} z{?T@ZZSyf$aTLYsY+AlF&n$ z^9z_D#Da)o9Y-^QrujP>7LtN%VHS)V6V>_8E*1TW;O*B`ixti{4)Pcugbpi8 zD%U<^dUg@!V_NrRPCda6YTtd$?JpLHgB0=OobgMw%K)%>a42R&gY z3J}T?1l?nV=_`2<1w=CZLg#}{bp1~7rqKf&y_Sq0!0k6)A=6;tA2ORjG5)ba2A+rT zT751WsE~xTdFp`| zPGKQu^Fc4VmUJk?gj;Zh`u06XB)tR^4t4g8>8adGN`iV4PHi@Nn{^UyVJU218FIB)&nv4 zzG8uZ3yJDtVszt-O*r9h1$4|*x__1Cav;dhtew(3X@$|eW6cjByqS7H9zCJNmj*Ix zMJ^!R1a`hxJBF`HjYMrKgULGISwN%fBJ$4scW#N2DZVlhA&P7DgJ7VDkVN$uEPB2V zTE#^8G4wN9H+>$GKiv)gPU#tniP#32m!>;fVN(X&lodOj#Il7NT=%3zGTSAY$5dPR zV8|W`N@1Kg9Bwi@)PfWBsVy&Nv(^;l((mjPCp?V_W7bw8n0qI@zbxUR-9#{V6UG-j z4+AVTC=zszDsX}*5}xK4eZdWGgKg#)VPmPT1_Gg+yL9_Q>N*r8u&}3%-xM2zY0(BI z;|ZE=isa#!wtH&uJB6&(TWfpWm-1%I|<`rvjlfX95LHx1t^f z&nkGuKC}u-&nn|$IYM80iE^Zp3+AxImaHT~T|eR8Kpk=Eb(fgkKOWHwQ(p1jZpVoo zf3&NoXFHX$$_Z@2_I7!omHrVocG?xq{$YuhpleB+tYt~7VUUv#qVvoQFf_(A1S3W@umlt`7y*e|5|kn(k9xvK$I|Q2Zg}+h<;?{Qm1oTEanf&*Zw%KH3BmjMk)`AB^1*+YOkbwjM^gqv-`<3m^(9oM)C90cUfpD&H`5h?W&kn>TYERLM z!TM3UQ(8idF1i}=L!O^}pb2bW`2WFL(RguQ098*}gPc!UL*dR?!JuG0;9su zIz)Rb>JaNgD?v+&kUt?kIe3t^Q@Uh06mp+-yzml*SNuWFQ~IF>tos1t|ASnveh)s^ zbi_G*CiaN6gIKvuBrP{IuR!6FXMbhb4`78zE=07Am3J;C$N_YX^<{s_AWp*QwCL>qZf{n^z$~9f&(tl zg)nT9v|DW_qZh*R23`RtaRiieC6vU9ShJH`^0ofbI^9NGh)spvNObQ70s{ht~fTEnc?Au9U`h zbW8qrd#Hz2I@zw0p3RFpL}#k_I9;k0} zBxu=5un6dffnvv=qY-;lPX|MRv{Wbv`6Hra13U&{hDt<0wcX!nUPQoI5WGH;q|3Du zwX3zsnYP}q2ygQbIOw9@^7B8uqkwhYl4YBl7``)`7~QLzYSs-_pGa@>O%&uZ{Hiuq z(h})zA*WU}FJQA{#SYmb4+ird47aZ=Z?43J4&NM+GaO zC>T*-1tfa`+u7Q2nnA-K5z~XpSN3R_58M*958Pn0eMkSMu>x+6tZLH$ZcZ3-+5m3O z1#S-WE%FkK1$SDBGJde(%26OeX!oQo^Q7HB%>R9qADjSSpRofj={@v^naEG7PfdY10Y~O z6*55UOpQftITg}Gv9{=k?q{tV1^iu2WnEn@DY3jru3>KzA@tKG!obc3y|Aen%yBkg zj#~ulc=hCdetcGVQ09MU@FGEY_N4vq4E>^3c1#0zt3MFH9l$qMO?5GPIt%u5PBF-# z^vSIi)6mdQF~nT;$zMd$fCdXxL$nWX!*>laQbO%|3`X<{~i6m(nI*~=ng8G z%wz(}X|&M=@>tZ;X)^o`9U#8{AwqI7eX+6{c?r^EjDM9K66Iqh?_hiOKfHrg^or7) z?fuow)9dj+hBx!*s#RzHI$ z5AqV5{~;(ELS1X$$D(WioZFW)cG?eZ1E6k&$SQ*Z z-y#fBgiVqk;QM(mFhk+iXb|#Sl{5Z}UllNZC;u;gzY3y;z6tQqRx?uw)H18%6*Gff zgARq&goR@Je&q!!i7y=z^I(yY&r^k*c1VB%nbEt!1fc2y9v5up#lQmZU{;M~zx@t& z68FV{RX*uI5>UyYp3yW?Q0FWU20@uVaG2xaeH}hvJ|qS6Ax+l*ispIFprd(C6wF0V zl)|Ovbq}sS78a5rs~fP%1v@FDRiu8rY~sn}VCQ2Z8q6}T&~HvIh^mplz<_H-!(NOd zzMeaSH5qsj1zEp~L??z5?xZEbO3-VDe%U1Cw~cqFD$~MG9`g9DM)LVDdsY!6FuO zh(%Eas)W;q)QD#Y0Ov15@-~ObsclWcT4oB?GF-5hv4H&*1F*l+Eux_^45u-XUe;)? zF#iKz-7lC;YoEPr+>%vW2t^A2s^&7(aLOaiVca8a@OV#uz-muLY(GYvH<=CPK!ta2 z=B@2A(D0WYP-Cw^#nX`t!#5i0nvx+zs+*QIeV>C% zJcF(kk}fN0H5hSD^wr{gdHa|Gm+LA9AL}ZjC>zOU4cnz5l-GJJaGl&_ zM(2pv-V-RbQtf3~3ibqfm;;~}Sy@$YH_8|kO7hUHjzJq&fpwC(qy2Gs(-$^gCCB7q zT<_*%A>`h!W3*C9X=A4XaU#h_r>kM~#=CLntZTM;hUt4uBm*wnAYsBsayj{Fu>U5H zy4wT-;{XJ>v?$(0BcEsDPF8d0(NMY|Gb`EU!IL~&ckt_W91Oi5?oX@|UX$N_XB^c~ zU7PM_k+wrGE(5Fd0*>mBb~1t5b=qjPUtp8Aj#ipVNbWQdBW86Vm47?VG^%bKBY^F6 ztD!@o9NHy-y*RE;#-beBe7g_0mm>Q1%mfHkUvof6TMMH|b-B@8{G%<3yKwue`E-y< zO1^LlChCLmQGNdFU!a4{HLqW$OY0VWjre`ntKzcWF-Z?U3}$=ade@7{)D#Iq$K?sg zn@@wTyH3T7lfjo$1>&w-tS$K2J>Rh>A@{?UHOoc?fw8^D_va~ YcLF>Is+ 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

@G3(5=YLRGNRmcu2yo03pTN)_ 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%0D=o;bC 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

    VFitEr>Y{ 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 + + + 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 0000000000000000000000000000000000000000..5297654b97476f2d63e30d91ff3467918062c076 GIT binary patch literal 481280 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

    Dq;={zf#7Bvb5uYILBR)mkPke@WfcPBodE$%2 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