From 77f8c0d303c23d3d9bef2834b6af1af50debdb19 Mon Sep 17 00:00:00 2001 From: Eric Fontana Date: Wed, 8 Apr 2015 07:54:41 -0400 Subject: [PATCH 01/14] Bug fix for UdpInputListener, re-factored TailFile and LogsListener to use database. --- .nuget/packages.config | 2 +- .../TimberWinR.ServiceHost.csproj | 4 +- TimberWinR.ServiceHost/default.json | 2 +- .../CommandLineOptions.cs | 82 + TimberWinR.TestGenerator/Dynamic.cs | 2407 +++++++++++++++++ .../JsonLogFileGenerator.cs | 252 ++ TimberWinR.TestGenerator/LogFileGenerator.cs | 94 + TimberWinR.TestGenerator/Program.cs | 579 ++++ .../Properties/AssemblyInfo.cs | 36 + .../RedisTestGenerator.cs | 49 + TimberWinR.TestGenerator/TcpTestGenerator.cs | 62 + .../TimberWinR.TestGenerator.csproj | 115 + TimberWinR.TestGenerator/UdpTestGenerator.cs | 70 + TimberWinR.TestGenerator/default.json | 45 + TimberWinR.TestGenerator/packages.config | 10 + TimberWinR.TestGenerator/results1.json | 20 + TimberWinR.TestGenerator/results2.json | 20 + TimberWinR.TestGenerator/test1-twconfig.json | 45 + TimberWinR.TestGenerator/test1.json | 15 + TimberWinR.TestGenerator/test2-tw.json | 45 + TimberWinR.TestGenerator/test2.json | 14 + TimberWinR.UnitTests/GrokFilterTests.cs | 29 +- TimberWinR.UnitTests/TailFileTests.cs | 2 +- .../TimberWinR.UnitTests.csproj | 11 +- TimberWinR.UnitTests/app.config | 11 + TimberWinR.sln | 12 + TimberWinR/Configuration.cs | 10 +- TimberWinR/Diagnostics/Diagnostics.cs | 109 +- TimberWinR/Filters/GrokFilter.cs | 1 + TimberWinR/Inputs/InputListener.cs | 55 +- TimberWinR/Inputs/LogsFileDatabase.cs | 116 +- TimberWinR/Inputs/LogsListener.cs | 122 +- TimberWinR/Inputs/StdinListener.cs | 19 +- TimberWinR/Inputs/TailFileListener.cs | 121 +- TimberWinR/Inputs/TcpInputListener.cs | 2 +- TimberWinR/Inputs/UdpInputListener.cs | 80 +- TimberWinR/Manager.cs | 33 +- TimberWinR/Outputs/Elasticsearch.cs | 2 +- TimberWinR/Outputs/Redis.cs | 71 +- TimberWinR/Parser.cs | 8 +- TimberWinR/ReleaseNotes.md | 11 +- TimberWinR/TimberWinR.csproj | 30 +- TimberWinR/packages.config | 2 +- TimberWix/TimberWinR.Wix.wixproj | 6 +- .../NUnit.Runners.2.6.3.nupkg | Bin 572556 -> 0 bytes packages/NUnit.Runners.2.6.3/license.txt | 15 - packages/NUnit.Runners.2.6.3/tools/agent.conf | 4 - .../NUnit.Runners.2.6.3/tools/agent.log.conf | 18 - .../tools/launcher.log.conf | 18 - .../tools/lib/Images/Tree/Circles/Failure.jpg | Bin 761 -> 0 bytes .../tools/lib/Images/Tree/Circles/Ignored.jpg | Bin 688 -> 0 bytes .../lib/Images/Tree/Circles/Inconclusive.jpg | Bin 734 -> 0 bytes .../tools/lib/Images/Tree/Circles/Skipped.jpg | Bin 689 -> 0 bytes .../tools/lib/Images/Tree/Circles/Success.jpg | Bin 731 -> 0 bytes .../tools/lib/Images/Tree/Classic/Failure.jpg | Bin 808 -> 0 bytes .../tools/lib/Images/Tree/Classic/Ignored.jpg | Bin 789 -> 0 bytes .../lib/Images/Tree/Classic/Inconclusive.jpg | Bin 784 -> 0 bytes .../tools/lib/Images/Tree/Classic/Skipped.jpg | Bin 689 -> 0 bytes .../tools/lib/Images/Tree/Classic/Success.jpg | Bin 768 -> 0 bytes .../tools/lib/Images/Tree/Default/Failure.png | Bin 1445 -> 0 bytes .../tools/lib/Images/Tree/Default/Ignored.png | Bin 592 -> 0 bytes .../lib/Images/Tree/Default/Inconclusive.png | Bin 1436 -> 0 bytes .../tools/lib/Images/Tree/Default/Skipped.png | Bin 1405 -> 0 bytes .../tools/lib/Images/Tree/Default/Success.png | Bin 1439 -> 0 bytes .../lib/Images/Tree/Visual Studio/Failure.png | Bin 747 -> 0 bytes .../lib/Images/Tree/Visual Studio/Ignored.png | Bin 773 -> 0 bytes .../Tree/Visual Studio/Inconclusive.png | Bin 782 -> 0 bytes .../Tree/Visual Studio/SeriousWarning.png | Bin 687 -> 0 bytes .../lib/Images/Tree/Visual Studio/Skipped.png | Bin 1405 -> 0 bytes .../lib/Images/Tree/Visual Studio/Success.png | Bin 3386 -> 0 bytes .../NUnit.Runners.2.6.3/tools/lib/log4net.dll | Bin 258048 -> 0 bytes .../tools/lib/nunit-console-runner.dll | Bin 36864 -> 0 bytes .../tools/lib/nunit-gui-runner.dll | Bin 155648 -> 0 bytes .../tools/lib/nunit.core.dll | Bin 155648 -> 0 bytes .../tools/lib/nunit.core.interfaces.dll | Bin 61440 -> 0 bytes .../tools/lib/nunit.uiexception.dll | Bin 90112 -> 0 bytes .../tools/lib/nunit.uikit.dll | Bin 241664 -> 0 bytes .../tools/lib/nunit.util.dll | Bin 135168 -> 0 bytes .../tools/nunit-agent-x86.exe | Bin 8192 -> 0 bytes .../tools/nunit-agent-x86.exe.config | 37 - .../NUnit.Runners.2.6.3/tools/nunit-agent.exe | Bin 8192 -> 0 bytes .../tools/nunit-agent.exe.config | 37 - .../tools/nunit-console-x86.exe | Bin 5120 -> 0 bytes .../tools/nunit-console-x86.exe.config | 24 - .../tools/nunit-console.exe | Bin 5120 -> 0 bytes .../tools/nunit-console.exe.config | 24 - .../tools/nunit-editor.exe | Bin 143360 -> 0 bytes .../NUnit.Runners.2.6.3/tools/nunit-x86.exe | Bin 6656 -> 0 bytes .../tools/nunit-x86.exe.config | 23 - packages/NUnit.Runners.2.6.3/tools/nunit.exe | Bin 6656 -> 0 bytes .../tools/nunit.exe.config | 23 - .../tools/nunit.framework.dll | Bin 151552 -> 0 bytes .../tools/pnunit-agent.exe | Bin 32768 -> 0 bytes .../tools/pnunit-agent.exe.config | 77 - .../tools/pnunit-launcher.exe | Bin 36864 -> 0 bytes .../tools/pnunit-launcher.exe.config | 77 - .../tools/pnunit.framework.dll | Bin 9728 -> 0 bytes .../tools/pnunit.tests.dll | Bin 8192 -> 0 bytes .../NUnit.Runners.2.6.3/tools/runpnunit.bat | 3 - packages/NUnit.Runners.2.6.3/tools/test.conf | 82 - packages/repositories.config | 1 + 101 files changed, 4511 insertions(+), 783 deletions(-) create mode 100644 TimberWinR.TestGenerator/CommandLineOptions.cs create mode 100644 TimberWinR.TestGenerator/Dynamic.cs create mode 100644 TimberWinR.TestGenerator/JsonLogFileGenerator.cs create mode 100644 TimberWinR.TestGenerator/LogFileGenerator.cs create mode 100644 TimberWinR.TestGenerator/Program.cs create mode 100644 TimberWinR.TestGenerator/Properties/AssemblyInfo.cs create mode 100644 TimberWinR.TestGenerator/RedisTestGenerator.cs create mode 100644 TimberWinR.TestGenerator/TcpTestGenerator.cs create mode 100644 TimberWinR.TestGenerator/TimberWinR.TestGenerator.csproj create mode 100644 TimberWinR.TestGenerator/UdpTestGenerator.cs create mode 100644 TimberWinR.TestGenerator/default.json create mode 100644 TimberWinR.TestGenerator/packages.config create mode 100644 TimberWinR.TestGenerator/results1.json create mode 100644 TimberWinR.TestGenerator/results2.json create mode 100644 TimberWinR.TestGenerator/test1-twconfig.json create mode 100644 TimberWinR.TestGenerator/test1.json create mode 100644 TimberWinR.TestGenerator/test2-tw.json create mode 100644 TimberWinR.TestGenerator/test2.json create mode 100644 TimberWinR.UnitTests/app.config delete mode 100644 packages/NUnit.Runners.2.6.3/NUnit.Runners.2.6.3.nupkg delete mode 100644 packages/NUnit.Runners.2.6.3/license.txt delete mode 100644 packages/NUnit.Runners.2.6.3/tools/agent.conf delete mode 100644 packages/NUnit.Runners.2.6.3/tools/agent.log.conf delete mode 100644 packages/NUnit.Runners.2.6.3/tools/launcher.log.conf delete mode 100644 packages/NUnit.Runners.2.6.3/tools/lib/Images/Tree/Circles/Failure.jpg delete mode 100644 packages/NUnit.Runners.2.6.3/tools/lib/Images/Tree/Circles/Ignored.jpg delete mode 100644 packages/NUnit.Runners.2.6.3/tools/lib/Images/Tree/Circles/Inconclusive.jpg delete mode 100644 packages/NUnit.Runners.2.6.3/tools/lib/Images/Tree/Circles/Skipped.jpg delete mode 100644 packages/NUnit.Runners.2.6.3/tools/lib/Images/Tree/Circles/Success.jpg delete mode 100644 packages/NUnit.Runners.2.6.3/tools/lib/Images/Tree/Classic/Failure.jpg delete mode 100644 packages/NUnit.Runners.2.6.3/tools/lib/Images/Tree/Classic/Ignored.jpg delete mode 100644 packages/NUnit.Runners.2.6.3/tools/lib/Images/Tree/Classic/Inconclusive.jpg delete mode 100644 packages/NUnit.Runners.2.6.3/tools/lib/Images/Tree/Classic/Skipped.jpg delete mode 100644 packages/NUnit.Runners.2.6.3/tools/lib/Images/Tree/Classic/Success.jpg delete mode 100644 packages/NUnit.Runners.2.6.3/tools/lib/Images/Tree/Default/Failure.png delete mode 100644 packages/NUnit.Runners.2.6.3/tools/lib/Images/Tree/Default/Ignored.png delete mode 100644 packages/NUnit.Runners.2.6.3/tools/lib/Images/Tree/Default/Inconclusive.png delete mode 100644 packages/NUnit.Runners.2.6.3/tools/lib/Images/Tree/Default/Skipped.png delete mode 100644 packages/NUnit.Runners.2.6.3/tools/lib/Images/Tree/Default/Success.png delete mode 100644 packages/NUnit.Runners.2.6.3/tools/lib/Images/Tree/Visual Studio/Failure.png delete mode 100644 packages/NUnit.Runners.2.6.3/tools/lib/Images/Tree/Visual Studio/Ignored.png delete mode 100644 packages/NUnit.Runners.2.6.3/tools/lib/Images/Tree/Visual Studio/Inconclusive.png delete mode 100644 packages/NUnit.Runners.2.6.3/tools/lib/Images/Tree/Visual Studio/SeriousWarning.png delete mode 100644 packages/NUnit.Runners.2.6.3/tools/lib/Images/Tree/Visual Studio/Skipped.png delete mode 100644 packages/NUnit.Runners.2.6.3/tools/lib/Images/Tree/Visual Studio/Success.png delete mode 100644 packages/NUnit.Runners.2.6.3/tools/lib/log4net.dll delete mode 100644 packages/NUnit.Runners.2.6.3/tools/lib/nunit-console-runner.dll delete mode 100644 packages/NUnit.Runners.2.6.3/tools/lib/nunit-gui-runner.dll delete mode 100644 packages/NUnit.Runners.2.6.3/tools/lib/nunit.core.dll delete mode 100644 packages/NUnit.Runners.2.6.3/tools/lib/nunit.core.interfaces.dll delete mode 100644 packages/NUnit.Runners.2.6.3/tools/lib/nunit.uiexception.dll delete mode 100644 packages/NUnit.Runners.2.6.3/tools/lib/nunit.uikit.dll delete mode 100644 packages/NUnit.Runners.2.6.3/tools/lib/nunit.util.dll delete mode 100644 packages/NUnit.Runners.2.6.3/tools/nunit-agent-x86.exe delete mode 100644 packages/NUnit.Runners.2.6.3/tools/nunit-agent-x86.exe.config delete mode 100644 packages/NUnit.Runners.2.6.3/tools/nunit-agent.exe delete mode 100644 packages/NUnit.Runners.2.6.3/tools/nunit-agent.exe.config delete mode 100644 packages/NUnit.Runners.2.6.3/tools/nunit-console-x86.exe delete mode 100644 packages/NUnit.Runners.2.6.3/tools/nunit-console-x86.exe.config delete mode 100644 packages/NUnit.Runners.2.6.3/tools/nunit-console.exe delete mode 100644 packages/NUnit.Runners.2.6.3/tools/nunit-console.exe.config delete mode 100644 packages/NUnit.Runners.2.6.3/tools/nunit-editor.exe delete mode 100644 packages/NUnit.Runners.2.6.3/tools/nunit-x86.exe delete mode 100644 packages/NUnit.Runners.2.6.3/tools/nunit-x86.exe.config delete mode 100644 packages/NUnit.Runners.2.6.3/tools/nunit.exe delete mode 100644 packages/NUnit.Runners.2.6.3/tools/nunit.exe.config delete mode 100644 packages/NUnit.Runners.2.6.3/tools/nunit.framework.dll delete mode 100644 packages/NUnit.Runners.2.6.3/tools/pnunit-agent.exe delete mode 100644 packages/NUnit.Runners.2.6.3/tools/pnunit-agent.exe.config delete mode 100644 packages/NUnit.Runners.2.6.3/tools/pnunit-launcher.exe delete mode 100644 packages/NUnit.Runners.2.6.3/tools/pnunit-launcher.exe.config delete mode 100644 packages/NUnit.Runners.2.6.3/tools/pnunit.framework.dll delete mode 100644 packages/NUnit.Runners.2.6.3/tools/pnunit.tests.dll delete mode 100644 packages/NUnit.Runners.2.6.3/tools/runpnunit.bat delete mode 100644 packages/NUnit.Runners.2.6.3/tools/test.conf diff --git a/.nuget/packages.config b/.nuget/packages.config index 7025a72..a7df95c 100644 --- a/.nuget/packages.config +++ b/.nuget/packages.config @@ -1,4 +1,4 @@  - + \ No newline at end of file diff --git a/TimberWinR.ServiceHost/TimberWinR.ServiceHost.csproj b/TimberWinR.ServiceHost/TimberWinR.ServiceHost.csproj index 7ff089c..f789e38 100644 --- a/TimberWinR.ServiceHost/TimberWinR.ServiceHost.csproj +++ b/TimberWinR.ServiceHost/TimberWinR.ServiceHost.csproj @@ -49,9 +49,9 @@ - + False - ..\packages\Topshelf.3.1.3\lib\net40-full\Topshelf.dll + ..\packages\Topshelf.3.1.4\lib\net40-full\Topshelf.dll diff --git a/TimberWinR.ServiceHost/default.json b/TimberWinR.ServiceHost/default.json index 34665b7..12dfc62 100644 --- a/TimberWinR.ServiceHost/default.json +++ b/TimberWinR.ServiceHost/default.json @@ -18,7 +18,7 @@ "Filters": [ { "grok": { - "condition": "[EventTypeName] == \"Information Event\"", + "condition": "\"[EventTypeName]\" == \"Information Event\"", "match": [ "Text", "" diff --git a/TimberWinR.TestGenerator/CommandLineOptions.cs b/TimberWinR.TestGenerator/CommandLineOptions.cs new file mode 100644 index 0000000..81fc217 --- /dev/null +++ b/TimberWinR.TestGenerator/CommandLineOptions.cs @@ -0,0 +1,82 @@ +using System.ComponentModel; +using CommandLine; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using CommandLine.Text; + +namespace TimberWinR.TestGenerator +{ + class CommandLineOptions + { + // [Option('r', "read", Required = true, HelpText = "Input file to be processed.")] + // public string InputFile { get; set; } + [Option("timberWinRConfig", DefaultValue = "default.json", HelpText = "Config file/directory to use")] + public string TimberWinRConfigFile { get; set; } + + [Option("testDir", DefaultValue = ".", HelpText = "Test directory to use (created if necessary)")] + public string TestDir { get; set; } + + [Option("testFile", DefaultValue = "", HelpText = "Config file/directory to use")] + public string TestFile { get; set; } + + [Option("resultsFile", HelpText = "Expected results Results json file")] + public string ExpectedResultsFile { get; set; } + + [Option('n', "numMessages", DefaultValue = 1000, HelpText = "The number of messages to send to the output(s)")] + public int NumMessages { get; set; } + + [Option('l', "logLevel", DefaultValue = "debug", HelpText = "Logging Level Debug|Error|Fatal|Info|Off|Trace|Warn")] + public string LogLevel { get; set; } + + [Option('v', "verbose", DefaultValue = true, HelpText = "Prints all messages to standard output.")] + public bool Verbose { get; set; } + + [Option("jsonLogDir", DefaultValue = ".", HelpText = "Json LogGenerator Log directory")] + public string JsonLogDir { get; set; } + + [OptionArray('j', "json", DefaultValue = new string[] {})] + public string[] JsonLogFiles { get; set; } + + [OptionArray("jroll", DefaultValue = new string[] { })] + public string[] JsonRollingLogFiles { get; set; } + + [Option("jsonRate", DefaultValue = 30, HelpText = "Json Rate in Milliseconds between generation of log lines")] + public int JsonRate { get; set; } + + [Option('u', "udp", DefaultValue = 0, HelpText = "Enable UDP generator on this Port")] + public int Udp { get; set; } + + [Option("udp-host", DefaultValue = "localhost", HelpText = "Host to send Udp data to")] + public string UdpHost { get; set; } + + [Option("udp-rate", DefaultValue = 10, HelpText = "Udp Rate in Milliseconds between generation of log lines")] + public int UdpRate { get; set; } + + [Option('t', "tcp", DefaultValue = 0, HelpText = "Enable Tcp generator on this Port")] + public int Tcp { get; set; } + + [Option("tcp-host", DefaultValue = "localhost", HelpText = "Host to send Tcp data to")] + public string TcpHost { get; set; } + + [Option("tcp-rate", DefaultValue = 10, HelpText = "Tcp Rate in Milliseconds between generation of log lines")] + public int TcpRate { get; set; } + + [Option('r', "redis", DefaultValue = 0, HelpText = "Enable Redis generator on this Port")] + public int Redis { get; set; } + + [Option("redis-host", DefaultValue = "", HelpText = "Host to send Redis data to")] + public string RedisHost { get; set; } + + [ParserState] + public IParserState LastParserState { get; set; } + + [HelpOption] + public string GetUsage() + { + return HelpText.AutoBuild(this, + (HelpText current) => HelpText.DefaultParsingErrorsHandler(this, current)); + } + } +} diff --git a/TimberWinR.TestGenerator/Dynamic.cs b/TimberWinR.TestGenerator/Dynamic.cs new file mode 100644 index 0000000..3bde75c --- /dev/null +++ b/TimberWinR.TestGenerator/Dynamic.cs @@ -0,0 +1,2407 @@ +//Copyright (C) Microsoft Corporation. All rights reserved. + +using System; +using System.Collections.Generic; +using System.Text; +using System.Linq; +using System.Linq.Expressions; +using System.Reflection; +using System.Reflection.Emit; +using System.Threading; +using System.Runtime.CompilerServices; +using System.Collections; +using Newtonsoft.Json.Linq; + +namespace System.Linq.Dynamic +{ + public static class DynamicQueryable + { + public static IQueryable Where(this IQueryable source, string predicate, params object[] values) + { + return (IQueryable)Where((IQueryable)source, predicate, values); + } + + public static IQueryable Where(this IQueryable source, string predicate, params object[] values) + { + if (source == null) throw new ArgumentNullException("source"); + if (predicate == null) throw new ArgumentNullException("predicate"); + LambdaExpression lambda = DynamicExpression.ParseLambda(source.ElementType, typeof(bool), predicate, values); + return source.Provider.CreateQuery( + Expression.Call( + typeof(Queryable), "Where", + new Type[] { source.ElementType }, + source.Expression, Expression.Quote(lambda))); + } + + public static IQueryable Select(this IQueryable source, string selector, params object[] values) + { + if (source == null) throw new ArgumentNullException("source"); + if (selector == null) throw new ArgumentNullException("selector"); + LambdaExpression lambda = DynamicExpression.ParseLambda(source.ElementType, null, selector, values); + return source.Provider.CreateQuery( + Expression.Call( + typeof(Queryable), "Select", + new Type[] { source.ElementType, lambda.Body.Type }, + source.Expression, Expression.Quote(lambda))); + } + + public static IQueryable OrderBy(this IQueryable source, string ordering, params object[] values) + { + return (IQueryable)OrderBy((IQueryable)source, ordering, values); + } + + public static IQueryable OrderBy(this IQueryable source, string ordering, params object[] values) + { + if (source == null) throw new ArgumentNullException("source"); + if (ordering == null) throw new ArgumentNullException("ordering"); + ParameterExpression[] parameters = new ParameterExpression[] { + Expression.Parameter(source.ElementType, "") }; + ExpressionParser parser = new ExpressionParser(parameters, ordering, values); + IEnumerable orderings = parser.ParseOrdering(); + Expression queryExpr = source.Expression; + string methodAsc = "OrderBy"; + string methodDesc = "OrderByDescending"; + foreach (DynamicOrdering o in orderings) + { + queryExpr = Expression.Call( + typeof(Queryable), o.Ascending ? methodAsc : methodDesc, + new Type[] { source.ElementType, o.Selector.Type }, + queryExpr, Expression.Quote(Expression.Lambda(o.Selector, parameters))); + methodAsc = "ThenBy"; + methodDesc = "ThenByDescending"; + } + return source.Provider.CreateQuery(queryExpr); + } + + public static IQueryable Take(this IQueryable source, int count) + { + if (source == null) throw new ArgumentNullException("source"); + return source.Provider.CreateQuery( + Expression.Call( + typeof(Queryable), "Take", + new Type[] { source.ElementType }, + source.Expression, Expression.Constant(count))); + } + + public static IQueryable Union(this IQueryable source, IQueryable other) + { + if (source == null) throw new ArgumentNullException("source"); + return source.Provider.CreateQuery( + Expression.Call( + typeof(Queryable), "Union", + new Type[] { source.ElementType }, + source.Expression, other.Expression)); + } + + public static IQueryable Skip(this IQueryable source, int count) + { + if (source == null) throw new ArgumentNullException("source"); + return source.Provider.CreateQuery( + Expression.Call( + typeof(Queryable), "Skip", + new Type[] { source.ElementType }, + source.Expression, Expression.Constant(count))); + } + + public static IQueryable GroupBy(this IQueryable source, string keySelector, string elementSelector, params object[] values) + { + if (source == null) throw new ArgumentNullException("source"); + if (keySelector == null) throw new ArgumentNullException("keySelector"); + if (elementSelector == null) throw new ArgumentNullException("elementSelector"); + LambdaExpression keyLambda = DynamicExpression.ParseLambda(source.ElementType, null, keySelector, values); + LambdaExpression elementLambda = DynamicExpression.ParseLambda(source.ElementType, null, elementSelector, values); + return source.Provider.CreateQuery( + Expression.Call( + typeof(Queryable), "GroupBy", + new Type[] { source.ElementType, keyLambda.Body.Type, elementLambda.Body.Type }, + source.Expression, Expression.Quote(keyLambda), Expression.Quote(elementLambda))); + } + + public static bool Any(this IQueryable source) + { + if (source == null) throw new ArgumentNullException("source"); + return (bool)source.Provider.Execute( + Expression.Call( + typeof(Queryable), "Any", + new Type[] { source.ElementType }, source.Expression)); + } + + public static int Count(this IQueryable source) + { + if (source == null) throw new ArgumentNullException("source"); + return (int)source.Provider.Execute( + Expression.Call( + typeof(Queryable), "Count", + new Type[] { source.ElementType }, source.Expression)); + } + } + + public abstract class DynamicClass + { + public override string ToString() + { + PropertyInfo[] props = this.GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public); + StringBuilder sb = new StringBuilder(); + sb.Append("{"); + for (int i = 0; i < props.Length; i++) + { + if (i > 0) sb.Append(", "); + sb.Append(props[i].Name); + sb.Append("="); + sb.Append(props[i].GetValue(this, null)); + } + sb.Append("}"); + return sb.ToString(); + } + } + + public class DynamicProperty + { + string name; + Type type; + + public DynamicProperty(string name, Type type) + { + if (name == null) throw new ArgumentNullException("name"); + if (type == null) throw new ArgumentNullException("type"); + this.name = name; + this.type = type; + } + + public string Name + { + get { return name; } + } + + public Type Type + { + get { return type; } + } + } + + public static class DynamicExpression + { + public static Expression Parse(Type resultType, string expression, params object[] values) + { + ExpressionParser parser = new ExpressionParser(null, expression, values); + return parser.Parse(resultType); + } + + public static LambdaExpression ParseLambda(Type itType, Type resultType, string expression, params object[] values) + { + return ParseLambda(new ParameterExpression[] { Expression.Parameter(itType, "") }, resultType, expression, values); + } + + public static LambdaExpression ParseLambda(ParameterExpression[] parameters, Type resultType, string expression, params object[] values) + { + ExpressionParser parser = new ExpressionParser(parameters, expression, values); + return Expression.Lambda(parser.Parse(resultType), parameters); + } + + public static Expression> ParseLambda(string expression, params object[] values) + { + return (Expression>)ParseLambda(typeof(T), typeof(S), expression, values); + } + + public static Type CreateClass(params DynamicProperty[] properties) + { + return ClassFactory.Instance.GetDynamicClass(properties); + } + + public static Type CreateClass(IEnumerable properties) + { + return ClassFactory.Instance.GetDynamicClass(properties); + } + } + + internal class DynamicOrdering + { + public Expression Selector; + public bool Ascending; + } + + internal class Signature : IEquatable + { + public DynamicProperty[] properties; + public int hashCode; + + public Signature(IEnumerable properties) + { + this.properties = properties.ToArray(); + hashCode = 0; + foreach (DynamicProperty p in properties) + { + hashCode ^= p.Name.GetHashCode() ^ p.Type.GetHashCode(); + } + } + + public override int GetHashCode() + { + return hashCode; + } + + public override bool Equals(object obj) + { + return obj is Signature ? Equals((Signature)obj) : false; + } + + public bool Equals(Signature other) + { + if (properties.Length != other.properties.Length) return false; + for (int i = 0; i < properties.Length; i++) + { + if (properties[i].Name != other.properties[i].Name || + properties[i].Type != other.properties[i].Type) return false; + } + return true; + } + } + + internal class ClassFactory + { + public static readonly ClassFactory Instance = new ClassFactory(); + + static ClassFactory() { } // Trigger lazy initialization of static fields + + ModuleBuilder module; + Dictionary classes; + int classCount; + ReaderWriterLock rwLock; + + private ClassFactory() + { + AssemblyName name = new AssemblyName("DynamicClasses"); + AssemblyBuilder assembly = AppDomain.CurrentDomain.DefineDynamicAssembly(name, AssemblyBuilderAccess.Run); +#if ENABLE_LINQ_PARTIAL_TRUST + new ReflectionPermission(PermissionState.Unrestricted).Assert(); +#endif + try + { + module = assembly.DefineDynamicModule("Module"); + } + finally + { +#if ENABLE_LINQ_PARTIAL_TRUST + PermissionSet.RevertAssert(); +#endif + } + classes = new Dictionary(); + rwLock = new ReaderWriterLock(); + } + + public Type GetDynamicClass(IEnumerable properties) + { + rwLock.AcquireReaderLock(Timeout.Infinite); + try + { + Signature signature = new Signature(properties); + Type type; + if (!classes.TryGetValue(signature, out type)) + { + type = CreateDynamicClass(signature.properties); + classes.Add(signature, type); + } + return type; + } + finally + { + rwLock.ReleaseReaderLock(); + } + } + + Type CreateDynamicClass(DynamicProperty[] properties) + { + LockCookie cookie = rwLock.UpgradeToWriterLock(Timeout.Infinite); + try + { + string typeName = "DynamicClass" + (classCount + 1); +#if ENABLE_LINQ_PARTIAL_TRUST + new ReflectionPermission(PermissionState.Unrestricted).Assert(); +#endif + try + { + TypeBuilder tb = this.module.DefineType(typeName, TypeAttributes.Class | + TypeAttributes.Public, typeof(DynamicClass)); + FieldInfo[] fields = GenerateProperties(tb, properties); + GenerateEquals(tb, fields); + GenerateGetHashCode(tb, fields); + Type result = tb.CreateType(); + classCount++; + return result; + } + finally + { +#if ENABLE_LINQ_PARTIAL_TRUST + PermissionSet.RevertAssert(); +#endif + } + } + finally + { + rwLock.DowngradeFromWriterLock(ref cookie); + } + } + + FieldInfo[] GenerateProperties(TypeBuilder tb, DynamicProperty[] properties) + { + FieldInfo[] fields = new FieldBuilder[properties.Length]; + for (int i = 0; i < properties.Length; i++) + { + DynamicProperty dp = properties[i]; + FieldBuilder fb = tb.DefineField("_" + dp.Name, dp.Type, FieldAttributes.Private); + PropertyBuilder pb = tb.DefineProperty(dp.Name, PropertyAttributes.HasDefault, dp.Type, null); + MethodBuilder mbGet = tb.DefineMethod("get_" + dp.Name, + MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig, + dp.Type, Type.EmptyTypes); + ILGenerator genGet = mbGet.GetILGenerator(); + genGet.Emit(OpCodes.Ldarg_0); + genGet.Emit(OpCodes.Ldfld, fb); + genGet.Emit(OpCodes.Ret); + MethodBuilder mbSet = tb.DefineMethod("set_" + dp.Name, + MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig, + null, new Type[] { dp.Type }); + ILGenerator genSet = mbSet.GetILGenerator(); + genSet.Emit(OpCodes.Ldarg_0); + genSet.Emit(OpCodes.Ldarg_1); + genSet.Emit(OpCodes.Stfld, fb); + genSet.Emit(OpCodes.Ret); + pb.SetGetMethod(mbGet); + pb.SetSetMethod(mbSet); + fields[i] = fb; + } + return fields; + } + + void GenerateEquals(TypeBuilder tb, FieldInfo[] fields) + { + MethodBuilder mb = tb.DefineMethod("Equals", + MethodAttributes.Public | MethodAttributes.ReuseSlot | + MethodAttributes.Virtual | MethodAttributes.HideBySig, + typeof(bool), new Type[] { typeof(object) }); + ILGenerator gen = mb.GetILGenerator(); + LocalBuilder other = gen.DeclareLocal(tb); + Label next = gen.DefineLabel(); + gen.Emit(OpCodes.Ldarg_1); + gen.Emit(OpCodes.Isinst, tb); + gen.Emit(OpCodes.Stloc, other); + gen.Emit(OpCodes.Ldloc, other); + gen.Emit(OpCodes.Brtrue_S, next); + gen.Emit(OpCodes.Ldc_I4_0); + gen.Emit(OpCodes.Ret); + gen.MarkLabel(next); + foreach (FieldInfo field in fields) + { + Type ft = field.FieldType; + Type ct = typeof(EqualityComparer<>).MakeGenericType(ft); + next = gen.DefineLabel(); + gen.EmitCall(OpCodes.Call, ct.GetMethod("get_Default"), null); + gen.Emit(OpCodes.Ldarg_0); + gen.Emit(OpCodes.Ldfld, field); + gen.Emit(OpCodes.Ldloc, other); + gen.Emit(OpCodes.Ldfld, field); + gen.EmitCall(OpCodes.Callvirt, ct.GetMethod("Equals", new Type[] { ft, ft }), null); + gen.Emit(OpCodes.Brtrue_S, next); + gen.Emit(OpCodes.Ldc_I4_0); + gen.Emit(OpCodes.Ret); + gen.MarkLabel(next); + } + gen.Emit(OpCodes.Ldc_I4_1); + gen.Emit(OpCodes.Ret); + } + + void GenerateGetHashCode(TypeBuilder tb, FieldInfo[] fields) + { + MethodBuilder mb = tb.DefineMethod("GetHashCode", + MethodAttributes.Public | MethodAttributes.ReuseSlot | + MethodAttributes.Virtual | MethodAttributes.HideBySig, + typeof(int), Type.EmptyTypes); + ILGenerator gen = mb.GetILGenerator(); + gen.Emit(OpCodes.Ldc_I4_0); + foreach (FieldInfo field in fields) + { + Type ft = field.FieldType; + Type ct = typeof(EqualityComparer<>).MakeGenericType(ft); + gen.EmitCall(OpCodes.Call, ct.GetMethod("get_Default"), null); + gen.Emit(OpCodes.Ldarg_0); + gen.Emit(OpCodes.Ldfld, field); + gen.EmitCall(OpCodes.Callvirt, ct.GetMethod("GetHashCode", new Type[] { ft }), null); + gen.Emit(OpCodes.Xor); + } + gen.Emit(OpCodes.Ret); + } + } + + public sealed class ParseException : Exception + { + int position; + + public ParseException(string message, int position) + : base(message) + { + this.position = position; + } + + public int Position + { + get { return position; } + } + + public override string ToString() + { + return string.Format(Res.ParseExceptionFormat, Message, position); + } + } + + internal class ExpressionParser + { + struct Token + { + public TokenId id; + public string text; + public int pos; + } + + enum TokenId + { + Unknown, + End, + Identifier, + StringLiteral, + IntegerLiteral, + RealLiteral, + Exclamation, + Percent, + Amphersand, + OpenParen, + CloseParen, + Asterisk, + Plus, + Comma, + Minus, + Dot, + Slash, + Colon, + LessThan, + Equal, + GreaterThan, + Question, + OpenBracket, + CloseBracket, + Bar, + ExclamationEqual, + DoubleAmphersand, + LessThanEqual, + LessGreater, + DoubleEqual, + GreaterThanEqual, + DoubleBar, + Lambda + } + + interface ILogicalSignatures + { + void F(bool x, bool y); + void F(bool? x, bool? y); + } + + interface IArithmeticSignatures + { + void F(int x, int y); + void F(uint x, uint y); + void F(long x, long y); + void F(ulong x, ulong y); + void F(float x, float y); + void F(double x, double y); + void F(decimal x, decimal y); + void F(int? x, int? y); + void F(uint? x, uint? y); + void F(long? x, long? y); + void F(ulong? x, ulong? y); + void F(float? x, float? y); + void F(double? x, double? y); + void F(decimal? x, decimal? y); + } + + interface IRelationalSignatures : IArithmeticSignatures + { + void F(string x, string y); + void F(char x, char y); + void F(DateTime x, DateTime y); + void F(TimeSpan x, TimeSpan y); + void F(char? x, char? y); + void F(DateTime? x, DateTime? y); + void F(TimeSpan? x, TimeSpan? y); + } + + interface IEqualitySignatures : IRelationalSignatures + { + void F(bool x, bool y); + void F(bool? x, bool? y); + } + + interface IAddSignatures : IArithmeticSignatures + { + void F(DateTime x, TimeSpan y); + void F(TimeSpan x, TimeSpan y); + void F(DateTime? x, TimeSpan? y); + void F(TimeSpan? x, TimeSpan? y); + } + + interface ISubtractSignatures : IAddSignatures + { + void F(DateTime x, DateTime y); + void F(DateTime? x, DateTime? y); + } + + interface INegationSignatures + { + void F(int x); + void F(long x); + void F(float x); + void F(double x); + void F(decimal x); + void F(int? x); + void F(long? x); + void F(float? x); + void F(double? x); + void F(decimal? x); + } + + interface INotSignatures + { + void F(bool x); + void F(bool? x); + } + + interface IEnumerableSignatures + { + void Where(bool predicate); + void Any(); + void Any(bool predicate); + void All(bool predicate); + void Count(); + void Count(bool predicate); + void Min(object selector); + void Max(object selector); + void Sum(int selector); + void Sum(int? selector); + void Sum(long selector); + void Sum(long? selector); + void Sum(float selector); + void Sum(float? selector); + void Sum(double selector); + void Sum(double? selector); + void Sum(decimal selector); + void Sum(decimal? selector); + void Average(int selector); + void Average(int? selector); + void Average(long selector); + void Average(long? selector); + void Average(float selector); + void Average(float? selector); + void Average(double selector); + void Average(double? selector); + void Average(decimal selector); + void Average(decimal? selector); + void Take(int count); + void Union(IQueryable right); + void Select(LambdaExpression exp); + void OrderBy(LambdaExpression exp); + void OrderByDescending(LambdaExpression exp); + } + + static readonly Type[] predefinedTypes = { + typeof(Object), + typeof(Boolean), + typeof(Char), + typeof(String), + typeof(SByte), + typeof(Byte), + typeof(Int16), + typeof(UInt16), + typeof(Int32), + typeof(UInt32), + typeof(Int64), + typeof(UInt64), + typeof(Single), + typeof(Double), + typeof(Decimal), + typeof(DateTime), + typeof(TimeSpan), + typeof(Guid), + typeof(Math), + typeof(Convert), + typeof(JToken), + typeof(JObject), + }; + + static readonly Expression trueLiteral = Expression.Constant(true); + static readonly Expression falseLiteral = Expression.Constant(false); + static readonly Expression nullLiteral = Expression.Constant(null); + + static readonly string keywordIt = "it"; + static readonly string keywordIif = "iif"; + static readonly string keywordNew = "new"; + + static Dictionary keywords; + + Dictionary symbols; + IDictionary externals; + IDictionary internals = new Dictionary(); + Dictionary literals; + ParameterExpression it; + string text; + int textPos; + int textLen; + char ch; + Token token; + + public ExpressionParser(ParameterExpression[] parameters, string expression, object[] values) + { + if (expression == null) throw new ArgumentNullException("expression"); + if (keywords == null) keywords = CreateKeywords(); + symbols = new Dictionary(StringComparer.OrdinalIgnoreCase); + literals = new Dictionary(); + if (parameters != null) ProcessParameters(parameters); + if (values != null) ProcessValues(values); + text = expression; + textLen = text.Length; + SetTextPos(0); + NextToken(); + } + + void ProcessParameters(ParameterExpression[] parameters) + { + foreach (ParameterExpression pe in parameters) + if (!String.IsNullOrEmpty(pe.Name)) + AddSymbol(pe.Name, pe); + if (parameters.Length == 1 && String.IsNullOrEmpty(parameters[0].Name)) + it = parameters[0]; + } + + void ProcessValues(object[] values) + { + for (int i = 0; i < values.Length; i++) + { + object value = values[i]; + if (i == values.Length - 1 && value is IDictionary) + { + externals = (IDictionary)value; + } + else + { + AddSymbol("@" + i.ToString(System.Globalization.CultureInfo.InvariantCulture), value); + } + } + } + + void AddSymbol(string name, object value) + { + if (symbols.ContainsKey(name)) + throw ParseError(Res.DuplicateIdentifier, name); + symbols.Add(name, value); + } + + public Expression Parse(Type resultType) + { + int exprPos = token.pos; + Expression expr = ParseExpression(); + if (resultType != null) + if ((expr = PromoteExpression(expr, resultType, true)) == null) + throw ParseError(exprPos, Res.ExpressionTypeMismatch, GetTypeName(resultType)); + ValidateToken(TokenId.End, Res.SyntaxError); + return expr; + } + +#pragma warning disable 0219 + public IEnumerable ParseOrdering() + { + List orderings = new List(); + while (true) + { + Expression expr = ParseExpression(); + bool ascending = true; + if (TokenIdentifierIs("asc") || TokenIdentifierIs("ascending")) + { + NextToken(); + } + else if (TokenIdentifierIs("desc") || TokenIdentifierIs("descending")) + { + NextToken(); + ascending = false; + } + orderings.Add(new DynamicOrdering { Selector = expr, Ascending = ascending }); + if (token.id != TokenId.Comma) break; + NextToken(); + } + ValidateToken(TokenId.End, Res.SyntaxError); + return orderings; + } +#pragma warning restore 0219 + + // ?: operator + Expression ParseExpression() + { + int errorPos = token.pos; + Expression expr = ParseLambda(); + if (token.id == TokenId.Question) + { + NextToken(); + Expression expr1 = ParseExpression(); + ValidateToken(TokenId.Colon, Res.ColonExpected); + NextToken(); + Expression expr2 = ParseExpression(); + expr = GenerateConditional(expr, expr1, expr2, errorPos); + } + return expr; + } + + /// + /// => operator + /// Added Support for projection operator + /// + /// + Expression ParseLambda() + { + int errorPos = token.pos; + Expression expr = ParseLogicalOr(); + if (token.id == TokenId.Lambda) + { + if (token.id == TokenId.Lambda && it.Type == expr.Type) + { + NextToken(); + if (token.id == TokenId.Identifier || token.id == TokenId.OpenParen) + { + var right = ParseExpression(); + return Expression.Lambda(right, new[] { (ParameterExpression)expr }); + } + ValidateToken(TokenId.OpenParen, Res.OpenParenExpected); + } + } + return expr; + } + + // ||, or operator + Expression ParseLogicalOr() + { + Expression left = ParseLogicalAnd(); + while (token.id == TokenId.DoubleBar || TokenIdentifierIs("or")) + { + Token op = token; + NextToken(); + Expression right = ParseLogicalAnd(); + CheckAndPromoteOperands(typeof(ILogicalSignatures), op.text, ref left, ref right, op.pos); + left = Expression.OrElse(left, right); + } + return left; + } + + // &&, and operator + Expression ParseLogicalAnd() + { + Expression left = ParseComparison(); + while (token.id == TokenId.DoubleAmphersand || TokenIdentifierIs("and")) + { + Token op = token; + NextToken(); + Expression right = ParseComparison(); + CheckAndPromoteOperands(typeof(ILogicalSignatures), op.text, ref left, ref right, op.pos); + left = Expression.AndAlso(left, right); + } + return left; + } + + // =, ==, !=, <>, >, >=, <, <= operators + Expression ParseComparison() + { + Expression left = ParseAdditive(); + while (token.id == TokenId.Equal || token.id == TokenId.DoubleEqual || + token.id == TokenId.ExclamationEqual || token.id == TokenId.LessGreater || + token.id == TokenId.GreaterThan || token.id == TokenId.GreaterThanEqual || + token.id == TokenId.LessThan || token.id == TokenId.LessThanEqual) + { + Token op = token; + NextToken(); + Expression right = ParseAdditive(); + bool isEquality = op.id == TokenId.Equal || op.id == TokenId.DoubleEqual || + op.id == TokenId.ExclamationEqual || op.id == TokenId.LessGreater; + if (isEquality && !left.Type.IsValueType && !right.Type.IsValueType) + { + if (left.Type != right.Type) + { + if (left.Type.IsAssignableFrom(right.Type)) + { + right = Expression.Convert(right, left.Type); + } + else if (right.Type.IsAssignableFrom(left.Type)) + { + left = Expression.Convert(left, right.Type); + } + else + { + throw IncompatibleOperandsError(op.text, left, right, op.pos); + } + } + } + else if (IsEnumType(left.Type) || IsEnumType(right.Type)) + { + if (left.Type != right.Type) + { + Expression e; + if ((e = PromoteExpression(right, left.Type, true)) != null) + { + right = e; + } + else if ((e = PromoteExpression(left, right.Type, true)) != null) + { + left = e; + } + else + { + throw IncompatibleOperandsError(op.text, left, right, op.pos); + } + } + } + else + { + CheckAndPromoteOperands(isEquality ? typeof(IEqualitySignatures) : typeof(IRelationalSignatures), + op.text, ref left, ref right, op.pos); + } + switch (op.id) + { + case TokenId.Equal: + case TokenId.DoubleEqual: + left = GenerateEqual(left, right); + break; + case TokenId.ExclamationEqual: + case TokenId.LessGreater: + left = GenerateNotEqual(left, right); + break; + case TokenId.GreaterThan: + left = GenerateGreaterThan(left, right); + break; + case TokenId.GreaterThanEqual: + left = GenerateGreaterThanEqual(left, right); + break; + case TokenId.LessThan: + left = GenerateLessThan(left, right); + break; + case TokenId.LessThanEqual: + left = GenerateLessThanEqual(left, right); + break; + } + } + return left; + } + + // +, -, & operators + Expression ParseAdditive() + { + Expression left = ParseMultiplicative(); + while (token.id == TokenId.Plus || token.id == TokenId.Minus || + token.id == TokenId.Amphersand) + { + Token op = token; + NextToken(); + Expression right = ParseMultiplicative(); + switch (op.id) + { + case TokenId.Plus: + if (left.Type == typeof(string) || right.Type == typeof(string)) + goto case TokenId.Amphersand; + CheckAndPromoteOperands(typeof(IAddSignatures), op.text, ref left, ref right, op.pos); + left = GenerateAdd(left, right); + break; + case TokenId.Minus: + CheckAndPromoteOperands(typeof(ISubtractSignatures), op.text, ref left, ref right, op.pos); + left = GenerateSubtract(left, right); + break; + case TokenId.Amphersand: + left = GenerateStringConcat(left, right); + break; + } + } + return left; + } + + // *, /, %, mod operators + Expression ParseMultiplicative() + { + Expression left = ParseUnary(); + while (token.id == TokenId.Asterisk || token.id == TokenId.Slash || + token.id == TokenId.Percent || TokenIdentifierIs("mod")) + { + Token op = token; + NextToken(); + Expression right = ParseUnary(); + CheckAndPromoteOperands(typeof(IArithmeticSignatures), op.text, ref left, ref right, op.pos); + switch (op.id) + { + case TokenId.Asterisk: + left = Expression.Multiply(left, right); + break; + case TokenId.Slash: + left = Expression.Divide(left, right); + break; + case TokenId.Percent: + case TokenId.Identifier: + left = Expression.Modulo(left, right); + break; + } + } + return left; + } + + // -, !, not unary operators + Expression ParseUnary() + { + if (token.id == TokenId.Minus || token.id == TokenId.Exclamation || + TokenIdentifierIs("not")) + { + Token op = token; + NextToken(); + if (op.id == TokenId.Minus && (token.id == TokenId.IntegerLiteral || + token.id == TokenId.RealLiteral)) + { + token.text = "-" + token.text; + token.pos = op.pos; + return ParsePrimary(); + } + Expression expr = ParseUnary(); + if (op.id == TokenId.Minus) + { + CheckAndPromoteOperand(typeof(INegationSignatures), op.text, ref expr, op.pos); + expr = Expression.Negate(expr); + } + else + { + CheckAndPromoteOperand(typeof(INotSignatures), op.text, ref expr, op.pos); + expr = Expression.Not(expr); + } + return expr; + } + return ParsePrimary(); + } + + Expression ParsePrimary() + { + Expression expr = ParsePrimaryStart(); + while (true) + { + if (token.id == TokenId.Dot) + { + NextToken(); + expr = ParseMemberAccess(null, expr); + } + else if (token.id == TokenId.OpenBracket) + { + expr = ParseElementAccess(expr); + } + else + { + break; + } + } + return expr; + } + + Expression ParsePrimaryStart() + { + switch (token.id) + { + case TokenId.Identifier: + return ParseIdentifier(); + case TokenId.StringLiteral: + return ParseStringLiteral(); + case TokenId.IntegerLiteral: + return ParseIntegerLiteral(); + case TokenId.RealLiteral: + return ParseRealLiteral(); + case TokenId.OpenParen: + return ParseParenExpression(); + default: + throw ParseError(Res.ExpressionExpected); + } + } + + Expression ParseStringLiteral() + { + ValidateToken(TokenId.StringLiteral); + char quote = token.text[0]; + string s = token.text.Substring(1, token.text.Length - 2); + int start = 0; + while (true) + { + int i = s.IndexOf(quote, start); + if (i < 0) break; + s = s.Remove(i, 1); + start = i + 1; + } + if (quote == '\'') + { + if (s.Length != 1) + throw ParseError(Res.InvalidCharacterLiteral); + NextToken(); + return CreateLiteral(s[0], s); + } + NextToken(); + return CreateLiteral(s, s); + } + + Expression ParseIntegerLiteral() + { + ValidateToken(TokenId.IntegerLiteral); + string text = token.text; + if (text[0] != '-') + { + ulong value; + if (!UInt64.TryParse(text, out value)) + throw ParseError(Res.InvalidIntegerLiteral, text); + NextToken(); + if (value <= (ulong)Int32.MaxValue) return CreateLiteral((int)value, text); + if (value <= (ulong)UInt32.MaxValue) return CreateLiteral((uint)value, text); + if (value <= (ulong)Int64.MaxValue) return CreateLiteral((long)value, text); + return CreateLiteral(value, text); + } + else + { + long value; + if (!Int64.TryParse(text, out value)) + throw ParseError(Res.InvalidIntegerLiteral, text); + NextToken(); + if (value >= Int32.MinValue && value <= Int32.MaxValue) + return CreateLiteral((int)value, text); + return CreateLiteral(value, text); + } + } + + Expression ParseRealLiteral() + { + ValidateToken(TokenId.RealLiteral); + string text = token.text; + object value = null; + char last = text[text.Length - 1]; + if (last == 'F' || last == 'f') + { + float f; + if (Single.TryParse(text.Substring(0, text.Length - 1), out f)) value = f; + } + else + { + double d; + if (Double.TryParse(text, out d)) value = d; + } + if (value == null) throw ParseError(Res.InvalidRealLiteral, text); + NextToken(); + return CreateLiteral(value, text); + } + + Expression CreateLiteral(object value, string text) + { + ConstantExpression expr = Expression.Constant(value); + literals.Add(expr, text); + return expr; + } + + Expression ParseParenExpression() + { + ValidateToken(TokenId.OpenParen, Res.OpenParenExpected); + NextToken(); + Expression e = ParseExpression(); + ValidateToken(TokenId.CloseParen, Res.CloseParenOrOperatorExpected); + NextToken(); + return e; + } + + Expression ParseIdentifier() + { + ValidateToken(TokenId.Identifier); + object value; + if (keywords.TryGetValue(token.text, out value)) + { + if (value is Type) return ParseTypeAccess((Type)value); + if (value == (object)keywordIt) return ParseIt(); + if (value == (object)keywordIif) return ParseIif(); + if (value == (object)keywordNew) return ParseNew(); + NextToken(); + return (Expression)value; + } + //if (symbols.TryGetValue(token.text, out value) || + // externals != null && externals.TryGetValue(token.text, out value)) { + if (symbols.TryGetValue(token.text, out value) || + externals != null && externals.TryGetValue(token.text, out value) || internals.TryGetValue(token.text, out value)) + { + Expression expr = value as Expression; + if (expr == null) + { + expr = Expression.Constant(value); + } + else + { + LambdaExpression lambda = expr as LambdaExpression; + if (lambda != null) return ParseLambdaInvocation(lambda); + } + NextToken(); + return expr; + } + if (it != null) return ParseMemberAccess(null, it); + throw ParseError(Res.UnknownIdentifier, token.text); + } + + Expression ParseIt() + { + if (it == null) + throw ParseError(Res.NoItInScope); + NextToken(); + return it; + } + + Expression ParseIif() + { + int errorPos = token.pos; + NextToken(); + Expression[] args = ParseArgumentList(); + if (args.Length != 3) + throw ParseError(errorPos, Res.IifRequiresThreeArgs); + return GenerateConditional(args[0], args[1], args[2], errorPos); + } + + Expression GenerateConditional(Expression test, Expression expr1, Expression expr2, int errorPos) + { + if (test.Type != typeof(bool)) + throw ParseError(errorPos, Res.FirstExprMustBeBool); + if (expr1.Type != expr2.Type) + { + Expression expr1as2 = expr2 != nullLiteral ? PromoteExpression(expr1, expr2.Type, true) : null; + Expression expr2as1 = expr1 != nullLiteral ? PromoteExpression(expr2, expr1.Type, true) : null; + if (expr1as2 != null && expr2as1 == null) + { + expr1 = expr1as2; + } + else if (expr2as1 != null && expr1as2 == null) + { + expr2 = expr2as1; + } + else + { + string type1 = expr1 != nullLiteral ? expr1.Type.Name : "null"; + string type2 = expr2 != nullLiteral ? expr2.Type.Name : "null"; + if (expr1as2 != null && expr2as1 != null) + throw ParseError(errorPos, Res.BothTypesConvertToOther, type1, type2); + throw ParseError(errorPos, Res.NeitherTypeConvertsToOther, type1, type2); + } + } + return Expression.Condition(test, expr1, expr2); + } + + Expression ParseNew() + { + NextToken(); + ValidateToken(TokenId.OpenParen, Res.OpenParenExpected); + NextToken(); + List properties = new List(); + List expressions = new List(); + while (true) + { + int exprPos = token.pos; + Expression expr = ParseExpression(); + string propName; + if (TokenIdentifierIs("as")) + { + NextToken(); + propName = GetIdentifier(); + NextToken(); + } + else + { + MemberExpression me = expr as MemberExpression; + if (me == null) throw ParseError(exprPos, Res.MissingAsClause); + propName = me.Member.Name; + } + expressions.Add(expr); + properties.Add(new DynamicProperty(propName, expr.Type)); + if (token.id != TokenId.Comma) break; + NextToken(); + } + ValidateToken(TokenId.CloseParen, Res.CloseParenOrCommaExpected); + NextToken(); + Type type = DynamicExpression.CreateClass(properties); + MemberBinding[] bindings = new MemberBinding[properties.Count]; + for (int i = 0; i < bindings.Length; i++) + bindings[i] = Expression.Bind(type.GetProperty(properties[i].Name), expressions[i]); + return Expression.MemberInit(Expression.New(type), bindings); + } + + Expression ParseLambdaInvocation(LambdaExpression lambda) + { + int errorPos = token.pos; + NextToken(); + Expression[] args = ParseArgumentList(); + MethodBase method; + if (FindMethod(lambda.Type, "Invoke", false, args, out method) != 1) + throw ParseError(errorPos, Res.ArgsIncompatibleWithLambda); + return Expression.Invoke(lambda, args); + } + + Expression ParseTypeAccess(Type type) + { + int errorPos = token.pos; + NextToken(); + if (token.id == TokenId.Question) + { + if (!type.IsValueType || IsNullableType(type)) + throw ParseError(errorPos, Res.TypeHasNoNullableForm, GetTypeName(type)); + type = typeof(Nullable<>).MakeGenericType(type); + NextToken(); + } + if (token.id == TokenId.OpenParen) + { + Expression[] args = ParseArgumentList(); + MethodBase method; + switch (FindBestMethod(type.GetConstructors(), args, out method)) + { + case 0: + if (args.Length == 1) + return GenerateConversion(args[0], type, errorPos); + throw ParseError(errorPos, Res.NoMatchingConstructor, GetTypeName(type)); + case 1: + return Expression.New((ConstructorInfo)method, args); + default: + throw ParseError(errorPos, Res.AmbiguousConstructorInvocation, GetTypeName(type)); + } + } + ValidateToken(TokenId.Dot, Res.DotOrOpenParenExpected); + NextToken(); + return ParseMemberAccess(type, null); + } + + Expression GenerateConversion(Expression expr, Type type, int errorPos) + { + Type exprType = expr.Type; + if (exprType == type) return expr; + if (exprType.IsValueType && type.IsValueType) + { + if ((IsNullableType(exprType) || IsNullableType(type)) && + GetNonNullableType(exprType) == GetNonNullableType(type)) + return Expression.Convert(expr, type); + if ((IsNumericType(exprType) || IsEnumType(exprType)) && + (IsNumericType(type)) || IsEnumType(type)) + return Expression.ConvertChecked(expr, type); + } + if (exprType.IsAssignableFrom(type) || type.IsAssignableFrom(exprType) || + exprType.IsInterface || type.IsInterface) + return Expression.Convert(expr, type); + throw ParseError(errorPos, Res.CannotConvertValue, + GetTypeName(exprType), GetTypeName(type)); + } + + /// + /// Parsing begins here + /// + /// + /// + /// + Expression ParseMemberAccess(Type type, Expression instance) + { + if (instance != null) type = instance.Type; + int errorPos = token.pos; + string id = GetIdentifier(); + NextToken(); + if (token.id == TokenId.OpenParen) + { + if (instance != null && type != typeof(string)) + { + Type enumerableType = FindGenericType(typeof(IQueryable<>), type); + if (enumerableType != null) + { + Type elementType = enumerableType.GetGenericArguments()[0]; + return ParseAggregate(instance, elementType, id, errorPos); + } + } + Expression[] args = ParseArgumentList(); + MethodBase mb; + switch (FindMethod(type, id, instance == null, args, out mb)) + { + case 0: + throw ParseError(errorPos, Res.NoApplicableMethod, + id, GetTypeName(type)); + case 1: + MethodInfo method = (MethodInfo)mb; + if (!IsPredefinedType(method.DeclaringType)) + throw ParseError(errorPos, Res.MethodsAreInaccessible, GetTypeName(method.DeclaringType)); + if (method.ReturnType == typeof(void)) + throw ParseError(errorPos, Res.MethodIsVoid, + id, GetTypeName(method.DeclaringType)); + return Expression.Call(instance, (MethodInfo)method, args); + default: + throw ParseError(errorPos, Res.AmbiguousMethodInvocation, + id, GetTypeName(type)); + } + } + else + { + MemberInfo member = FindPropertyOrField(type, id, instance == null); + //if (member == null) + // throw ParseError(errorPos, Res.UnknownPropertyOrField, + // id, GetTypeName(type)); + if (member == null) + { + if (token.id == TokenId.Lambda && it.Type == type) + { + // This might be an internal variable for use within a lambda expression, so store it as such + internals.Add(id, it); + NextToken(); + var right = ParseExpression(); + return right; + } + else + { + throw ParseError(errorPos, Res.UnknownPropertyOrField, + id, GetTypeName(type)); + } + } + return member is PropertyInfo ? + Expression.Property(instance, (PropertyInfo)member) : + Expression.Field(instance, (FieldInfo)member); + } + } + + static Type FindGenericType(Type generic, Type type) + { + while (type != null && type != typeof(object)) + { + if (type.IsGenericType && type.GetGenericTypeDefinition() == generic) return type; + if (generic.IsInterface) + { + foreach (Type intfType in type.GetInterfaces()) + { + Type found = FindGenericType(generic, intfType); + if (found != null) return found; + } + } + type = type.BaseType; + } + return null; + } + + Expression ParseAggregate(Expression instance, Type elementType, string methodName, int errorPos) + { + ParameterExpression outerIt = it; + ParameterExpression innerIt = it == null ? Expression.Parameter(elementType, "") : Expression.Parameter(elementType, it.ToString()); + it = innerIt; + Expression[] args = ParseArgumentList(); + it = outerIt; + MethodBase signature; + if (FindMethod(typeof(IEnumerableSignatures), methodName, false, args, out signature) != 1) + throw ParseError(errorPos, Res.NoApplicableAggregate, methodName); + Type[] typeArgs; + + switch (signature.Name) + { + case "Min": + case "Max": + typeArgs = new Type[] { elementType, args[0].Type }; + break; + case "Select": + typeArgs = new Type[] { elementType, args[0].Type.GetGenericArguments().Last() }; + break; + case "OrderBy": + typeArgs = new Type[] { elementType, args[0].Type.GetGenericArguments().Last() }; + break; + case "OrderByDescending": + typeArgs = new Type[] { elementType, args[0].Type.GetGenericArguments().Last() }; + break; + default: + typeArgs = new Type[] { elementType }; + break; + } + if (args.Length == 0) + { + args = new Expression[] { instance }; + } + else + { + if (args[0].NodeType == ExpressionType.Constant) + { + args = new Expression[] { instance, args[0] }; + } + else + { + if (signature.GetParameters().Last().ParameterType == typeof(System.Linq.IQueryable) + || signature.GetParameters().Last().ParameterType == typeof(IEnumerable) + || args[0] is LambdaExpression) + { + args = new Expression[] { instance, args[0] }; + } + else + { + args = new Expression[] { instance, Expression.Lambda(args[0], innerIt) }; + } + } + } + + return Expression.Call(typeof(Queryable), signature.Name, typeArgs, args); + } + + Expression[] ParseArgumentList() + { + ValidateToken(TokenId.OpenParen, Res.OpenParenExpected); + NextToken(); + Expression[] args = token.id != TokenId.CloseParen ? ParseArguments() : new Expression[0]; + ValidateToken(TokenId.CloseParen, Res.CloseParenOrCommaExpected); + NextToken(); + return args; + } + + Expression[] ParseArguments() + { + List argList = new List(); + while (true) + { + argList.Add(ParseExpression()); + if (token.id != TokenId.Comma) break; + NextToken(); + } + return argList.ToArray(); + } + + Expression ParseElementAccess(Expression expr) + { + int errorPos = token.pos; + ValidateToken(TokenId.OpenBracket, Res.OpenParenExpected); + NextToken(); + Expression[] args = ParseArguments(); + ValidateToken(TokenId.CloseBracket, Res.CloseBracketOrCommaExpected); + NextToken(); + if (expr.Type.IsArray) + { + if (expr.Type.GetArrayRank() != 1 || args.Length != 1) + throw ParseError(errorPos, Res.CannotIndexMultiDimArray); + Expression index = PromoteExpression(args[0], typeof(int), true); + if (index == null) + throw ParseError(errorPos, Res.InvalidIndex); + return Expression.ArrayIndex(expr, index); + } + else + { + MethodBase mb; + switch (FindIndexer(expr.Type, args, out mb)) + { + case 0: + throw ParseError(errorPos, Res.NoApplicableIndexer, + GetTypeName(expr.Type)); + case 1: + return Expression.Call(expr, (MethodInfo)mb, args); + default: + throw ParseError(errorPos, Res.AmbiguousIndexerInvocation, + GetTypeName(expr.Type)); + } + } + } + + static bool IsPredefinedType(Type type) + { + foreach (Type t in predefinedTypes) if (t == type) return true; + return false; + } + + static bool IsNullableType(Type type) + { + return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>); + } + + static Type GetNonNullableType(Type type) + { + return IsNullableType(type) ? type.GetGenericArguments()[0] : type; + } + + static string GetTypeName(Type type) + { + Type baseType = GetNonNullableType(type); + string s = baseType.Name; + if (type != baseType) s += '?'; + return s; + } + + static bool IsNumericType(Type type) + { + return GetNumericTypeKind(type) != 0; + } + + static bool IsSignedIntegralType(Type type) + { + return GetNumericTypeKind(type) == 2; + } + + static bool IsUnsignedIntegralType(Type type) + { + return GetNumericTypeKind(type) == 3; + } + + static int GetNumericTypeKind(Type type) + { + type = GetNonNullableType(type); + if (type.IsEnum) return 0; + switch (Type.GetTypeCode(type)) + { + case TypeCode.Char: + case TypeCode.Single: + case TypeCode.Double: + case TypeCode.Decimal: + return 1; + case TypeCode.SByte: + case TypeCode.Int16: + case TypeCode.Int32: + case TypeCode.Int64: + return 2; + case TypeCode.Byte: + case TypeCode.UInt16: + case TypeCode.UInt32: + case TypeCode.UInt64: + return 3; + default: + return 0; + } + } + + static bool IsEnumType(Type type) + { + return GetNonNullableType(type).IsEnum; + } + + void CheckAndPromoteOperand(Type signatures, string opName, ref Expression expr, int errorPos) + { + Expression[] args = new Expression[] { expr }; + MethodBase method; + if (FindMethod(signatures, "F", false, args, out method) != 1) + throw ParseError(errorPos, Res.IncompatibleOperand, + opName, GetTypeName(args[0].Type)); + expr = args[0]; + } + + void CheckAndPromoteOperands(Type signatures, string opName, ref Expression left, ref Expression right, int errorPos) + { + Expression[] args = new Expression[] { left, right }; + MethodBase method; + if (FindMethod(signatures, "F", false, args, out method) != 1) + throw IncompatibleOperandsError(opName, left, right, errorPos); + left = args[0]; + right = args[1]; + } + + Exception IncompatibleOperandsError(string opName, Expression left, Expression right, int pos) + { + return ParseError(pos, Res.IncompatibleOperands, + opName, GetTypeName(left.Type), GetTypeName(right.Type)); + } + + MemberInfo FindPropertyOrField(Type type, string memberName, bool staticAccess) + { + BindingFlags flags = BindingFlags.Public | BindingFlags.DeclaredOnly | + (staticAccess ? BindingFlags.Static : BindingFlags.Instance); + foreach (Type t in SelfAndBaseTypes(type)) + { + MemberInfo[] members = t.FindMembers(MemberTypes.Property | MemberTypes.Field, + flags, Type.FilterNameIgnoreCase, memberName); + if (members.Length != 0) return members[0]; + } + return null; + } + + int FindMethod(Type type, string methodName, bool staticAccess, Expression[] args, out MethodBase method) + { + BindingFlags flags = BindingFlags.Public | BindingFlags.DeclaredOnly | + (staticAccess ? BindingFlags.Static : BindingFlags.Instance); + foreach (Type t in SelfAndBaseTypes(type)) + { + MemberInfo[] members = t.FindMembers(MemberTypes.Method, + flags, Type.FilterNameIgnoreCase, methodName).ToArray();//GetExtensionMethods + int count = FindBestMethod(members.Cast(), args, out method); + if (count != 0) return count; + } + method = null; + return 0; + } + + + //UNDONE: Extract extension methods dynamically instead of relying on statically defined subset in code see IEnumerableSignatures + IEnumerable GetExtensionMethods(Type extendedType, string methodName) + { + //var query = from type in typeof(System.Linq.Enumerable). + // where type.IsSealed && !type.IsGenericType && !type.IsNested + var query = from method in typeof(System.Linq.Enumerable).GetMethods(BindingFlags.Static + | BindingFlags.Public | BindingFlags.NonPublic) + where method.IsDefined(typeof(ExtensionAttribute), false) + where method.Name == methodName + //where method.GetParameters()[0].ParameterType == extendedType + select method; + return query; + } + + + int FindIndexer(Type type, Expression[] args, out MethodBase method) + { + foreach (Type t in SelfAndBaseTypes(type)) + { + MemberInfo[] members = t.GetDefaultMembers(); + if (members.Length != 0) + { + IEnumerable methods = members. + OfType(). + Select(p => (MethodBase)p.GetGetMethod()). + Where(m => m != null); + int count = FindBestMethod(methods, args, out method); + if (count != 0) return count; + } + } + method = null; + return 0; + } + + static IEnumerable SelfAndBaseTypes(Type type) + { + if (type.IsInterface) + { + List types = new List(); + AddInterface(types, type); + return types; + } + return SelfAndBaseClasses(type); + } + + static IEnumerable SelfAndBaseClasses(Type type) + { + while (type != null) + { + yield return type; + type = type.BaseType; + } + } + + static void AddInterface(List types, Type type) + { + if (!types.Contains(type)) + { + types.Add(type); + foreach (Type t in type.GetInterfaces()) AddInterface(types, t); + } + } + + class MethodData + { + public MethodBase MethodBase; + public ParameterInfo[] Parameters; + public Expression[] Args; + } + + int FindBestMethod(IEnumerable methods, Expression[] args, out MethodBase method) + { + MethodData[] applicable = methods. + Select(m => new MethodData { MethodBase = m, Parameters = m.GetParameters().Where(p => p.ParameterType != ((MethodInfo)m).ReturnType).ToArray() }). + Where(m => IsApplicable(m, args)). + ToArray(); + if (applicable.Length > 1) + { + applicable = applicable. + Where(m => applicable.All(n => m == n || IsBetterThan(args, m, n))). + ToArray(); + } + if (applicable.Length == 1) + { + MethodData md = applicable[0]; + for (int i = 0; i < args.Length; i++) args[i] = md.Args[i]; + method = md.MethodBase; + } + else + { + method = null; + } + return applicable.Length; + } + + bool IsApplicable(MethodData method, Expression[] args) + { + if (method.Parameters.Length != args.Length) return false; + Expression[] promotedArgs = new Expression[args.Length]; + for (int i = 0; i < args.Length; i++) + { + ParameterInfo pi = method.Parameters[i]; + if (pi.IsOut) return false; + Expression promoted = PromoteExpression(args[i], pi.ParameterType, false); + if (promoted == null) return false; + promotedArgs[i] = promoted; + } + method.Args = promotedArgs; + return true; + } + + Expression PromoteExpression(Expression expr, Type type, bool exact) + { + if (expr.Type == type || ((expr is LambdaExpression) && ((LambdaExpression)expr).ReturnType == type) || (expr is LambdaExpression) && type == (typeof(LambdaExpression))) return expr; + //if (expr.Type == type || ((expr is LambdaExpression) && (type is typeof(LambdaExpression))) return expr; + if (expr is ConstantExpression) + { + ConstantExpression ce = (ConstantExpression)expr; + if (ce == nullLiteral) + { + if (!type.IsValueType || IsNullableType(type)) + return Expression.Constant(null, type); + } + else + { + string text; + if (literals.TryGetValue(ce, out text)) + { + Type target = GetNonNullableType(type); + Object value = null; + switch (Type.GetTypeCode(ce.Type)) + { + case TypeCode.Int32: + case TypeCode.UInt32: + case TypeCode.Int64: + case TypeCode.UInt64: + value = ParseNumber(text, target); + break; + case TypeCode.Double: + if (target == typeof(decimal)) value = ParseNumber(text, target); + break; + case TypeCode.String: + value = ParseEnum(text, target); + break; + } + if (value != null) + return Expression.Constant(value, type); + } + } + } + if (IsCompatibleWith(expr.Type, type)) + { + if (type.IsValueType || exact) return Expression.Convert(expr, type); + return expr; + } + return null; + } + + static object ParseNumber(string text, Type type) + { + switch (Type.GetTypeCode(GetNonNullableType(type))) + { + case TypeCode.SByte: + sbyte sb; + if (sbyte.TryParse(text, out sb)) return sb; + break; + case TypeCode.Byte: + byte b; + if (byte.TryParse(text, out b)) return b; + break; + case TypeCode.Int16: + short s; + if (short.TryParse(text, out s)) return s; + break; + case TypeCode.UInt16: + ushort us; + if (ushort.TryParse(text, out us)) return us; + break; + case TypeCode.Int32: + int i; + if (int.TryParse(text, out i)) return i; + break; + case TypeCode.UInt32: + uint ui; + if (uint.TryParse(text, out ui)) return ui; + break; + case TypeCode.Int64: + long l; + if (long.TryParse(text, out l)) return l; + break; + case TypeCode.UInt64: + ulong ul; + if (ulong.TryParse(text, out ul)) return ul; + break; + case TypeCode.Single: + float f; + if (float.TryParse(text, out f)) return f; + break; + case TypeCode.Double: + double d; + if (double.TryParse(text, out d)) return d; + break; + case TypeCode.Decimal: + decimal e; + if (decimal.TryParse(text, out e)) return e; + break; + } + return null; + } + + static object ParseEnum(string name, Type type) + { + if (type.IsEnum) + { + MemberInfo[] memberInfos = type.FindMembers(MemberTypes.Field, + BindingFlags.Public | BindingFlags.DeclaredOnly | BindingFlags.Static, + Type.FilterNameIgnoreCase, name); + if (memberInfos.Length != 0) return ((FieldInfo)memberInfos[0]).GetValue(null); + } + return null; + } + + static bool IsCompatibleWith(Type source, Type target) + { + if (source == target) return true; + if (!target.IsValueType) return target.IsAssignableFrom(source); + Type st = GetNonNullableType(source); + Type tt = GetNonNullableType(target); + if (st != source && tt == target) return false; + TypeCode sc = st.IsEnum ? TypeCode.Object : Type.GetTypeCode(st); + TypeCode tc = tt.IsEnum ? TypeCode.Object : Type.GetTypeCode(tt); + switch (sc) + { + case TypeCode.SByte: + switch (tc) + { + case TypeCode.SByte: + case TypeCode.Int16: + case TypeCode.Int32: + case TypeCode.Int64: + case TypeCode.Single: + case TypeCode.Double: + case TypeCode.Decimal: + return true; + } + break; + case TypeCode.Byte: + switch (tc) + { + case TypeCode.Byte: + case TypeCode.Int16: + case TypeCode.UInt16: + case TypeCode.Int32: + case TypeCode.UInt32: + case TypeCode.Int64: + case TypeCode.UInt64: + case TypeCode.Single: + case TypeCode.Double: + case TypeCode.Decimal: + return true; + } + break; + case TypeCode.Int16: + switch (tc) + { + case TypeCode.Int16: + case TypeCode.Int32: + case TypeCode.Int64: + case TypeCode.Single: + case TypeCode.Double: + case TypeCode.Decimal: + return true; + } + break; + case TypeCode.UInt16: + switch (tc) + { + case TypeCode.UInt16: + case TypeCode.Int32: + case TypeCode.UInt32: + case TypeCode.Int64: + case TypeCode.UInt64: + case TypeCode.Single: + case TypeCode.Double: + case TypeCode.Decimal: + return true; + } + break; + case TypeCode.Int32: + switch (tc) + { + case TypeCode.Int32: + case TypeCode.Int64: + case TypeCode.Single: + case TypeCode.Double: + case TypeCode.Decimal: + return true; + } + break; + case TypeCode.UInt32: + switch (tc) + { + case TypeCode.UInt32: + case TypeCode.Int64: + case TypeCode.UInt64: + case TypeCode.Single: + case TypeCode.Double: + case TypeCode.Decimal: + return true; + } + break; + case TypeCode.Int64: + switch (tc) + { + case TypeCode.Int64: + case TypeCode.Single: + case TypeCode.Double: + case TypeCode.Decimal: + return true; + } + break; + case TypeCode.UInt64: + switch (tc) + { + case TypeCode.UInt64: + case TypeCode.Single: + case TypeCode.Double: + case TypeCode.Decimal: + return true; + } + break; + case TypeCode.Single: + switch (tc) + { + case TypeCode.Single: + case TypeCode.Double: + return true; + } + break; + default: + if (st == tt) return true; + break; + } + return false; + } + + static bool IsBetterThan(Expression[] args, MethodData m1, MethodData m2) + { + bool better = false; + for (int i = 0; i < args.Length; i++) + { + int c = CompareConversions(args[i].Type, + m1.Parameters[i].ParameterType, + m2.Parameters[i].ParameterType); + if (c < 0) return false; + if (c > 0) better = true; + } + return better; + } + + // Return 1 if s -> t1 is a better conversion than s -> t2 + // Return -1 if s -> t2 is a better conversion than s -> t1 + // Return 0 if neither conversion is better + static int CompareConversions(Type s, Type t1, Type t2) + { + if (t1 == t2) return 0; + if (s == t1) return 1; + if (s == t2) return -1; + bool t1t2 = IsCompatibleWith(t1, t2); + bool t2t1 = IsCompatibleWith(t2, t1); + if (t1t2 && !t2t1) return 1; + if (t2t1 && !t1t2) return -1; + if (IsSignedIntegralType(t1) && IsUnsignedIntegralType(t2)) return 1; + if (IsSignedIntegralType(t2) && IsUnsignedIntegralType(t1)) return -1; + return 0; + } + + Expression GenerateEqual(Expression left, Expression right) + { + return Expression.Equal(left, right); + } + + Expression GenerateNotEqual(Expression left, Expression right) + { + return Expression.NotEqual(left, right); + } + + Expression GenerateGreaterThan(Expression left, Expression right) + { + if (left.Type == typeof(string)) + { + return Expression.GreaterThan( + GenerateStaticMethodCall("Compare", left, right), + Expression.Constant(0) + ); + } + return Expression.GreaterThan(left, right); + } + + Expression GenerateGreaterThanEqual(Expression left, Expression right) + { + if (left.Type == typeof(string)) + { + return Expression.GreaterThanOrEqual( + GenerateStaticMethodCall("Compare", left, right), + Expression.Constant(0) + ); + } + return Expression.GreaterThanOrEqual(left, right); + } + + Expression GenerateLessThan(Expression left, Expression right) + { + if (left.Type == typeof(string)) + { + return Expression.LessThan( + GenerateStaticMethodCall("Compare", left, right), + Expression.Constant(0) + ); + } + return Expression.LessThan(left, right); + } + + Expression GenerateLessThanEqual(Expression left, Expression right) + { + if (left.Type == typeof(string)) + { + return Expression.LessThanOrEqual( + GenerateStaticMethodCall("Compare", left, right), + Expression.Constant(0) + ); + } + return Expression.LessThanOrEqual(left, right); + } + + Expression GenerateAdd(Expression left, Expression right) + { + if (left.Type == typeof(string) && right.Type == typeof(string)) + { + return GenerateStaticMethodCall("Concat", left, right); + } + return Expression.Add(left, right); + } + + Expression GenerateSubtract(Expression left, Expression right) + { + return Expression.Subtract(left, right); + } + + Expression GenerateStringConcat(Expression left, Expression right) + { + return Expression.Call( + null, + typeof(string).GetMethod("Concat", new[] { typeof(object), typeof(object) }), + new[] { left, right }); + } + + MethodInfo GetStaticMethod(string methodName, Expression left, Expression right) + { + return left.Type.GetMethod(methodName, new[] { left.Type, right.Type }); + } + + Expression GenerateStaticMethodCall(string methodName, Expression left, Expression right) + { + return Expression.Call(null, GetStaticMethod(methodName, left, right), new[] { left, right }); + } + + void SetTextPos(int pos) + { + textPos = pos; + ch = textPos < textLen ? text[textPos] : '\0'; + } + + void NextChar() + { + if (textPos < textLen) textPos++; + ch = textPos < textLen ? text[textPos] : '\0'; + } + + void NextToken() + { + while (Char.IsWhiteSpace(ch)) NextChar(); + TokenId t; + int tokenPos = textPos; + switch (ch) + { + case '!': + NextChar(); + if (ch == '=') + { + NextChar(); + t = TokenId.ExclamationEqual; + } + else + { + t = TokenId.Exclamation; + } + break; + case '%': + NextChar(); + t = TokenId.Percent; + break; + case '&': + NextChar(); + if (ch == '&') + { + NextChar(); + t = TokenId.DoubleAmphersand; + } + else + { + t = TokenId.Amphersand; + } + break; + case '(': + NextChar(); + t = TokenId.OpenParen; + break; + case ')': + NextChar(); + t = TokenId.CloseParen; + break; + case '*': + NextChar(); + t = TokenId.Asterisk; + break; + case '+': + NextChar(); + t = TokenId.Plus; + break; + case ',': + NextChar(); + t = TokenId.Comma; + break; + case '-': + NextChar(); + t = TokenId.Minus; + break; + case '.': + NextChar(); + t = TokenId.Dot; + break; + case '/': + NextChar(); + t = TokenId.Slash; + break; + case ':': + NextChar(); + t = TokenId.Colon; + break; + case '<': + NextChar(); + if (ch == '=') + { + NextChar(); + t = TokenId.LessThanEqual; + } + else + { + t = TokenId.LessThan; + } + break; + case '=': + NextChar(); + if (ch == '=') + { + NextChar(); + t = TokenId.DoubleEqual; + } + else if (ch == '>') + { + NextChar(); + t = TokenId.Lambda; + } + else + { + t = TokenId.Equal; + } + break; + case '>': + NextChar(); + if (ch == '=') + { + NextChar(); + t = TokenId.GreaterThanEqual; + } + else + { + t = TokenId.GreaterThan; + } + break; + case '?': + NextChar(); + t = TokenId.Question; + break; + case '[': + NextChar(); + t = TokenId.OpenBracket; + break; + case ']': + NextChar(); + t = TokenId.CloseBracket; + break; + case '|': + NextChar(); + if (ch == '|') + { + NextChar(); + t = TokenId.DoubleBar; + } + else + { + t = TokenId.Bar; + } + break; + case '"': + case '\'': + char quote = ch; + do + { + NextChar(); + while (textPos < textLen && ch != quote) NextChar(); + if (textPos == textLen) + throw ParseError(textPos, Res.UnterminatedStringLiteral); + NextChar(); + } while (ch == quote); + t = TokenId.StringLiteral; + break; + default: + if (Char.IsLetter(ch) || ch == '@' || ch == '_') + { + do + { + NextChar(); + } while (Char.IsLetterOrDigit(ch) || ch == '_'); + t = TokenId.Identifier; + break; + } + if (Char.IsDigit(ch)) + { + t = TokenId.IntegerLiteral; + do + { + NextChar(); + } while (Char.IsDigit(ch)); + if (ch == '.') + { + t = TokenId.RealLiteral; + NextChar(); + ValidateDigit(); + do + { + NextChar(); + } while (Char.IsDigit(ch)); + } + if (ch == 'E' || ch == 'e') + { + t = TokenId.RealLiteral; + NextChar(); + if (ch == '+' || ch == '-') NextChar(); + ValidateDigit(); + do + { + NextChar(); + } while (Char.IsDigit(ch)); + } + if (ch == 'F' || ch == 'f') NextChar(); + break; + } + if (textPos == textLen) + { + t = TokenId.End; + break; + } + throw ParseError(textPos, Res.InvalidCharacter, ch); + } + token.id = t; + token.text = text.Substring(tokenPos, textPos - tokenPos); + token.pos = tokenPos; + } + + bool TokenIdentifierIs(string id) + { + return token.id == TokenId.Identifier && String.Equals(id, token.text, StringComparison.OrdinalIgnoreCase); + } + + string GetIdentifier() + { + ValidateToken(TokenId.Identifier, Res.IdentifierExpected); + string id = token.text; + if (id.Length > 1 && id[0] == '@') id = id.Substring(1); + return id; + } + + void ValidateDigit() + { + if (!Char.IsDigit(ch)) throw ParseError(textPos, Res.DigitExpected); + } + + void ValidateToken(TokenId t, string errorMessage) + { + if (token.id != t) throw ParseError(errorMessage); + } + + void ValidateToken(TokenId t) + { + if (token.id != t) throw ParseError(Res.SyntaxError); + } + + Exception ParseError(string format, params object[] args) + { + return ParseError(token.pos, format, args); + } + + Exception ParseError(int pos, string format, params object[] args) + { + return new ParseException(string.Format(System.Globalization.CultureInfo.CurrentCulture, format, args), pos); + } + + static Dictionary CreateKeywords() + { + Dictionary d = new Dictionary(StringComparer.OrdinalIgnoreCase); + d.Add("true", trueLiteral); + d.Add("false", falseLiteral); + d.Add("null", nullLiteral); + d.Add(keywordIt, keywordIt); + d.Add(keywordIif, keywordIif); + d.Add(keywordNew, keywordNew); + foreach (Type type in predefinedTypes) d.Add(type.Name, type); + return d; + } + } + + static class Res + { + public const string DuplicateIdentifier = "The identifier '{0}' was defined more than once"; + public const string ExpressionTypeMismatch = "Expression of type '{0}' expected"; + public const string ExpressionExpected = "Expression expected"; + public const string InvalidCharacterLiteral = "Character literal must contain exactly one character"; + public const string InvalidIntegerLiteral = "Invalid integer literal '{0}'"; + public const string InvalidRealLiteral = "Invalid real literal '{0}'"; + public const string UnknownIdentifier = "Unknown identifier '{0}'"; + public const string NoItInScope = "No 'it' is in scope"; + public const string IifRequiresThreeArgs = "The 'iif' function requires three arguments"; + public const string FirstExprMustBeBool = "The first expression must be of type 'Boolean'"; + public const string BothTypesConvertToOther = "Both of the types '{0}' and '{1}' convert to the other"; + public const string NeitherTypeConvertsToOther = "Neither of the types '{0}' and '{1}' converts to the other"; + public const string MissingAsClause = "Expression is missing an 'as' clause"; + public const string ArgsIncompatibleWithLambda = "Argument list incompatible with lambda expression"; + public const string TypeHasNoNullableForm = "Type '{0}' has no nullable form"; + public const string NoMatchingConstructor = "No matching constructor in type '{0}'"; + public const string AmbiguousConstructorInvocation = "Ambiguous invocation of '{0}' constructor"; + public const string CannotConvertValue = "A value of type '{0}' cannot be converted to type '{1}'"; + public const string NoApplicableMethod = "No applicable method '{0}' exists in type '{1}'"; + public const string MethodsAreInaccessible = "Methods on type '{0}' are not accessible"; + public const string MethodIsVoid = "Method '{0}' in type '{1}' does not return a value"; + public const string AmbiguousMethodInvocation = "Ambiguous invocation of method '{0}' in type '{1}'"; + public const string UnknownPropertyOrField = "No property or field '{0}' exists in type '{1}'"; + public const string NoApplicableAggregate = "No applicable aggregate method '{0}' exists"; + public const string CannotIndexMultiDimArray = "Indexing of multi-dimensional arrays is not supported"; + public const string InvalidIndex = "Array index must be an integer expression"; + public const string NoApplicableIndexer = "No applicable indexer exists in type '{0}'"; + public const string AmbiguousIndexerInvocation = "Ambiguous invocation of indexer in type '{0}'"; + public const string IncompatibleOperand = "Operator '{0}' incompatible with operand type '{1}'"; + public const string IncompatibleOperands = "Operator '{0}' incompatible with operand types '{1}' and '{2}'"; + public const string UnterminatedStringLiteral = "Unterminated string literal"; + public const string InvalidCharacter = "Syntax error '{0}'"; + public const string DigitExpected = "Digit expected"; + public const string SyntaxError = "Syntax error"; + public const string TokenExpected = "{0} expected"; + public const string ParseExceptionFormat = "{0} (at index {1})"; + public const string ColonExpected = "':' expected"; + public const string OpenParenExpected = "'(' expected"; + public const string CloseParenOrOperatorExpected = "')' or operator expected"; + public const string CloseParenOrCommaExpected = "')' or ',' expected"; + public const string DotOrOpenParenExpected = "'.' or '(' expected"; + public const string OpenBracketExpected = "'[' expected"; + public const string CloseBracketOrCommaExpected = "']' or ',' expected"; + public const string IdentifierExpected = "Identifier expected"; + } +} diff --git a/TimberWinR.TestGenerator/JsonLogFileGenerator.cs b/TimberWinR.TestGenerator/JsonLogFileGenerator.cs new file mode 100644 index 0000000..cd85417 --- /dev/null +++ b/TimberWinR.TestGenerator/JsonLogFileGenerator.cs @@ -0,0 +1,252 @@ +using System.Diagnostics; +using System.Runtime.InteropServices; +using System.Runtime.Remoting.Messaging; +using System.Threading; +using Newtonsoft.Json; +using Newtonsoft.Json.Linq; +using NLog; +using NLog.Config; +using NLog.Targets; + +using System; +using System.Collections.Generic; +using System.Linq; +using System.Net; +using System.Net.Sockets; +using System.Text; +using System.IO; + +namespace TimberWinR.TestGenerator +{ + class JsonLogFileTestParameters + { + public int NumMessages { get; set; } + public string LogFileDir { get; set; } + public string LogFileName { get; set; } + public int SleepTimeMilliseconds { get; set; } + public JsonLogFileTestParameters() + { + SleepTimeMilliseconds = 30; + LogFileDir = "."; + NumMessages = 10; + } + } + + class JsonLogFileGenerator + { + public static int Generate(JsonLogFileTestParameters parms) + { + LogManager.GetCurrentClassLogger().Info("Start JSON LogFile Generation for: {0} on Thread: {1}", Path.GetFullPath(parms.LogFileName), Thread.CurrentThread.ManagedThreadId); + + var logFilePath = Path.Combine(parms.LogFileDir, parms.LogFileName); + + try + { + if (File.Exists(logFilePath)) + { + LogManager.GetCurrentClassLogger().Info("Deleting file: {0}", logFilePath); + File.Delete(logFilePath); + } + } + catch (Exception ex) + { + LogManager.GetCurrentClassLogger().Error(ex); + } + + + var hostName = System.Environment.MachineName + "." + + Microsoft.Win32.Registry.LocalMachine.OpenSubKey( + "SYSTEM\\CurrentControlSet\\services\\Tcpip\\Parameters").GetValue("Domain", "").ToString(); + + var watch = Stopwatch.StartNew(); + + // This text is always added, making the file longer over time + // if it is not deleted. + using (StreamWriter sw = File.AppendText(logFilePath)) + { + sw.AutoFlush = true; + for (int i = 0; i < parms.NumMessages; i++) + { + JObject o = new JObject + { + {"LineNumber", i+1}, + {"Application", "jsonlogfile-generator"}, + {"Host", hostName}, + {"UtcTimestamp", DateTime.UtcNow.ToString("o")}, + {"Type", "jsonlog"}, + {"Message", string.Format("{0}: Testgenerator jsonlogfile message {1}", i+1, DateTime.UtcNow.ToString("o"))}, + {"Index", "logstash"} + }; + sw.WriteLine(o.ToString(Formatting.None)); + + Thread.Sleep(parms.SleepTimeMilliseconds); + } + LogManager.GetCurrentClassLogger().Info("Elapsed Time for {0} was {1} seconds", Path.GetFullPath(parms.LogFileName), watch.Elapsed); + watch.Reset(); + } + + LogManager.GetCurrentClassLogger().Info("Finished JSON Log File Generation for: {0} elapsed: {1}", Path.GetFullPath(parms.LogFileName), watch.Elapsed); + + return parms.NumMessages; + } + } + + class JsonRollingLogFileGenerator + { + public static int Generate(JsonLogFileTestParameters parms) + { + LogManager.GetCurrentClassLogger().Info("Start JSON RollingLogFile Generation for: {0} on Thread: {1}", Path.GetFullPath(parms.LogFileName), Thread.CurrentThread.ManagedThreadId); + + var logFilePath = Path.Combine(parms.LogFileDir, parms.LogFileName); + + try + { + if (File.Exists(logFilePath)) + File.Delete(logFilePath); + + if (File.Exists(logFilePath + ".rolled")) + File.Delete(logFilePath + ".rolled"); + } + catch (Exception ex) + { + LogManager.GetCurrentClassLogger().Error(ex); + } + + + var hostName = System.Environment.MachineName + "." + + Microsoft.Win32.Registry.LocalMachine.OpenSubKey( + "SYSTEM\\CurrentControlSet\\services\\Tcpip\\Parameters").GetValue("Domain", "").ToString(); + + + int quarters = parms.NumMessages/4; + + int[] segments = new int[] {quarters, quarters, quarters, quarters + parms.NumMessages%4}; + var watch = Stopwatch.StartNew(); + + + int recordNumber = 0; + int currentTotal = 0; + for (int segment = 0; segment < 4; segment++) + { + currentTotal += segments[segment]; + + // This text is always added, making the file longer over time + // if it is not deleted. + using (StreamWriter sw = File.AppendText(logFilePath)) + { + sw.AutoFlush = true; + + var lwatch = Stopwatch.StartNew(); + + // The Rolling Generator will roll 1/2 way through the log + for (int i = 0; i < segments[segment]; i++) + { + JObject o = new JObject + { + {"LineNumber", recordNumber + 1}, + {"Application", "jsonrollinglogfile-generator"}, + {"Host", hostName}, + {"UtcTimestamp", DateTime.UtcNow.ToString("o")}, + {"Type", "jsonrollinglog"}, + { + "Message", + string.Format("{0}: Testgenerator jsonrollinglogfile message {1}", recordNumber + 1, + DateTime.UtcNow.ToString("o")) + }, + {"Index", "logstash"} + }; + sw.WriteLine(o.ToString(Formatting.None)); + recordNumber++; + Thread.Sleep(parms.SleepTimeMilliseconds); + } + LogManager.GetCurrentClassLogger().Info("Elapsed Time for {0} was {1} seconds for {2} logs", Path.GetFullPath(parms.LogFileName), lwatch.Elapsed, segments[segment]); + + } + + // + // We might not have yet processed all the lines from the first file, so wait till + // we catch up before rolling the log file. + // + LogManager.GetCurrentClassLogger().Info("{0}: Waiting for output to catch up: {1} {2}", Thread.CurrentThread.ManagedThreadId, logFilePath, currentTotal); + WaitOutputToCatchUp(logFilePath, currentTotal); + + // + // Roll the log + wait for the reader to catch up. + // + + LogManager.GetCurrentClassLogger().Info("{0}: Rolling Log File: {1} {2}", Thread.CurrentThread.ManagedThreadId, logFilePath, File.GetCreationTimeUtc(logFilePath)); + + RollLogFile(logFilePath); + + LogManager.GetCurrentClassLogger().Info("{0}: Finished Rolling Log File: {1}", Thread.CurrentThread.ManagedThreadId, logFilePath); + } + + watch.Stop(); + + LogManager.GetCurrentClassLogger().Info("Finished JSON RollingLogFile File Generation for: {0} elapsed: {1}", Path.GetFullPath(parms.LogFileName), watch.Elapsed); + + return parms.NumMessages; + } + + private static void WaitOutputToCatchUp(string logFilePath, int firstPart) + { + bool caughtUp = false; + do + { + var json = Program.Diagnostics.DiagnosticsOutput(); + + IList inputs = json["timberwinr"]["inputs"].Children().ToList(); + foreach (JToken t in inputs) + { + JProperty inputProp = t.First as JProperty; + if (inputProp.Name == "taillog" || inputProp.Name == "log") + { + var files = inputProp.Value["filedb"].Children().ToList(); + foreach (var file in files) + { + var fileName = file["FileName"].ToString(); + FileInfo fi1 = new FileInfo(fileName); + FileInfo fi2 = new FileInfo(logFilePath); + if (fi1.FullName == fi2.FullName) + { + var linesProcessed = file["LinesProcessed"].Value(); + if (linesProcessed >= firstPart) + { + caughtUp = true; + break; + } + } + } + } + } + + Thread.Sleep(300); + } while (!caughtUp); + + LogManager.GetCurrentClassLogger().Info("{0}: Finished Waiting for output to catch up: {1} {2}", Thread.CurrentThread.ManagedThreadId, logFilePath, firstPart); + + } + + private static void RollLogFile(string logFilePath) + { + bool moved = false; + do + { + try + { + if (File.Exists(logFilePath + ".rolled")) + File.Delete(logFilePath + ".rolled"); + + File.Move(logFilePath, logFilePath + ".rolled"); + moved = true; + } + catch (Exception) + { + Thread.Sleep(100); + } + } while (!moved); + Thread.Sleep(1000); + } + } + +} diff --git a/TimberWinR.TestGenerator/LogFileGenerator.cs b/TimberWinR.TestGenerator/LogFileGenerator.cs new file mode 100644 index 0000000..f1b1936 --- /dev/null +++ b/TimberWinR.TestGenerator/LogFileGenerator.cs @@ -0,0 +1,94 @@ +using System.Diagnostics; +using System.Runtime.InteropServices; +using System.Runtime.Remoting.Messaging; +using System.Threading; +using Newtonsoft.Json; +using Newtonsoft.Json.Linq; +using NLog; +using NLog.Config; +using NLog.Targets; + +using System; +using System.Collections.Generic; +using System.Linq; +using System.Net; +using System.Net.Sockets; +using System.Text; +using System.IO; + + +namespace TimberWinR.TestGenerator +{ + class LogFileTestParameters + { + public int NumMessages { get; set; } + public string LogFileDir { get; set; } + public string LogFileName { get; set; } + public int SleepTimeMilliseconds { get; set; } + public LogFileTestParameters() + { + SleepTimeMilliseconds = 30; + LogFileDir = "."; + NumMessages = 10; + } + } + + class LogFileGenerator + { + public static int Generate(JsonLogFileTestParameters parms) + { + LogManager.GetCurrentClassLogger().Info("Start LogFile Generation for: {0} on Thread: {1}", Path.GetFullPath(parms.LogFileName), Thread.CurrentThread.ManagedThreadId); + + var logFilePath = Path.Combine(parms.LogFileDir, parms.LogFileName); + + try + { + if (File.Exists(logFilePath)) + { + LogManager.GetCurrentClassLogger().Info("Deleting file: {0}", logFilePath); + File.Delete(logFilePath); + } + } + catch (Exception ex) + { + LogManager.GetCurrentClassLogger().Error(ex); + } + + + var hostName = System.Environment.MachineName + "." + + Microsoft.Win32.Registry.LocalMachine.OpenSubKey( + "SYSTEM\\CurrentControlSet\\services\\Tcpip\\Parameters").GetValue("Domain", "").ToString(); + + var watch = Stopwatch.StartNew(); + + // This text is always added, making the file longer over time + // if it is not deleted. + using (StreamWriter sw = File.AppendText(logFilePath)) + { + sw.AutoFlush = true; + for (int i = 0; i < parms.NumMessages; i++) + { + JObject o = new JObject + { + {"LineNumber", i+1}, + {"Application", "logfile-generator"}, + {"Host", hostName}, + {"UtcTimestamp", DateTime.UtcNow.ToString("o")}, + {"Type", "log"}, + {"Message", string.Format("{0}: Testgenerator logfile message {1}", i+1, DateTime.UtcNow.ToString("o"))}, + {"Index", "logstash"} + }; + sw.WriteLine(o.ToString(Formatting.None)); + + Thread.Sleep(parms.SleepTimeMilliseconds); + } + LogManager.GetCurrentClassLogger().Info("Elapsed Time for {0} was {1} seconds", Path.GetFullPath(parms.LogFileName), watch.Elapsed); + watch.Reset(); + } + + LogManager.GetCurrentClassLogger().Info("Finished LogFile Generation for: {0} elapsed: {1}", Path.GetFullPath(parms.LogFileName), watch.Elapsed); + + return parms.NumMessages; + } + } +} diff --git a/TimberWinR.TestGenerator/Program.cs b/TimberWinR.TestGenerator/Program.cs new file mode 100644 index 0000000..18cc313 --- /dev/null +++ b/TimberWinR.TestGenerator/Program.cs @@ -0,0 +1,579 @@ +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.IO; +using System.Linq; +using System.Linq.Expressions; +using System.Text; +using System.Threading; +using System.Threading.Tasks; +using System.CodeDom.Compiler; +using Newtonsoft.Json; +using Newtonsoft.Json.Linq; + +using NLog; +using NLog.Config; +using NLog.Targets; +using ServiceStack.Text.Jsv; + + +namespace TimberWinR.TestGenerator +{ + public class Program + { + private static List _tasks = new List(); + private static CancellationTokenSource _cancellationTokenSource = new CancellationTokenSource(); + private static Manager _timberWinR; + + public static Diagnostics.Diagnostics Diagnostics { get; set; } + + private static PerformanceCounter cpuCounter = new PerformanceCounter(); + private static PerformanceCounter ramCounter = new PerformanceCounter(); + private static Task _monitorTask; + + private static int _totalMessagesToSend; + private static int _cpuSampleCount; + private static double _avgCpuUsage; + private static double _totalCpuUsage; + private static double _maxCpuUsage; + + private static int _memSampleCount; + private static double _avgMemUsage; + private static double _totalMemUsage; + private static double _maxMemUsage; + + private static CommandLineOptions Options; + + static int Main(string[] args) + { + _totalMessagesToSend = 0; + + cpuCounter.CategoryName = "Processor"; + cpuCounter.CounterName = "% Processor Time"; + cpuCounter.InstanceName = "_Total"; + + ramCounter.CategoryName = "Memory"; + ramCounter.CounterName = "% Committed Bytes In Use"; + + + Options = new CommandLineOptions(); + + if (CommandLine.Parser.Default.ParseArguments(args, Options)) + { + var testFile = Options.TestFile; + if (!string.IsNullOrEmpty(testFile)) + { + if (!File.Exists(Options.TestFile)) + throw new Exception(string.Format("No such test file: {0} found", Options.TestFile)); + + var fargs = ParseTestArguments(testFile, ref Options); + if (!CommandLine.Parser.Default.ParseArguments(fargs, Options)) + return 2; + } + + SetupTestDirectory(Options); + + var swOverall = Stopwatch.StartNew(); + swOverall.Start(); + + InitializeLogging(Options.LogLevel); + + LogManager.GetCurrentClassLogger().Info("Starting CPU Usage: {0}, RAM Usage: {1}", getCurrentCpuUsage(), getAvailableRAM()); + + // Reset the tests. + ResetTests(Options); + + var sw = Stopwatch.StartNew(); + + // Startup TimberWinR + StartTimberWinR(Options.TimberWinRConfigFile, Options.LogLevel, ".", false); + + // Run the Generators + var arrayOfTasks = RunGenerators(Options); + + // Wait for all Generators to finish + try + { + Task.WaitAll(arrayOfTasks); + } + catch (AggregateException aex) + { + LogManager.GetCurrentClassLogger().Error(aex); + } + + + LogManager.GetCurrentClassLogger().Info("Generation Finished: " + sw.Elapsed); + sw.Reset(); + sw.Start(); + + // All generators are finished, wait till senders are done. + WaitForOutputTransmission(); + + LogManager.GetCurrentClassLogger().Info("Finished Transmission: " + sw.Elapsed); + sw.Reset(); + sw.Start(); + + // Get all the stats + var jsonTimberWinr = ShutdownTimberWinR(); + + LogManager.GetCurrentClassLogger().Info("Finished Shutdown: " + sw.Elapsed); + sw.Stop(); + + swOverall.Stop(); + LogManager.GetCurrentClassLogger().Info("Total Elapsed Time: {0}", swOverall.Elapsed); + + int results = VerifyResults(Options, jsonTimberWinr); + + Console.ReadKey(); + return results; + } + + return 1; + } + + private static void CopySourceFile(string fileName, string outputDir) + { + FileInfo fi = new FileInfo(fileName); + if (fi.Exists) + File.Copy(fileName, Path.Combine(outputDir, fi.Name)); + } + + private static void SetupTestDirectory(CommandLineOptions options) + { + if (options.TestDir != "." && Directory.Exists(options.TestDir)) + Directory.Delete(options.TestDir, true); + + if (!Directory.Exists(options.TestDir)) + Directory.CreateDirectory(options.TestDir); + + CopySourceFile(options.TestFile, options.TestDir); + CopySourceFile(options.TimberWinRConfigFile, options.TestDir); + CopySourceFile(options.ExpectedResultsFile, options.TestDir); + + Directory.SetCurrentDirectory(options.TestDir); + } + + private static string[] ParseTestArguments(string testFile, ref CommandLineOptions options) + { + options = new CommandLineOptions(); + JObject jtest = JObject.Parse(File.ReadAllText(testFile)); + IList inputs = jtest["arguments"].Children().ToList(); + List testargs = new List(); + foreach (JProperty it in inputs) + { + testargs.Add(it.Name); + + var cc = it.Value.Children().Count(); + if (cc > 0) + { + for (int i = 0; i < cc; i++) + { + testargs.Add(it.Value[i].ToString()); + } + } + else + { + testargs.Add(it.Value.ToString()); + } + } + var fargs = testargs.ToArray(); + return fargs; + } + + private static int VerifyResults(CommandLineOptions options, JObject json) + { + var jresult = JObject.Parse(File.ReadAllText(options.ExpectedResultsFile)); + + json["maxCpuUsage"] = _maxCpuUsage; + json["avgCpuUsage"] = _avgCpuUsage; + + json["maxMemUsage"] = _maxMemUsage; + json["avgMemUsage"] = _avgMemUsage; + + // TailLogs + + IList inputs = json["timberwinr"]["inputs"].Children().ToList(); + foreach (JToken t in inputs) + { + JProperty inputProp = t.First as JProperty; + switch (inputProp.Name) + { + case "udp": + return VerifyConditions(json, new string[] { "udp" }, inputProp, jresult); + + case "log": + case "taillog": + return VerifyConditions(json, new string[] { "log", "taillog" }, inputProp, jresult); + } + } + + return 0; + } + + private static int VerifyConditions(JObject json, string[] logTypes, JProperty inputProp, JObject jresult) + { + var ttail = inputProp.Value as JObject; + foreach (var resultInput in jresult["Results"]["Inputs"].Children().ToList()) + { + JProperty rinputProp = resultInput.First as JProperty; + if (logTypes.Contains(rinputProp.Name)) + { + foreach (JProperty testProp in rinputProp.Value) + { + try + { + var cond1 = testProp.Value.ToString(); + IList tkeys = ttail.Properties().Select(pn => pn.Name).ToList(); + foreach (string tkey in tkeys) + cond1 = cond1.Replace(string.Format("[{0}]", tkey), string.Format("{0}", ttail[tkey].ToString())); + + // Add builtins + cond1 = cond1.Replace("[avgCpuUsage]", json["avgCpuUsage"].ToString()); + cond1 = cond1.Replace("[maxCpuUsage]", json["maxCpuUsage"].ToString()); + cond1 = cond1.Replace("[avgMemUsage]", json["avgMemUsage"].ToString()); + cond1 = cond1.Replace("[maxMemUsage]", json["maxMemUsage"].ToString()); + + var p1 = Expression.Parameter(typeof(JObject), "json"); + var e1 = System.Linq.Dynamic.DynamicExpression.ParseLambda(new[] { p1 }, + typeof(bool), cond1); + bool r1 = (bool)e1.Compile().DynamicInvoke(ttail); + if (!r1) + { + LogManager.GetCurrentClassLogger().Error("Test Failed: '{0}: ({1})'", testProp.Name, cond1); + return 1; + + } + else + { + LogManager.GetCurrentClassLogger() + .Info("PASSED({0}): '{1}: ({2})'", inputProp.Name, testProp.Name, cond1); + } + } + catch (Exception ex) + { + LogManager.GetCurrentClassLogger() + .Error("Error parsing expression '{0}': {1}", testProp.Value.ToString(), + ex.Message); + return 2; + } + } + } + } + return 0; + } + + // Wait till all output has been transmitted. + private static void WaitForOutputTransmission() + { + bool completed = false; + do + { + var json = Diagnostics.DiagnosticsOutput(); + + //Console.WriteLine(json.ToString(Formatting.Indented)); + + IList inputs = json["timberwinr"]["inputs"].Children().ToList(); + foreach (var so in inputs.Children()) + { + var token = so.First; + var messages = token["messages"].Value(); + // Console.WriteLine("{0} messages", messages); + } + + + IList outputs = json["timberwinr"]["outputs"].Children().ToList(); + foreach (var so in outputs.Children()) + { + var outputToken = so.First; + + var mbc = outputToken["queuedMessageCount"].Value(); + var smc = outputToken["sentMessageCount"].Value(); + + // LogManager.GetCurrentClassLogger().Info("Queued: {0}, Sent: {1}", mbc, smc); + + completed = mbc == 0 && smc >= _totalMessagesToSend; + } + Thread.Sleep(250); + } while (!completed); + } + + private static void sampleUsages() + { + getCurrentCpuUsage(); + getAvailableRAM(); + } + + private static string getCurrentCpuUsage() + { + _cpuSampleCount++; + var v = cpuCounter.NextValue(); + if (v > _maxCpuUsage) + _maxCpuUsage = v; + + _totalCpuUsage += v; + _avgCpuUsage = _totalCpuUsage / _cpuSampleCount; + + return v + "%"; + } + + private static string getAvailableRAM() + { + _memSampleCount++; + var v = ramCounter.NextValue(); + if (v > _maxMemUsage) + _maxMemUsage = v; + + _totalMemUsage += v; + _avgMemUsage = _totalMemUsage / _memSampleCount; + return v + "MB"; + } + + private static JObject ShutdownTimberWinR() + { + _timberWinR.Shutdown(); + + // Cancel any/all other threads + _cancellationTokenSource.Cancel(); + + var json = Diagnostics.DiagnosticsOutput(); + + LogManager.GetCurrentClassLogger() + .Info("Average CPU Usage: {0}%, Average RAM Usage: {1}MB, Max CPU: {2}%, Max Mem: {3}MB", _avgCpuUsage, _avgMemUsage, _maxCpuUsage, _maxMemUsage); + + LogManager.GetCurrentClassLogger().Info(json.ToString()); + + Diagnostics.Shutdown(); + + return json; + } + + static void StartTimberWinR(string configFile, string logLevel, string logFileDir, bool enableLiveMonitor) + { + _timberWinR = new TimberWinR.Manager(configFile, logLevel, logFileDir, enableLiveMonitor, _cancellationTokenSource.Token, false); + _timberWinR.OnConfigurationProcessed += TimberWinROnOnConfigurationProcessed; + _timberWinR.Start(_cancellationTokenSource.Token); + Diagnostics = new Diagnostics.Diagnostics(_timberWinR, _cancellationTokenSource.Token, 5141); + } + + private static void TimberWinROnOnConfigurationProcessed(Configuration configuration) + { + Console.WriteLine("Processed Config: {0}", configuration.GetHashCode()); + + if (!string.IsNullOrEmpty(Options.RedisHost) && configuration.RedisOutputs != null && configuration.RedisOutputs.Count() > 0) + { + foreach (var ro in configuration.RedisOutputs) + { + ro.Host = new string[] { Options.RedisHost }; + } + } + + } + + static void InitializeLogging(string logLevel) + { + var loggingConfiguration = new LoggingConfiguration(); + + // Create our default targets + var coloredConsoleTarget = new ColoredConsoleTarget(); + + var logFileDir = "."; + + Target fileTarget = CreateDefaultFileTarget(logFileDir); + + loggingConfiguration.AddTarget("Console", coloredConsoleTarget); + loggingConfiguration.AddTarget("DailyFile", fileTarget); + + // The LogLevel.Trace means has to be at least Trace to show up on console + loggingConfiguration.LoggingRules.Add(new LoggingRule("*", LogLevel.Trace, coloredConsoleTarget)); + // LogLevel.Debug means has to be at least Debug to show up in logfile + loggingConfiguration.LoggingRules.Add(new LoggingRule("*", LogLevel.Debug, fileTarget)); + + LogManager.Configuration = loggingConfiguration; + LogManager.EnableLogging(); + + LogManager.GlobalThreshold = LogLevel.FromString(logLevel); + } + + static FileTarget CreateDefaultFileTarget(string logPath) + { + return new FileTarget + { + ArchiveEvery = FileArchivePeriod.None, + ArchiveAboveSize = 5 * 1024 * 1024, + MaxArchiveFiles = 5, + BufferSize = 10, + FileName = Path.Combine(logPath, "TimberWinR.TestGenerator", "TimberWinRTestGen.log"), + ArchiveFileName = Path.Combine(logPath, "TimberWinR-TestGenerator_log-{#######}.log"), + }; + } + + static void ResetTests(CommandLineOptions options) + { + if (File.Exists(".timberwinrdb")) + File.Delete(".timberwinrdb"); + + if (File.Exists("TimberWinR.TestGenerator\\TimberWinRTestGen.log")) + File.Delete("TimberWinR.TestGenerator\\TimberWinRTestGen.log"); + + if (File.Exists("TimberWinR\\TimberWinR.log")) + File.Delete("TimberWinR\\TimberWinR.log"); + + if (options.JsonLogFiles.Length > 0) + { + foreach (var logFile in options.JsonLogFiles) + { + if (File.Exists(logFile)) + File.Delete(logFile); + } + } + + if (options.JsonRollingLogFiles.Length > 0) + { + foreach (var logFile in options.JsonRollingLogFiles) + { + if (File.Exists(logFile)) + File.Delete(logFile); + } + } + } + + static Task[] RunGenerators(CommandLineOptions options) + { + _monitorTask = Task.Factory.StartNew(() => + { + using (var syncHandle = new ManualResetEventSlim()) + { + try + { + // Execute the query + while (!_cancellationTokenSource.Token.IsCancellationRequested) + { + sampleUsages(); + // LogManager.GetCurrentClassLogger().Info("Starting CPU Usage: {0}, RAM Usage: {1}", getCurrentCpuUsage(), getAvailableRAM()); + syncHandle.Wait(TimeSpan.FromMilliseconds(options.JsonRate), _cancellationTokenSource.Token); + } + } + catch (OperationCanceledException) + { + } + catch (Exception ex) + { + LogManager.GetCurrentClassLogger().Error(ex); + } + } + }, _cancellationTokenSource.Token, TaskCreationOptions.LongRunning, TaskScheduler.Current); + + StartJson(options); + StartJsonRolling(options); + StartUdp(options); + StartTcp(options); + + return _tasks.ToArray(); + } + + static void StartJson(CommandLineOptions options) + { + if (options.JsonLogFiles.Length > 0) + { + foreach (var logFile in options.JsonLogFiles) + { + _totalMessagesToSend += options.NumMessages; + + if (options.Verbose) + LogManager.GetCurrentClassLogger() + .Info("Starting LogFile Generator for {0}", + Path.GetFullPath(Path.Combine(options.JsonLogDir, logFile))); + _tasks.Add(Task.Factory.StartNew(() => + { + var p = new JsonLogFileTestParameters() + { + NumMessages = options.NumMessages, + LogFileDir = options.JsonLogDir, + LogFileName = logFile, + SleepTimeMilliseconds = options.JsonRate + }; + JsonLogFileGenerator.Generate(p); + Thread.Sleep(250); + })); + + } + } + } + + private static void StartJsonRolling(CommandLineOptions options) + { + if (options.JsonRollingLogFiles.Length > 0) + { + foreach (var logFile in options.JsonRollingLogFiles) + { + _totalMessagesToSend += options.NumMessages; + + if (options.Verbose) + LogManager.GetCurrentClassLogger() + .Info("Starting RollingLogFile Generator for {0}", + Path.GetFullPath(Path.Combine(options.JsonLogDir, logFile))); + _tasks.Add(Task.Factory.StartNew(() => + { + var p = new JsonLogFileTestParameters() + { + NumMessages = options.NumMessages, + LogFileDir = options.JsonLogDir, + LogFileName = logFile, + SleepTimeMilliseconds = options.JsonRate + }; + JsonRollingLogFileGenerator.Generate(p); + Thread.Sleep(250); + })); + + } + } + } + + static void StartUdp(CommandLineOptions options) + { + if (options.Udp > 0) + { + if (options.Verbose) + LogManager.GetCurrentClassLogger() + .Info("Starting UDP Generator for {0}:{1}", options.UdpHost, options.Udp); + + _tasks.Add(Task.Factory.StartNew(() => + { + var p = new UdpTestParameters() + { + Port = options.Udp, + Host = options.UdpHost, + NumMessages = options.NumMessages, + SleepTimeMilliseconds = options.UdpRate + }; + _totalMessagesToSend += UdpTestGenerator.Generate(p); + })); + } + } + + static void StartTcp(CommandLineOptions options) + { + if (options.Tcp > 0) + { + if (options.Verbose) + LogManager.GetCurrentClassLogger() + .Info("Starting Tcp Generator for {0}:{1}", options.TcpHost, options.Tcp); + + _totalMessagesToSend += options.NumMessages; + + _tasks.Add(Task.Factory.StartNew(() => + { + var p = new TcpTestParameters() + { + Port = options.Tcp, + Host = options.TcpHost, + NumMessages = options.NumMessages, + SleepTimeMilliseconds = options.TcpRate + }; + TcpTestGenerator.Generate(p); + })); + } + } + + } +} diff --git a/TimberWinR.TestGenerator/Properties/AssemblyInfo.cs b/TimberWinR.TestGenerator/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..99e0400 --- /dev/null +++ b/TimberWinR.TestGenerator/Properties/AssemblyInfo.cs @@ -0,0 +1,36 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("TimberWinR.TestGenerator")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("TimberWinR.TestGenerator")] +[assembly: AssemblyCopyright("Copyright © 2015")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("a56bf91c-c5f8-4771-8ef8-ab9ad28179c4")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// 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.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/TimberWinR.TestGenerator/RedisTestGenerator.cs b/TimberWinR.TestGenerator/RedisTestGenerator.cs new file mode 100644 index 0000000..6af0cd9 --- /dev/null +++ b/TimberWinR.TestGenerator/RedisTestGenerator.cs @@ -0,0 +1,49 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using Newtonsoft.Json.Linq; +using ServiceStack.Redis; + +namespace TimberWinR.TestGenerator +{ + class RedisTestParameters + { + public int Port { get; set; } + public string Host { get; set; } + public int NumMessages { get; set; } + public RedisTestParameters() + { + NumMessages = 100; + Port = 6379; + Host = "localhost"; + } + } + + class RedisTestGenerator + { + public static void Generate(RedisTestParameters parms) + { + var hostName = System.Environment.MachineName + "." + + Microsoft.Win32.Registry.LocalMachine.OpenSubKey( + "SYSTEM\\CurrentControlSet\\services\\Tcpip\\Parameters").GetValue("Domain", "").ToString(); + + var rc = new RedisClient(parms.Host, parms.Port); + + for (int i = 0; i < parms.NumMessages; i++) + { + JObject o = new JObject + { + {"Application", "redis-generator"}, + {"Host", hostName}, + {"UtcTimestamp", DateTime.UtcNow.ToString("o")}, + {"Type", "redis"}, + {"Message", "redis message " + DateTime.UtcNow.ToString("o")}, + {"Index", "logstash"} + }; + byte[] bytes = System.Text.Encoding.UTF8.GetBytes(o.ToString()); + var restult = rc.RPush("logstash", bytes); + } + } + } +} diff --git a/TimberWinR.TestGenerator/TcpTestGenerator.cs b/TimberWinR.TestGenerator/TcpTestGenerator.cs new file mode 100644 index 0000000..7037a27 --- /dev/null +++ b/TimberWinR.TestGenerator/TcpTestGenerator.cs @@ -0,0 +1,62 @@ +using System.Threading; +using Newtonsoft.Json.Linq; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Net; +using System.Net.Sockets; +using System.Text; +using ServiceStack.Text; + +namespace TimberWinR.TestGenerator +{ + class TcpTestParameters + { + public int Port { get; set; } + public string Host { get; set; } + public int NumMessages { get; set; } + public int SleepTimeMilliseconds { get; set; } + public TcpTestParameters() + { + NumMessages = 100; + Port = 5140; + Host = "localhost"; + SleepTimeMilliseconds = 10; + } + } + + class TcpTestGenerator + { + public static int Generate(TcpTestParameters parms) + { + TcpClient server = new TcpClient(parms.Host, parms.Port); + + var hostName = System.Environment.MachineName + "." + + Microsoft.Win32.Registry.LocalMachine.OpenSubKey( + "SYSTEM\\CurrentControlSet\\services\\Tcpip\\Parameters").GetValue("Domain", "").ToString(); + + + using (NetworkStream stream = server.GetStream()) + { + for (int i = 0; i < parms.NumMessages; i++) + { + JObject o = new JObject + { + {"Application", "tcp-generator"}, + {"Host", hostName}, + {"UtcTimestamp", DateTime.UtcNow.ToString("o")}, + {"Type", "tcp"}, + {"Message", "tcp message " + DateTime.UtcNow.ToString("o")}, + {"Index", "logstash"} + }; + byte[] data = Encoding.UTF8.GetBytes(string.Format("{0}\n", o.ToString())); + stream.Write(data, 0, data.Length); + Thread.Sleep(parms.SleepTimeMilliseconds); + } + } + + return parms.NumMessages; + } + + } +} diff --git a/TimberWinR.TestGenerator/TimberWinR.TestGenerator.csproj b/TimberWinR.TestGenerator/TimberWinR.TestGenerator.csproj new file mode 100644 index 0000000..f1191e4 --- /dev/null +++ b/TimberWinR.TestGenerator/TimberWinR.TestGenerator.csproj @@ -0,0 +1,115 @@ + + + + + Debug + AnyCPU + {F3960D6E-1EA0-4F4E-8F08-82FC185A0D29} + Exe + Properties + TimberWinR.TestGenerator + TimberWinR.TestGenerator + v4.0 + 512 + + + AnyCPU + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + + + AnyCPU + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + + + + ..\packages\CommandLineParser.1.9.71\lib\net40\CommandLine.dll + + + False + ..\packages\Newtonsoft.Json.6.0.8\lib\net40\Newtonsoft.Json.dll + + + False + ..\packages\NLog.3.2.0.0\lib\net40\NLog.dll + + + ..\packages\ServiceStack.Common.Signed.4.0.38\lib\net40\ServiceStack.Common.dll + + + ..\packages\ServiceStack.Interfaces.4.0.38\lib\portable-wp80+sl5+net40+win8+monotouch+monoandroid\ServiceStack.Interfaces.dll + + + ..\packages\ServiceStack.Redis.Signed.4.0.38\lib\net40\ServiceStack.Redis.dll + + + ..\packages\ServiceStack.Text.Signed.4.0.38\lib\net40\ServiceStack.Text.dll + + + + + + + + + + + + + + + + + + + + + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + + + {4ef96a08-21db-4178-be44-70dae594632c} + TimberWinR + + + + + \ No newline at end of file diff --git a/TimberWinR.TestGenerator/UdpTestGenerator.cs b/TimberWinR.TestGenerator/UdpTestGenerator.cs new file mode 100644 index 0000000..cf2644f --- /dev/null +++ b/TimberWinR.TestGenerator/UdpTestGenerator.cs @@ -0,0 +1,70 @@ +using System.Threading; +using Newtonsoft.Json.Linq; +using NLog; +using NLog.Config; +using NLog.Targets; + +using System; +using System.Collections.Generic; +using System.Linq; +using System.Net; +using System.Net.Sockets; +using System.Text; + +namespace TimberWinR.TestGenerator +{ + class UdpTestParameters + { + public int Port { get; set; } + public string Host { get; set; } + public int NumMessages { get; set; } + public int SleepTimeMilliseconds { get; set; } + public UdpTestParameters() + { + NumMessages = 100; + Port = 6379; + Host = "localhost"; + SleepTimeMilliseconds = 10; + } + } + + class UdpTestGenerator + { + public static int Generate(UdpTestParameters parms) + { + var hostName = System.Environment.MachineName + "." + + Microsoft.Win32.Registry.LocalMachine.OpenSubKey( + "SYSTEM\\CurrentControlSet\\services\\Tcpip\\Parameters").GetValue("Domain", "").ToString(); + + IPAddress broadcast; + if (!IPAddress.TryParse(parms.Host, out broadcast)) + broadcast = Dns.GetHostEntry(parms.Host).AddressList[0]; + + Socket s = new Socket(broadcast.AddressFamily, SocketType.Dgram, ProtocolType.Udp); + + LogManager.GetCurrentClassLogger().Info("Start UDP Generation"); + + for (int i = 0; i < parms.NumMessages; i++) + { + JObject o = new JObject + { + {"Application", "udp-generator"}, + {"Host", hostName}, + {"UtcTimestamp", DateTime.UtcNow.ToString("o")}, + {"Type", "udp"}, + {"Message", "Testgenerator udp message " + DateTime.UtcNow.ToString("o")}, + {"Index", "logstash"} + }; + byte[] sendbuf = Encoding.UTF8.GetBytes(o.ToString()); + IPEndPoint ep = new IPEndPoint(broadcast, parms.Port); + s.SendTo(sendbuf, ep); + Thread.Sleep(parms.SleepTimeMilliseconds); + } + + LogManager.GetCurrentClassLogger().Info("Finished UDP Generation"); + + return parms.NumMessages; + } + + } +} diff --git a/TimberWinR.TestGenerator/default.json b/TimberWinR.TestGenerator/default.json new file mode 100644 index 0000000..9740666 --- /dev/null +++ b/TimberWinR.TestGenerator/default.json @@ -0,0 +1,45 @@ +{ + "TimberWinR": { + "Inputs": { + "Udp": [ + { + "_comment": "Output from NLog", + "port": 5140 + } + ], + "TailFiles": [ + { + "interval": 5, + "logSource": "log files", + "location": "*.jlog", + "recurse": -1 + } + ] + }, + "Filters": [ + { + "grok": { + "condition": "\"[EventTypeName]\" == \"Information Event\"", + "match": [ + "Text", + "" + ], + "drop": "true" + } + } + ], + "Outputs": { + "Redis": [ + { + "_comment": "Change the host to your Redis instance", + "port": 6379, + "batch_count": 500, + "threads": 2, + "host": [ + "tstlexiceapp006.vistaprint.svc" + ] + } + ] + } + } +} diff --git a/TimberWinR.TestGenerator/packages.config b/TimberWinR.TestGenerator/packages.config new file mode 100644 index 0000000..fdebb31 --- /dev/null +++ b/TimberWinR.TestGenerator/packages.config @@ -0,0 +1,10 @@ + + + + + + + + + + \ No newline at end of file diff --git a/TimberWinR.TestGenerator/results1.json b/TimberWinR.TestGenerator/results1.json new file mode 100644 index 0000000..0e887d1 --- /dev/null +++ b/TimberWinR.TestGenerator/results1.json @@ -0,0 +1,20 @@ +{ + "Results": { + "Inputs": [ + { + "taillog": { + "test1: message sent count": "[messages] == 7404", + "test2: average cpu": "[avgCpuUsage] <= 30", + "test3: maximum memory": "[maxMemUsage] <= 20" + } + }, + { + "udp": { + "test1: message sent count": "[messages] == 1234", + "test2: average cpu": "[avgCpuUsage] <= 30", + "test3: maximum memory": "[maxMemUsage] <= 20" + } + } + ] + } +} diff --git a/TimberWinR.TestGenerator/results2.json b/TimberWinR.TestGenerator/results2.json new file mode 100644 index 0000000..e20ac02 --- /dev/null +++ b/TimberWinR.TestGenerator/results2.json @@ -0,0 +1,20 @@ +{ + "Results": { + "Inputs": [ + { + "taillog": { + "test1: message sent count": "[messages] == 7404", + "test2: average cpu": "[avgCpuUsage] <= 30", + "test3: maximum memory": "[maxMemUsage] <= 15" + } + }, + { + "udp": { + "test1: message sent count": "[messages] == 1234", + "test2: average cpu": "[avgCpuUsage] <= 30", + "test3: maximum memory": "[maxMemUsage] <= 15" + } + } + ] + } +} diff --git a/TimberWinR.TestGenerator/test1-twconfig.json b/TimberWinR.TestGenerator/test1-twconfig.json new file mode 100644 index 0000000..9740666 --- /dev/null +++ b/TimberWinR.TestGenerator/test1-twconfig.json @@ -0,0 +1,45 @@ +{ + "TimberWinR": { + "Inputs": { + "Udp": [ + { + "_comment": "Output from NLog", + "port": 5140 + } + ], + "TailFiles": [ + { + "interval": 5, + "logSource": "log files", + "location": "*.jlog", + "recurse": -1 + } + ] + }, + "Filters": [ + { + "grok": { + "condition": "\"[EventTypeName]\" == \"Information Event\"", + "match": [ + "Text", + "" + ], + "drop": "true" + } + } + ], + "Outputs": { + "Redis": [ + { + "_comment": "Change the host to your Redis instance", + "port": 6379, + "batch_count": 500, + "threads": 2, + "host": [ + "tstlexiceapp006.vistaprint.svc" + ] + } + ] + } + } +} diff --git a/TimberWinR.TestGenerator/test1.json b/TimberWinR.TestGenerator/test1.json new file mode 100644 index 0000000..241a50c --- /dev/null +++ b/TimberWinR.TestGenerator/test1.json @@ -0,0 +1,15 @@ +{ + "test": "Test 1", + "arguments": { + "--testFile": "test1.json", + "--testDir": "test1", + "--timberWinRConfig": "test1-twconfig.json", + "--numMessages": 1234, + "--logLevel": "debug", + "--udp-host": "::1", + "--udp": "5140", + "--jroll": ["r1.jlog", "r2.jlog"], + "--json": ["1.jlog", "2.jlog", "3.jlog", "4.jlog"], + "--resultsFile": "results1.json" + } +} diff --git a/TimberWinR.TestGenerator/test2-tw.json b/TimberWinR.TestGenerator/test2-tw.json new file mode 100644 index 0000000..a321b18 --- /dev/null +++ b/TimberWinR.TestGenerator/test2-tw.json @@ -0,0 +1,45 @@ +{ + "TimberWinR": { + "Inputs": { + "Udp": [ + { + "_comment": "Output from NLog", + "port": 5140 + } + ], + "Logs": [ + { + "interval": 5, + "logSource": "log files", + "location": "*.jlog", + "recurse": -1 + } + ] + }, + "Filters": [ + { + "grok": { + "condition": "\"[EventTypeName]\" == \"Information Event\"", + "match": [ + "Text", + "" + ], + "drop": "true" + } + } + ], + "Outputs": { + "Redis": [ + { + "_comment": "Change the host to your Redis instance", + "port": 6379, + "batch_count": 500, + "threads": 2, + "host": [ + "tstlexiceapp006.vistaprint.svc" + ] + } + ] + } + } +} diff --git a/TimberWinR.TestGenerator/test2.json b/TimberWinR.TestGenerator/test2.json new file mode 100644 index 0000000..223da98 --- /dev/null +++ b/TimberWinR.TestGenerator/test2.json @@ -0,0 +1,14 @@ +{ + "test": "Test 2", + "arguments": { + "--testFile": "test2.json", + "--testDir": "test2", + "--timberWinRConfig": "test2-tw.json", + "--numMessages": 1234, + "--logLevel": "debug", + "--udp": "5140", + "--jroll": ["r1.jlog", "r2.jlog"], + "--json": ["1.jlog", "2.jlog", "3.jlog", "4.jlog"], + "--resultsFile": "results2.json" + } +} diff --git a/TimberWinR.UnitTests/GrokFilterTests.cs b/TimberWinR.UnitTests/GrokFilterTests.cs index c1e4398..5aecd96 100644 --- a/TimberWinR.UnitTests/GrokFilterTests.cs +++ b/TimberWinR.UnitTests/GrokFilterTests.cs @@ -223,6 +223,7 @@ namespace TimberWinR.UnitTests } }, {"type", "Win32-FileLog"}, + {"Type", "Win32-MyType"}, {"ComputerName", "dev.mycompany.net"} }; @@ -281,11 +282,35 @@ namespace TimberWinR.UnitTests } }"; - // Positive Tests - Configuration c = Configuration.FromString(grokJson1); + string grokJson4 = @"{ + ""TimberWinR"":{ + ""Filters"":[ + { + ""grok"":{ + ""condition"": ""!\""[Type]\"".StartsWith(\""[\"") && !\""[Type]\"".EndsWith(\""]\"") && (\""[type]\"" == \""Win32-FileLog\"")"", + ""match"":[ + ""Text"", + """" + ], + ""remove_tag"":[ + ""tag1"" + ] + } + }] + } + }"; + + + Configuration c = Configuration.FromString(grokJson4); Grok grok = c.Filters.First() as Grok; Assert.IsTrue(grok.Apply(json)); + + // Positive Tests + c = Configuration.FromString(grokJson1); + grok = c.Filters.First() as Grok; + Assert.IsTrue(grok.Apply(json)); + c = Configuration.FromString(grokJson2); grok = c.Filters.First() as Grok; Assert.IsTrue(grok.Apply(json)); diff --git a/TimberWinR.UnitTests/TailFileTests.cs b/TimberWinR.UnitTests/TailFileTests.cs index 12a044e..89388a1 100644 --- a/TimberWinR.UnitTests/TailFileTests.cs +++ b/TimberWinR.UnitTests/TailFileTests.cs @@ -28,7 +28,7 @@ namespace TimberWinR.UnitTests var mgr = new Manager(); mgr.LogfileDir = "."; - var tf = new TailFile(); + var tf = new TailFileArguments(); var cancelTokenSource = new CancellationTokenSource(); tf.Location = "TestTailFile1.log"; diff --git a/TimberWinR.UnitTests/TimberWinR.UnitTests.csproj b/TimberWinR.UnitTests/TimberWinR.UnitTests.csproj index b927454..70a7674 100644 --- a/TimberWinR.UnitTests/TimberWinR.UnitTests.csproj +++ b/TimberWinR.UnitTests/TimberWinR.UnitTests.csproj @@ -39,15 +39,17 @@ ..\TimberWinR\lib\com-logparser\Interop.MSUtil.dll - ..\packages\Moq.4.2.1409.1722\lib\net40\Moq.dll + ..\packages\Moq.4.2.1502.0911\lib\net40\Moq.dll + True False - ..\packages\Newtonsoft.Json.6.0.4\lib\net40\Newtonsoft.Json.dll + ..\packages\Newtonsoft.Json.6.0.8\lib\net40\Newtonsoft.Json.dll + True - + False - ..\packages\NUnit.2.6.3\lib\nunit.framework.dll + ..\packages\NUnit.2.6.4\lib\nunit.framework.dll @@ -82,6 +84,7 @@ + Designer diff --git a/TimberWinR.UnitTests/app.config b/TimberWinR.UnitTests/app.config new file mode 100644 index 0000000..a01ef9c --- /dev/null +++ b/TimberWinR.UnitTests/app.config @@ -0,0 +1,11 @@ + + + + + + + + + + + \ No newline at end of file diff --git a/TimberWinR.sln b/TimberWinR.sln index 321b5ff..b32d06e 100644 --- a/TimberWinR.sln +++ b/TimberWinR.sln @@ -35,6 +35,8 @@ Project("{930C7802-8A8C-48F9-8165-68863BCCD9DD}") = "TimberWinR.Wix", "TimberWix EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "TimberWinR.ExtractID", "TimberWinR.ExtractID\TimberWinR.ExtractID.csproj", "{99096939-E9DD-4499-883D-4726745A5843}" EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "TimberWinR.TestGenerator", "TimberWinR.TestGenerator\TimberWinR.TestGenerator.csproj", "{F3960D6E-1EA0-4F4E-8F08-82FC185A0D29}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU @@ -97,6 +99,16 @@ Global {99096939-E9DD-4499-883D-4726745A5843}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU {99096939-E9DD-4499-883D-4726745A5843}.Release|Mixed Platforms.Build.0 = Release|Any CPU {99096939-E9DD-4499-883D-4726745A5843}.Release|x86.ActiveCfg = Release|Any CPU + {F3960D6E-1EA0-4F4E-8F08-82FC185A0D29}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {F3960D6E-1EA0-4F4E-8F08-82FC185A0D29}.Debug|Any CPU.Build.0 = Debug|Any CPU + {F3960D6E-1EA0-4F4E-8F08-82FC185A0D29}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {F3960D6E-1EA0-4F4E-8F08-82FC185A0D29}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {F3960D6E-1EA0-4F4E-8F08-82FC185A0D29}.Debug|x86.ActiveCfg = Debug|Any CPU + {F3960D6E-1EA0-4F4E-8F08-82FC185A0D29}.Release|Any CPU.ActiveCfg = Release|Any CPU + {F3960D6E-1EA0-4F4E-8F08-82FC185A0D29}.Release|Any CPU.Build.0 = Release|Any CPU + {F3960D6E-1EA0-4F4E-8F08-82FC185A0D29}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {F3960D6E-1EA0-4F4E-8F08-82FC185A0D29}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {F3960D6E-1EA0-4F4E-8F08-82FC185A0D29}.Release|x86.ActiveCfg = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE diff --git a/TimberWinR/Configuration.cs b/TimberWinR/Configuration.cs index 78fb08f..3dfe485 100644 --- a/TimberWinR/Configuration.cs +++ b/TimberWinR/Configuration.cs @@ -44,7 +44,7 @@ namespace TimberWinR { get { return _redisOutputs; } } - + private List _elasticsearchOutputs = new List(); public IEnumerable ElasticsearchOutputs @@ -76,8 +76,8 @@ namespace TimberWinR get { return _logs; } } - private List _tails = new List(); - public IEnumerable TailFiles + private List _tails = new List(); + public IEnumerable TailFiles { get { return _tails; } } @@ -241,8 +241,8 @@ namespace TimberWinR c._stdins.AddRange(x.TimberWinR.Inputs.Stdins.ToList()); if (x.TimberWinR.Inputs.Logs != null) c._logs.AddRange(x.TimberWinR.Inputs.Logs.ToList()); - if (x.TimberWinR.Inputs.TailFiles != null) - c._tails.AddRange(x.TimberWinR.Inputs.TailFiles.ToList()); + if (x.TimberWinR.Inputs.TailFilesArguments != null) + c._tails.AddRange(x.TimberWinR.Inputs.TailFilesArguments.ToList()); if (x.TimberWinR.Inputs.Tcps != null) c._tcps.AddRange(x.TimberWinR.Inputs.Tcps.ToList()); if (x.TimberWinR.Inputs.Udps != null) diff --git a/TimberWinR/Diagnostics/Diagnostics.cs b/TimberWinR/Diagnostics/Diagnostics.cs index 9596429..f009047 100644 --- a/TimberWinR/Diagnostics/Diagnostics.cs +++ b/TimberWinR/Diagnostics/Diagnostics.cs @@ -21,7 +21,7 @@ namespace TimberWinR.Diagnostics private CancellationToken CancelToken { get; set; } public int Port { get; set; } public Manager Manager { get; set; } - + public bool Stop { get; set; } private HttpListener web; public Diagnostics(Manager manager, CancellationToken cancelToken, int port = 5141) @@ -49,44 +49,60 @@ namespace TimberWinR.Diagnostics } - private void DiagnosticCallback(IAsyncResult result) - { - if (web == null) - return; - - var context = web.EndGetContext(result); - var response = context.Response; - + public JObject DiagnosticsOutput() + { JObject json = new JObject( - new JProperty("timberwinr", - new JObject( - new JProperty("version", GetAssemblyByName("TimberWinR.ServiceHost").GetName().Version.ToString()), - new JProperty("messages", Manager.NumMessages), - new JProperty("startedon", Manager.StartedOn), - new JProperty("configfile", Manager.JsonConfig), - new JProperty("logdir", Manager.LogfileDir), - new JProperty("logginglevel", LogManager.GlobalThreshold.ToString()), - new JProperty("inputs", - new JArray( - from i in Manager.Listeners - select new JObject(i.ToJson()))), - new JProperty("filters", - new JArray( - from f in Manager.Config.Filters - select new JObject(f.ToJson()))), - new JProperty("outputs", - new JArray( - from o in Manager.Outputs - select new JObject(o.ToJson())))))); - - response.StatusCode = (int)HttpStatusCode.OK; - response.StatusDescription = HttpStatusCode.OK.ToString(); - byte[] buffer = Encoding.UTF8.GetBytes(json.ToString()); - response.ContentLength64 = buffer.Length; - response.OutputStream.Write(buffer, 0, buffer.Length); - response.OutputStream.Close(); + new JProperty("timberwinr", + new JObject( + new JProperty("version", Assembly.GetEntryAssembly().GetName().Version.ToString()), + new JProperty("messages", Manager.NumMessages), + new JProperty("startedon", Manager.StartedOn), + new JProperty("configfile", Manager.JsonConfig), + new JProperty("logdir", Manager.LogfileDir), + new JProperty("logginglevel", LogManager.GlobalThreshold.ToString()), + new JProperty("inputs", + new JArray( + from i in Manager.Listeners + select new JObject(i.ToJson()))), + new JProperty("filters", + new JArray( + from f in Manager.Config.Filters + select new JObject(f.ToJson()))), + new JProperty("outputs", + new JArray( + from o in Manager.Outputs + select new JObject(o.ToJson())))))); + return json; } + private void DiagnosticCallback(IAsyncResult result) + { + if (web == null) + return; + + try + { + var context = web.EndGetContext(result); + var response = context.Response; + var json = DiagnosticsOutput(); + + response.StatusCode = (int) HttpStatusCode.OK; + response.StatusDescription = HttpStatusCode.OK.ToString(); + byte[] buffer = Encoding.UTF8.GetBytes(json.ToString()); + response.ContentLength64 = buffer.Length; + response.OutputStream.Write(buffer, 0, buffer.Length); + response.OutputStream.Close(); + } + catch (SocketException) + { + // Shutdown + } + catch (Exception ex) + { + if (!Stop) + LogManager.GetCurrentClassLogger().Error(ex); + } + } private void HttpListen(object o) { @@ -97,14 +113,19 @@ namespace TimberWinR.Diagnostics web.Start(); while (web != null && web.IsListening) - { - processRequest(); - } + { + processRequest(); + } + } + catch (SocketException) + { + // Shutdown } catch (Exception ex) { + if (!Stop) LogManager.GetCurrentClassLogger().Error("Diagnostic Listener Error: {0}", ex.ToString()); - } + } } private void ListenForClients(object olistener) @@ -140,7 +161,7 @@ namespace TimberWinR.Diagnostics var tcpClient = (TcpClient)client; NetworkStream clientStream = null; - Console.WriteLine("Handle new diag client: {0}, {1}", tcpClient.Connected, tcpClient.Client.RemoteEndPoint.ToString()); + // Console.WriteLine("Handle new diag client: {0}, {1}", tcpClient.Connected, tcpClient.Client.RemoteEndPoint.ToString()); try { using (clientStream = tcpClient.GetStream()) @@ -183,7 +204,7 @@ namespace TimberWinR.Diagnostics public void Shutdown() { - + Stop = true; try { if (web != null && web.IsListening) @@ -193,11 +214,9 @@ namespace TimberWinR.Diagnostics web = null; } } - catch (Exception ex) + catch (Exception) { - LogManager.GetCurrentClassLogger().Error(ex); } } - } } diff --git a/TimberWinR/Filters/GrokFilter.cs b/TimberWinR/Filters/GrokFilter.cs index 9d10820..7f88d22 100644 --- a/TimberWinR/Filters/GrokFilter.cs +++ b/TimberWinR/Filters/GrokFilter.cs @@ -47,6 +47,7 @@ namespace TimberWinR.Parser new JProperty("condition", Condition), new JProperty("addfields", AddField), new JProperty("addtags", AddTag), + new JProperty("drop", DropIfMatch), new JProperty("type", Type), new JProperty("removefields", RemoveField), new JProperty("removetag", RemoveTag) diff --git a/TimberWinR/Inputs/InputListener.cs b/TimberWinR/Inputs/InputListener.cs index 527c824..c89abff 100644 --- a/TimberWinR/Inputs/InputListener.cs +++ b/TimberWinR/Inputs/InputListener.cs @@ -1,5 +1,6 @@ using System.IO; using System.Runtime.InteropServices; +using Microsoft.Win32; using Newtonsoft.Json.Linq; using System; using System.Collections.Generic; @@ -18,7 +19,9 @@ namespace TimberWinR.Inputs private string _typeName; public AutoResetEvent FinishedEvent { get; set; } public string CheckpointFileName { get; set; } - + private object _locker = new object(); + public List Files { get; set; } + public string InputType { get { return _typeName; } @@ -28,6 +31,7 @@ namespace TimberWinR.Inputs public InputListener(CancellationToken token, string typeName) { + Files = new List(); CheckpointFileName = Path.Combine(System.IO.Path.GetTempPath(), string.Format("{0}.lpc", Guid.NewGuid().ToString())); this.FinishedEvent = new AutoResetEvent(false); @@ -40,6 +44,19 @@ namespace TimberWinR.Inputs .ToString(); } + public bool HaveSeenFile(string fileName) + { + return Files.Contains(fileName); + } + + protected void SaveVisitedFileName(string fileName) + { + lock (_locker) + { + if (!HaveSeenFile(fileName)) + Files.Add(fileName); + } + } protected string ToPrintable(string inputString) { string asAscii = Encoding.ASCII.GetString( @@ -58,17 +75,17 @@ namespace TimberWinR.Inputs public void Finished() { - LogManager.GetCurrentClassLogger().Info("Signaling Event Shutdown {0}", InputType); + LogManager.GetCurrentClassLogger().Info("{0}: Signalling Event Shutdown {1}", Thread.CurrentThread.ManagedThreadId, InputType); FinishedEvent.Set(); - LogManager.GetCurrentClassLogger().Info("Finished signaling Shutdown {0}", InputType); + LogManager.GetCurrentClassLogger().Info("{0}: Finished signalling Shutdown {1}", Thread.CurrentThread.ManagedThreadId, InputType); } + public virtual void Shutdown() { - LogManager.GetCurrentClassLogger().Info("Shutting Down {0}", InputType); + LogManager.GetCurrentClassLogger().Info("{0}: Shutting Down {1}", Thread.CurrentThread.ManagedThreadId, InputType); FinishedEvent.WaitOne(); - - LogManager.GetCurrentClassLogger().Info("Finished Wait For {0}", InputType); + try { if (File.Exists(CheckpointFileName)) @@ -80,6 +97,32 @@ namespace TimberWinR.Inputs } } + protected void EnsureRollingCaught() + { + try + { + const string mteKey = @"SYSTEM\CurrentControlSet\Control\FileSystem"; + + var mte = Microsoft.Win32.Registry.LocalMachine.OpenSubKey(mteKey).GetValue("MaximumTunnelEntries"); + if (mte == null || (int)mte != 0) + { + LogManager.GetCurrentClassLogger() + .Error( + "HKLM\\{0}\\MaximumTunnelEntries is not set to accurately detect log rolling, a DWORD value of 0 is required.", + mteKey); + Microsoft.Win32.Registry.LocalMachine.CreateSubKey(mteKey).SetValue("MaximumTunnelEntries", 0, RegistryValueKind.DWord); + LogManager.GetCurrentClassLogger() + .Error( + "HKLM\\{0}\\MaximumTunnelEntries is now set to 0, A reboot is now required to fix this issue. See http://support.microsoft.com/en-us/kb/172190 for details", + mteKey); + } + } + catch (Exception ex) + { + LogManager.GetCurrentClassLogger().Error(ex); + } + } + public virtual void AddDefaultFields(JObject json) { if (json["type"] == null) diff --git a/TimberWinR/Inputs/LogsFileDatabase.cs b/TimberWinR/Inputs/LogsFileDatabase.cs index 2010c4b..8fe5116 100644 --- a/TimberWinR/Inputs/LogsFileDatabase.cs +++ b/TimberWinR/Inputs/LogsFileDatabase.cs @@ -1,9 +1,12 @@ using System; using System.Collections.Generic; +using System.Diagnostics; using System.IO; using System.Linq; using System.Text; +using System.Threading; using Newtonsoft.Json; +using Newtonsoft.Json.Linq; using NLog; using TimberWinR.Parser; @@ -34,7 +37,10 @@ namespace TimberWinR.Inputs return ExistingFileTest(logName); } } - + + // + // Lookup the database entry for this log file, returns null if there isnt one. + // private LogsFileDatabaseEntry FindFile(string logName) { lock (_locker) @@ -43,6 +49,7 @@ namespace TimberWinR.Inputs return existingEntry; } } + private bool ExistingFileTest(string logName) { var existingEntry = (from e in Entries where e.FileName == logName select e).FirstOrDefault(); @@ -67,45 +74,82 @@ namespace TimberWinR.Inputs var de = new LogsFileDatabaseEntry(); lock (_locker) { - de.NewFile = true; - var fi = new FileInfo(logName); + var fi = new FileInfo(logName); de.FileName = logName; - de.Size = fi.Length; + de.LogFileExists = fi.Exists; + de.NewFile = true; + de.ProcessedFile = false; + de.LastPosition = fi.Length; de.SampleTime = DateTime.UtcNow; - de.CreationTimeUtc = fi.CreationTimeUtc; + de.CreationTimeUtc = fi.CreationTimeUtc; + Entries.Add(de); WriteDatabaseFileNoLock(); } return de; - } + } public static LogsFileDatabaseEntry LookupLogFile(string logName) { LogsFileDatabaseEntry dbe = Instance.FindFile(logName); if (dbe == null) dbe = Instance.AddFileEntry(logName); - else - dbe.NewFile = false; - + + FileInfo fi = new FileInfo(logName); + + dbe.LogFileExists = fi.Exists; + var creationTime = fi.CreationTimeUtc; + + if (dbe.LogFileExists && creationTime != dbe.CreationTimeUtc) + dbe.NewFile = true; + + dbe.CreationTimeUtc = creationTime; + return dbe; } - public static void Update(LogsFileDatabaseEntry dbe) + // Find all the non-existent entries and remove them. + private void PruneFiles() { - Instance.UpdateEntry(dbe); - } - - private void UpdateEntry(LogsFileDatabaseEntry dbe) - { - lock(_locker) + lock (_locker) { - var fi = new FileInfo(dbe.FileName); - dbe.CreationTimeUtc = fi.CreationTimeUtc; - dbe.SampleTime = DateTime.UtcNow; - dbe.Size = fi.Length; + foreach(var entry in Entries.ToList()) + { + FileInfo fi = new FileInfo(entry.FileName); + if (!fi.Exists) + Entries.Remove(entry); + } + WriteDatabaseFileNoLock(); + } + } + + public static void Update(LogsFileDatabaseEntry dbe, bool processedFile, long lastOffset) + { + dbe.ProcessedFile = processedFile; + dbe.LogFileExists = File.Exists(dbe.FileName); + Instance.UpdateEntry(dbe, lastOffset); + } + + public static void Roll(LogsFileDatabaseEntry dbe) + { + dbe.ProcessedFile = false; + dbe.LastPosition = 0; + Instance.UpdateEntry(dbe, 0); + dbe.NewFile = true; + } + + private void UpdateEntry(LogsFileDatabaseEntry dbe, long lastOffset) + { + lock (_locker) + { + var fi = new FileInfo(dbe.FileName); + dbe.NewFile = !fi.Exists; + dbe.CreationTimeUtc = fi.CreationTimeUtc; + dbe.SampleTime = DateTime.UtcNow; + dbe.LastPosition = lastOffset; + WriteDatabaseFileNoLock(); } - } public static LogsFileDatabase Instance { @@ -123,12 +167,19 @@ namespace TimberWinR.Inputs instance.ReadDatabaseNoLock(); else instance.WriteDatabaseFileNoLock(); + + if (instance.Entries == null) + instance.Entries = new List(); + + instance.PruneFiles(); } } return instance; } } + + // Serialize in the Database private void ReadDatabaseNoLock() { try @@ -152,7 +203,7 @@ namespace TimberWinR.Inputs catch (Exception ex2) { LogManager.GetCurrentClassLogger().Info("Error Creating New Database '{0}': {1}", DatabaseFileName, ex2.ToString()); - } + } } } private void WriteDatabaseFileNoLock() @@ -193,15 +244,30 @@ namespace TimberWinR.Inputs } + + // + // Represents a log file to be tailed + // public class LogsFileDatabaseEntry { [JsonIgnore] public bool NewFile { get; set; } - public string FileName { get; set; } - public Int64 MaxRecords { get; set; } + public bool ProcessedFile { get; set; } + public bool LogFileExists { get; set; } + public string FileName { get; set; } public DateTime CreationTimeUtc { get; set; } public DateTime SampleTime { get; set; } - public long Size { get; set; } + public long LastPosition { get; set; } + public long LinesProcessed + { + get { return _linesProcessed; } + } + + private int _linesProcessed; + public void IncrementLineCount() + { + Interlocked.Increment(ref _linesProcessed); + } } } diff --git a/TimberWinR/Inputs/LogsListener.cs b/TimberWinR/Inputs/LogsListener.cs index 35aba05..d1372f0 100644 --- a/TimberWinR/Inputs/LogsListener.cs +++ b/TimberWinR/Inputs/LogsListener.cs @@ -1,5 +1,6 @@ using System; using System.Collections.Generic; +using System.Diagnostics; using System.Linq; using System.Net.Configuration; using System.Runtime.InteropServices; @@ -9,6 +10,7 @@ using System.Threading; using System.Threading.Tasks; using System.IO; using Interop.MSUtil; +using Microsoft.Win32; using Newtonsoft.Json; using Newtonsoft.Json.Linq; using Newtonsoft.Json.Serialization; @@ -27,42 +29,45 @@ namespace TimberWinR.Inputs /// public class LogsListener : InputListener { + private object _locker = new object(); private int _pollingIntervalInSeconds; private TimberWinR.Parser.LogParameters _arguments; private long _receivedMessages; - private Dictionary _logFileMaxRecords; - private Dictionary _logFileCreationTimes; - private Dictionary _logFileSampleTimes; - private Dictionary _logFileSizes; - private CodecArguments _codecArguments; - private ICodec _codec; - + private CodecArguments _codecArguments; + private ICodec _codec; + public bool Stop { get; set; } + public bool IsWildcardFilePattern { get; set; } + public LogsListener(TimberWinR.Parser.LogParameters arguments, CancellationToken cancelToken) : base(cancelToken, "Win32-FileLog") { Stop = false; + + EnsureRollingCaught(); - _codecArguments = arguments.CodecArguments; + _codecArguments = arguments.CodecArguments; _codecArguments = arguments.CodecArguments; if (_codecArguments != null && _codecArguments.Type == CodecArguments.CodecType.multiline) _codec = new Multiline(_codecArguments); - _logFileMaxRecords = new Dictionary(); - _logFileCreationTimes = new Dictionary(); - _logFileSampleTimes = new Dictionary(); - _logFileSizes = new Dictionary(); - _receivedMessages = 0; _arguments = arguments; _pollingIntervalInSeconds = arguments.Interval; + IsWildcardFilePattern = arguments.Location.Contains('*'); + foreach (string srcFile in _arguments.Location.Split(',')) { string file = srcFile.Trim(); - Task.Factory.StartNew(() => FileWatcher(file)); + string dir = Path.GetDirectoryName(file); + if (string.IsNullOrEmpty(dir)) + dir = Environment.CurrentDirectory; + string fileSpec = Path.Combine(dir, file); + + Task.Factory.StartNew(() => FileWatcher(fileSpec)); } } @@ -73,9 +78,9 @@ namespace TimberWinR.Inputs base.Shutdown(); } + public override JObject ToJson() { - JObject json = new JObject( new JProperty("log", new JObject( @@ -86,21 +91,11 @@ namespace TimberWinR.Inputs new JProperty("codepage", _arguments.CodePage), new JProperty("splitLongLines", _arguments.SplitLongLines), new JProperty("recurse", _arguments.Recurse), - + new JProperty("filedb", + new JArray(from f in Files.ToList() + select JObject.FromObject(LogsFileDatabase.LookupLogFile(f)))), new JProperty("files", - new JArray(from f in _logFileMaxRecords.Keys - select new JValue(f))), - new JProperty("fileSampleTimes", - new JArray(from f in _logFileSampleTimes.Values - select new JValue(f))), - new JProperty("fileSizes", - new JArray(from f in _logFileSizes.Values - select new JValue(f))), - new JProperty("fileIndices", - new JArray(from f in _logFileMaxRecords.Values - select new JValue(f))), - new JProperty("fileCreationDates", - new JArray(from f in _logFileCreationTimes.Values + new JArray(from f in Files.ToList() select new JValue(f))) ))); @@ -120,7 +115,7 @@ namespace TimberWinR.Inputs return json; - } + } private void FileWatcher(string fileToWatch) { @@ -149,46 +144,34 @@ namespace TimberWinR.Inputs { var record = rsfiles.getRecord(); string logName = record.getValue("LogFilename") as string; - FileInfo fi = new FileInfo(logName); + FileInfo fi = new FileInfo(logName); - if (!fi.Exists) - { - _logFileCreationTimes.Remove(logName); - _logFileMaxRecords.Remove(logName); - _logFileSizes.Remove(logName); - } - - _logFileSampleTimes[logName] = DateTime.UtcNow; + var dbe = LogsFileDatabase.LookupLogFile(logName); + + SaveVisitedFileName(dbe.FileName); DateTime creationTime = fi.CreationTimeUtc; - bool logHasRolled = (_logFileCreationTimes.ContainsKey(logName) && - creationTime > _logFileCreationTimes[logName]) || - (_logFileSizes.ContainsKey(logName) && - fi.Length < _logFileSizes[logName]); + bool logHasRolled = dbe.NewFile || (creationTime != dbe.CreationTimeUtc || fi.Length < dbe.LastPosition); - - if (!_logFileMaxRecords.ContainsKey(logName) || logHasRolled) + if (logHasRolled) { - _logFileCreationTimes[logName] = creationTime; - _logFileSizes[logName] = fi.Length; - var qcount = string.Format("SELECT max(Index) as MaxRecordNumber FROM {0}", logName); - var rcount = oLogQuery.Execute(qcount, iFmt); - var qr = rcount.getRecord(); - var lrn = (Int64)qr.getValueEx("MaxRecordNumber"); - if (logHasRolled) - { - LogManager.GetCurrentClassLogger().Info("Log {0} has rolled", logName); - lrn = 0; - } - _logFileMaxRecords[logName] = lrn; + LogManager.GetCurrentClassLogger().Info("Log {0} has rolled", logName); + LogsFileDatabase.Roll(dbe); } - _logFileSizes[logName] = fi.Length; + // Log has rolled or this is a new file, or we haven't processed yet. + bool processWholeFile = logHasRolled || !dbe.ProcessedFile; + + if (processWholeFile) + LogsFileDatabase.Update(dbe, true, 0); + } rsfiles.close(); - foreach (string fileName in _logFileMaxRecords.Keys.ToList()) + foreach (string fileName in Files.ToList()) { - var lastRecordNumber = _logFileMaxRecords[fileName]; + var dbe = LogsFileDatabase.LookupLogFile(fileName); + + var lastRecordNumber = dbe.LastPosition; var query = string.Format("SELECT * FROM {0} where Index > {1}", fileName, lastRecordNumber); @@ -231,21 +214,22 @@ namespace TimberWinR.Inputs string msg = json["Text"].ToString(); if (!string.IsNullOrEmpty(msg)) { - if (_codecArguments != null && - _codecArguments.Type == CodecArguments.CodecType.multiline) + if (_codecArguments != null && _codecArguments.Type == CodecArguments.CodecType.multiline) { _codec.Apply(msg, this); _receivedMessages++; + dbe.IncrementLineCount(); } else { ProcessJson(json); - _receivedMessages++; + dbe.IncrementLineCount(); + _receivedMessages++; } } var lrn = (Int64)record.getValueEx("Index"); - _logFileMaxRecords[fileName] = lrn; + LogsFileDatabase.Update(dbe, true, lrn); GC.Collect(); } @@ -254,16 +238,18 @@ namespace TimberWinR.Inputs rs.close(); rs = null; GC.Collect(); + } } catch (FileNotFoundException fnfex) { string fn = fnfex.FileName; - if (!_fnfmap.ContainsKey(fn)) + if (!string.IsNullOrEmpty(fn) && !_fnfmap.ContainsKey(fn)) + { LogManager.GetCurrentClassLogger().Warn(fnfex.Message); - - _fnfmap[fn] = fn; + _fnfmap[fn] = fn; + } } catch (OperationCanceledException) { @@ -283,7 +269,7 @@ namespace TimberWinR.Inputs syncHandle.Wait(TimeSpan.FromSeconds(_pollingIntervalInSeconds), CancelToken); } catch (OperationCanceledException) - { + { } catch (Exception ex1) { diff --git a/TimberWinR/Inputs/StdinListener.cs b/TimberWinR/Inputs/StdinListener.cs index c94798f..d54799b 100644 --- a/TimberWinR/Inputs/StdinListener.cs +++ b/TimberWinR/Inputs/StdinListener.cs @@ -2,6 +2,7 @@ using System.Collections.Generic; using System.Diagnostics; using System.Linq; +using System.Runtime.InteropServices; using System.Text; using System.Text.RegularExpressions; using System.Threading; @@ -15,10 +16,15 @@ namespace TimberWinR.Inputs { public class StdinListener : InputListener { + [DllImport("User32.Dll", EntryPoint = "PostMessageA")] + private static extern bool PostMessage(IntPtr hWnd, uint msg, int wParam, int lParam); + private Thread _listenThread; private CodecArguments _codecArguments; - private ICodec _codec; - + private ICodec _codec; + const int VK_RETURN = 0x0D; + const int WM_KEYDOWN = 0x100; + public StdinListener(TimberWinR.Parser.Stdin arguments, CancellationToken cancelToken) : base(cancelToken, "Win32-Console") { @@ -54,7 +60,14 @@ namespace TimberWinR.Inputs public override void Shutdown() { - LogManager.GetCurrentClassLogger().Info("Shutting Down {0}", InputType); + LogManager.GetCurrentClassLogger().Info("Shutting Down {0}", InputType); + // This must come from another thread. + ThreadPool.QueueUserWorkItem((o) => + { + Thread.Sleep(100); + var hWnd = System.Diagnostics.Process.GetCurrentProcess().MainWindowHandle; + PostMessage(hWnd, WM_KEYDOWN, VK_RETURN, 0); + }); base.Shutdown(); } diff --git a/TimberWinR/Inputs/TailFileListener.cs b/TimberWinR/Inputs/TailFileListener.cs index dc49418..e4390a8 100644 --- a/TimberWinR/Inputs/TailFileListener.cs +++ b/TimberWinR/Inputs/TailFileListener.cs @@ -26,33 +26,27 @@ namespace TimberWinR.Inputs /// public class TailFileListener : InputListener { + private object _locker = new object(); private int _pollingIntervalInSeconds; - private TimberWinR.Parser.TailFile _arguments; + private TimberWinR.Parser.TailFileArguments _arguments; private long _receivedMessages; - private Dictionary _logFileMaxRecords; - private Dictionary _logFileCreationTimes; - private Dictionary _logFileSampleTimes; - private Dictionary _logFileSizes; - private CodecArguments _codecArguments; - private ICodec _codec; + private CodecArguments _codecArguments; + private ICodec _codec; + public bool Stop { get; set; } - public TailFileListener(TimberWinR.Parser.TailFile arguments, CancellationToken cancelToken) + public TailFileListener(TimberWinR.Parser.TailFileArguments arguments, CancellationToken cancelToken) : base(cancelToken, "Win32-TailLog") { Stop = false; + + EnsureRollingCaught(); _codecArguments = arguments.CodecArguments; if (_codecArguments != null && _codecArguments.Type == CodecArguments.CodecType.multiline) _codec = new Multiline(_codecArguments); - - _logFileMaxRecords = new Dictionary(); - _logFileCreationTimes = new Dictionary(); - _logFileSampleTimes = new Dictionary(); - _logFileSizes = new Dictionary(); - _receivedMessages = 0; _arguments = arguments; _pollingIntervalInSeconds = arguments.Interval; @@ -66,7 +60,7 @@ namespace TimberWinR.Inputs public override void Shutdown() { - LogManager.GetCurrentClassLogger().Info("Shutting Down {0}", InputType); + LogManager.GetCurrentClassLogger().Info("{0}: Shutting Down {1} for {2}", Thread.CurrentThread.ManagedThreadId, InputType, _arguments.Location); Stop = true; base.Shutdown(); } @@ -74,29 +68,19 @@ namespace TimberWinR.Inputs public override JObject ToJson() { JObject json = new JObject( - new JProperty("log", + new JProperty("taillog", new JObject( new JProperty("messages", _receivedMessages), new JProperty("type", InputType), new JProperty("location", _arguments.Location), new JProperty("logSource", _arguments.LogSource), new JProperty("recurse", _arguments.Recurse), - new JProperty("files", - new JArray(from f in _logFileMaxRecords.Keys + new JArray(from f in Files select new JValue(f))), - new JProperty("fileSampleTimes", - new JArray(from f in _logFileSampleTimes.Values - select new JValue(f))), - new JProperty("fileSizes", - new JArray(from f in _logFileSizes.Values - select new JValue(f))), - new JProperty("fileIndices", - new JArray(from f in _logFileMaxRecords.Values - select new JValue(f))), - new JProperty("fileCreationDates", - new JArray(from f in _logFileCreationTimes.Values - select new JValue(f))) + new JProperty("filedb", + new JArray(from f in Files + select JObject.FromObject(LogsFileDatabase.LookupLogFile(f)))) ))); @@ -117,10 +101,9 @@ namespace TimberWinR.Inputs return json; } - private void TailFileContents(string fileName, long offset) + private void TailFileContents(string fileName, long offset, LogsFileDatabaseEntry dbe) { - using (StreamReader reader = new StreamReader(new FileStream(fileName, - FileMode.Open, FileAccess.Read, FileShare.ReadWrite))) + using (StreamReader reader = new StreamReader(new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))) { //start at the end of the file long lastMaxOffset = offset; @@ -130,6 +113,8 @@ namespace TimberWinR.Inputs return; //seek to the last max offset + LogManager.GetCurrentClassLogger().Trace("{0}: File: {1} Seek to: {2}", Thread.CurrentThread.ManagedThreadId, fileName, lastMaxOffset); + reader.BaseStream.Seek(lastMaxOffset, SeekOrigin.Begin); //read out of the file until the EOF @@ -152,24 +137,31 @@ namespace TimberWinR.Inputs else json.Add(new JProperty("logSource", _arguments.LogSource)); } + json["Text"] = line; json["Index"] = index; json["LogFileName"] = fileName; + if (_codecArguments != null && _codecArguments.Type == CodecArguments.CodecType.multiline) { _codec.Apply(line, this); Interlocked.Increment(ref _receivedMessages); + dbe.IncrementLineCount(); } else { ProcessJson(json); Interlocked.Increment(ref _receivedMessages); - } - lineOffset += line.Length; + dbe.IncrementLineCount(); + //LogManager.GetCurrentClassLogger().Info("{0}: File: {1} {2} {3}", Thread.CurrentThread.ManagedThreadId, fileName, dbe.LinesProcessed, line); + } + + lineOffset += line.Length; } //update the last max offset lastMaxOffset = reader.BaseStream.Position; + LogsFileDatabase.Update(dbe, true, lastMaxOffset); } } // One thread for each kind of file to watch, i.e. "*.log,*.txt" would be two separate @@ -187,11 +179,14 @@ namespace TimberWinR.Inputs { if (!CancelToken.IsCancellationRequested) { + var isWildcardPattern = fileToWatch.Contains('*'); string path = Path.GetDirectoryName(fileToWatch); string name = Path.GetFileName(fileToWatch); if (string.IsNullOrEmpty(path)) path = "."; + LogManager.GetCurrentClassLogger().Trace(":{0} Tailing File: {1}", Thread.CurrentThread.ManagedThreadId, Path.Combine(path, name)); + // Ok, we have a potential file filter here as 'fileToWatch' could be foo.log or *.log SearchOption so = SearchOption.TopDirectoryOnly; @@ -201,26 +196,41 @@ namespace TimberWinR.Inputs foreach (string fileName in Directory.GetFiles(path, name, so)) { var dbe = LogsFileDatabase.LookupLogFile(fileName); - FileInfo fi = new FileInfo(dbe.FileName); - //LogManager.GetCurrentClassLogger().Info("Located File: {0}, New: {1}", dbe.FileName, dbe.NewFile); - long length = fi.Length; - bool logHasRolled = false; - if (fi.Length < dbe.Size || fi.CreationTimeUtc != dbe.CreationTimeUtc) + + // We only spin up 1 thread for a file we haven't yet seen. + if (isWildcardPattern && !HaveSeenFile(fileName) && dbe.NewFile) { - LogManager.GetCurrentClassLogger().Info("Log has Rolled: {0}", dbe.FileName); - logHasRolled = true; + LogManager.GetCurrentClassLogger().Debug(":{0} Starting Thread Tailing File: {1}", Thread.CurrentThread.ManagedThreadId, dbe.FileName); + LogsFileDatabase.Update(dbe, false, dbe.LastPosition); + SaveVisitedFileName(fileName); + Task.Factory.StartNew(() => TailFileWatcher(fileName)); } - bool processWholeFile = logHasRolled || dbe.NewFile; - if (processWholeFile) + else if (!isWildcardPattern) { - LogManager.GetCurrentClassLogger().Info("Process Whole File: {0}", dbe.FileName); - TailFileContents(dbe.FileName, 0); + FileInfo fi = new FileInfo(dbe.FileName); + + //LogManager.GetCurrentClassLogger().Info("Located File: {0}, New: {1}", dbe.FileName, dbe.NewFile); + long length = fi.Length; + bool logHasRolled = false; + if (fi.Length < dbe.LastPosition || fi.CreationTimeUtc != dbe.CreationTimeUtc) + { + LogManager.GetCurrentClassLogger().Info("{0}: Log has Rolled: {1}", Thread.CurrentThread.ManagedThreadId, dbe.FileName); + logHasRolled = true; + LogsFileDatabase.Roll(dbe); + } + // Log has rolled or this is a file we are seeing for the first time. + bool processWholeFile = logHasRolled || !dbe.ProcessedFile; + if (processWholeFile) + { + LogsFileDatabase.Update(dbe, true, 0); + LogManager.GetCurrentClassLogger().Debug("{0}: Process Whole File: {1}", Thread.CurrentThread.ManagedThreadId, dbe.FileName); + TailFileContents(dbe.FileName, 0, dbe); + } + else + { + TailFileContents(dbe.FileName, dbe.LastPosition, dbe); + } } - else - { - TailFileContents(dbe.FileName, dbe.Size); - } - LogsFileDatabase.Update(dbe); } } } @@ -232,6 +242,10 @@ namespace TimberWinR.Inputs LogManager.GetCurrentClassLogger().Warn(fnfex.Message); _fnfmap[fn] = fn; } + catch (IOException ioex) + { + LogManager.GetCurrentClassLogger().Debug("Log has rolled: {0}", ioex.Message); + } catch (OperationCanceledException) { break; @@ -249,16 +263,17 @@ namespace TimberWinR.Inputs } catch (OperationCanceledException) { + Stop = true; } catch (Exception ex1) { LogManager.GetCurrentClassLogger().Warn(ex1); - } + } } } } Finished(); - } + } } } diff --git a/TimberWinR/Inputs/TcpInputListener.cs b/TimberWinR/Inputs/TcpInputListener.cs index dd5e0e2..64db158 100644 --- a/TimberWinR/Inputs/TcpInputListener.cs +++ b/TimberWinR/Inputs/TcpInputListener.cs @@ -52,7 +52,7 @@ namespace TimberWinR.Inputs public override void Shutdown() { - LogManager.GetCurrentClassLogger().Info("Shutting Down {0}", InputType); + LogManager.GetCurrentClassLogger().Info("{0}: Shutting Down {1}", Thread.CurrentThread.ManagedThreadId, InputType); this._tcpListenerV4.Stop(); this._tcpListenerV6.Stop(); diff --git a/TimberWinR/Inputs/UdpInputListener.cs b/TimberWinR/Inputs/UdpInputListener.cs index fcff71d..615611c 100644 --- a/TimberWinR/Inputs/UdpInputListener.cs +++ b/TimberWinR/Inputs/UdpInputListener.cs @@ -1,6 +1,7 @@ using System; using System.IO; using System.Text; +using System.Text.RegularExpressions; using System.Threading; using System.Net; using System.Net.Sockets; @@ -11,24 +12,14 @@ using NLog; namespace TimberWinR.Inputs { public class UdpInputListener : InputListener - { - private readonly System.Net.Sockets.UdpClient _udpListener; - private readonly IPEndPoint groupV4; - private readonly IPEndPoint groupV6; - - private Thread _listenThreadV4; - private Thread _listenThreadV6; + { + private UdpClient _udpListenerV6; + private readonly Thread _listenThreadV6; private readonly int _port; private long _receivedMessages; private long _parsedErrors; - - private struct listenProfile - { - public IPEndPoint endPoint; - public UdpClient client; - } - + public override JObject ToJson() { JObject json = new JObject( @@ -46,36 +37,47 @@ namespace TimberWinR.Inputs : base(cancelToken, "Win32-Udp") { _port = port; - - groupV4 = new IPEndPoint(IPAddress.Any, 0); - groupV6 = new IPEndPoint(IPAddress.IPv6Any, 0); - + LogManager.GetCurrentClassLogger().Info("Udp Input on Port {0} Ready", _port); _receivedMessages = 0; - _udpListener = new System.Net.Sockets.UdpClient(port); - - _listenThreadV4 = new Thread(new ParameterizedThreadStart(StartListener)); - _listenThreadV4.Start(new listenProfile() { endPoint = groupV4, client = _udpListener }); - - _listenThreadV6 = new Thread(new ParameterizedThreadStart(StartListener)); - _listenThreadV6.Start(new listenProfile() { endPoint = groupV6, client = _udpListener }); + _listenThreadV6 = new Thread(StartListener); + _listenThreadV6.Start(); } public override void Shutdown() { LogManager.GetCurrentClassLogger().Info("Shutting Down {0}", InputType); - _udpListener.Close(); + + // close UDP listeners, which will end the listener threads + _udpListenerV6.Close(); + + // wait for completion of the threads + _listenThreadV6.Join(); + Finished(); + base.Shutdown(); } + private void StartListener() + { + var groupV6 = new IPEndPoint(IPAddress.IPv6Any, _port); + // Create the socket as IPv6 + var dualModeSocket = new Socket(AddressFamily.InterNetworkV6, SocketType.Dgram, ProtocolType.Udp); + + // + // Now, disable the IPV6only flag to make it compatable with both ipv4 and ipv6 + // See: http://blogs.msdn.com/b/malarch/archive/2005/11/18/494769.aspx + // + dualModeSocket.SetSocketOption(SocketOptionLevel.IPv6, SocketOptionName.IPv6Only, 0); + dualModeSocket.Bind(groupV6); + + _udpListenerV6 = new UdpClient(); + _udpListenerV6.Client = dualModeSocket; - private void StartListener(object useProfile) - { - var profile = (listenProfile)useProfile; string lastMessage = ""; try { @@ -83,21 +85,25 @@ namespace TimberWinR.Inputs { try { - byte[] bytes = profile.client.Receive(ref profile.endPoint); - var data = Encoding.UTF8.GetString(bytes, 0, bytes.Length); + byte[] bytes = _udpListenerV6.Receive(ref groupV6); + var data = Encoding.UTF8.GetString(bytes, 0, bytes.Length); lastMessage = data; - JObject json = JObject.Parse(data); + var json = JObject.Parse(data); ProcessJson(json); - _receivedMessages++; + Interlocked.Increment(ref _receivedMessages); } - catch (Exception ex1) + catch(SocketException) + { + break; + } + catch (Exception ex) { LogManager.GetCurrentClassLogger().Warn("Bad JSON: {0}", lastMessage); - LogManager.GetCurrentClassLogger().Warn(ex1); - _parsedErrors++; + LogManager.GetCurrentClassLogger().Warn(ex); + Interlocked.Increment(ref _parsedErrors); } } - _udpListener.Close(); + _udpListenerV6.Close(); } catch (Exception ex) { diff --git a/TimberWinR/Manager.cs b/TimberWinR/Manager.cs index d8dd550..3417691 100644 --- a/TimberWinR/Manager.cs +++ b/TimberWinR/Manager.cs @@ -28,6 +28,8 @@ namespace TimberWinR public List Listeners { get; set; } public bool LiveMonitor { get; set; } + public event Action OnConfigurationProcessed; + public DateTime StartedOn { get; set; } public string JsonConfig { get; set; } public string LogfileDir { get; set; } @@ -67,7 +69,7 @@ namespace TimberWinR LogsFileDatabase.Manager = this; } - public Manager(string jsonConfigFile, string logLevel, string logfileDir, bool liveMonitor, CancellationToken cancelToken) + public Manager(string jsonConfigFile, string logLevel, string logfileDir, bool liveMonitor, CancellationToken cancelToken, bool processConfiguration = true) { LogsFileDatabase.Manager = this; @@ -106,12 +108,14 @@ namespace TimberWinR LogManager.GlobalThreshold = LogLevel.FromString(logLevel); - LogManager.GetCurrentClassLogger() - .Info("TimberWinR Version {0}", GetAssemblyByName("TimberWinR.ServiceHost").GetName().Version.ToString()); - + //LogManager.GetCurrentClassLogger() + // .Info("TimberWinR Version {0}", GetAssemblyByName("TimberWinR.ServiceHost").GetName().Version.ToString()); LogManager.GetCurrentClassLogger() - .Info("Database Directory: {0}", LogsFileDatabase.Instance.DatabaseFileName); + .Info("TimberWinR Version {0}", Assembly.GetEntryAssembly().GetName().Version.ToString()); + + LogManager.GetCurrentClassLogger() + .Info("Database Filename: {0}", LogsFileDatabase.Instance.DatabaseFileName); try { @@ -146,7 +150,16 @@ namespace TimberWinR LogManager.GetCurrentClassLogger().Info("Log Directory {0}", logfileDir); LogManager.GetCurrentClassLogger().Info("Logging Level: {0}", LogManager.GlobalThreshold); - ProcessConfiguration(cancelToken, Config); + if (processConfiguration) + { + ProcessConfiguration(cancelToken, Config); + Start(cancelToken); + } + } + + public void Start(CancellationToken cancelToken) + { + ProcessConfiguration(cancelToken, Config); } public void ProcessConfiguration(CancellationToken cancelToken, Configuration config) @@ -154,6 +167,9 @@ namespace TimberWinR // Read the Configuration file if (config != null) { + if (OnConfigurationProcessed != null) + OnConfigurationProcessed(config); + if (config.RedisOutputs != null) { foreach (var ro in config.RedisOutputs) @@ -256,7 +272,8 @@ namespace TimberWinR new JProperty("TimberWinR", new JObject( new JProperty("version", - GetAssemblyByName("TimberWinR.ServiceHost").GetName().Version.ToString()), + Assembly.GetEntryAssembly().GetName().Version.ToString()), + //GetAssemblyByName("TimberWinR.ServiceHost").GetName().Version.ToString()), new JProperty("host", computerName), new JProperty("output", output.Name), new JProperty("initialized", DateTime.UtcNow) @@ -264,7 +281,7 @@ namespace TimberWinR json.Add(new JProperty("type", "Win32-TimberWinR")); json.Add(new JProperty("host", computerName)); output.Startup(json); - } + } } } diff --git a/TimberWinR/Outputs/Elasticsearch.cs b/TimberWinR/Outputs/Elasticsearch.cs index 9dae391..2b21880 100644 --- a/TimberWinR/Outputs/Elasticsearch.cs +++ b/TimberWinR/Outputs/Elasticsearch.cs @@ -268,7 +268,7 @@ namespace TimberWinR.Outputs ApplyFilters(jsonMessage); var message = jsonMessage.ToString(); - LogManager.GetCurrentClassLogger().Debug(message); + LogManager.GetCurrentClassLogger().Trace(message); lock (_locker) { diff --git a/TimberWinR/Outputs/Redis.cs b/TimberWinR/Outputs/Redis.cs index e192083..f0d21e3 100644 --- a/TimberWinR/Outputs/Redis.cs +++ b/TimberWinR/Outputs/Redis.cs @@ -28,7 +28,7 @@ namespace TimberWinR.Outputs private const int QUEUE_SAMPLE_SIZE = 30; // 30 samples over 2.5 minutes (default) private object _locker = new object(); private bool _warnedReachedMax; - + private readonly int _maxBatchCount; private readonly int _batchCount; private int _totalSamples; @@ -53,7 +53,7 @@ namespace TimberWinR.Outputs { if (_totalSamples < QUEUE_SAMPLE_SIZE) _totalSamples++; - + // Take a sample of the queue depth if (_sampleCountIndex >= QUEUE_SAMPLE_SIZE) _sampleCountIndex = 0; @@ -69,7 +69,7 @@ namespace TimberWinR.Outputs if (_totalSamples > 0) { var samples = _sampleQueueDepths.Take(_totalSamples); - int avg = (int) samples.Average(); + int avg = (int)samples.Average(); return avg; } return 0; @@ -81,7 +81,7 @@ namespace TimberWinR.Outputs { if (currentBatchCount < _maxBatchCount && currentBatchCount < queueSize && AverageQueueDepth() > currentBatchCount) { - currentBatchCount += Math.Max(_maxBatchCount/_batchCount, 1); + currentBatchCount += Math.Max(_maxBatchCount / _batchCount, 1); if (currentBatchCount >= _maxBatchCount && !_warnedReachedMax) { LogManager.GetCurrentClassLogger().Warn("Maximum Batch Count of {0} reached.", currentBatchCount); @@ -93,7 +93,7 @@ namespace TimberWinR.Outputs else // Reset to default { currentBatchCount = _batchCount; - _warnedReachedMax = false; + _warnedReachedMax = false; } return currentBatchCount; @@ -117,21 +117,21 @@ namespace TimberWinR.Outputs private readonly int _port; private readonly int _timeout; private readonly object _locker = new object(); - private readonly List _jsonQueue; + private readonly List _jsonQueue; private readonly string[] _redisHosts; private int _redisHostIndex; private TimberWinR.Manager _manager; private readonly int _batchCount; private int _currentBatchCount; - private readonly int _maxBatchCount; + private readonly int _maxBatchCount; private readonly int _interval; - private readonly int _numThreads; + private readonly int _numThreads; private long _sentMessages; private long _errorCount; private long _redisDepth; - private DateTime? _lastErrorTimeUTC; + private DateTime? _lastErrorTimeUTC; private readonly int _maxQueueSize; - private readonly bool _queueOverflowDiscardOldest; + private readonly bool _queueOverflowDiscardOldest; private BatchCounter _batchCounter; public bool Stop { get; set; } @@ -186,9 +186,9 @@ namespace TimberWinR.Outputs new JProperty("threads", _numThreads), new JProperty("batchcount", _batchCount), new JProperty("currentBatchCount", _currentBatchCount), - new JProperty("reachedMaxBatchCountTimes", _batchCounter.ReachedMaxBatchCountTimes), + new JProperty("reachedMaxBatchCountTimes", _batchCounter.ReachedMaxBatchCountTimes), new JProperty("maxBatchCount", _maxBatchCount), - new JProperty("averageQueueDepth", _batchCounter.AverageQueueDepth()), + new JProperty("averageQueueDepth", _batchCounter.AverageQueueDepth()), new JProperty("queueSamples", new JArray(_batchCounter.Samples())), new JProperty("index", _logstashIndexName), new JProperty("hosts", @@ -201,17 +201,17 @@ namespace TimberWinR.Outputs public RedisOutput(TimberWinR.Manager manager, Parser.RedisOutputParameters parameters, CancellationToken cancelToken) : base(cancelToken, "Redis") - { + { _redisDepth = 0; _batchCount = parameters.BatchCount; _maxBatchCount = parameters.MaxBatchCount; // Make sure maxBatchCount is larger than batchCount - if (_maxBatchCount < _batchCount) - _maxBatchCount = _batchCount*10; - + if (_maxBatchCount <= _batchCount) + _maxBatchCount = _batchCount * 10; + _manager = manager; _redisHostIndex = 0; - _redisHosts = parameters.Host; + _redisHosts = parameters.Host; _jsonQueue = new List(); _port = parameters.Port; _timeout = parameters.Timeout; @@ -224,7 +224,7 @@ namespace TimberWinR.Outputs _queueOverflowDiscardOldest = parameters.QueueOverflowDiscardOldest; _batchCounter = new BatchCounter(_batchCount, _maxBatchCount); _currentBatchCount = _batchCount; - + for (int i = 0; i < parameters.NumThreads; i++) { var redisThread = new Task(RedisSender, cancelToken); @@ -250,7 +250,7 @@ namespace TimberWinR.Outputs } var message = jsonMessage.ToString(); - LogManager.GetCurrentClassLogger().Debug(message); + LogManager.GetCurrentClassLogger().Trace(message); lock (_locker) { @@ -285,13 +285,13 @@ namespace TimberWinR.Outputs foreach (var filter in _manager.Config.Filters) { if (!filter.Apply(json)) - { - LogManager.GetCurrentClassLogger().Debug("Dropping: {0}", json.ToString()); + { + LogManager.GetCurrentClassLogger().Debug("{0}: Dropping: {1}", Thread.CurrentThread.ManagedThreadId, json.ToString()); drop = true; - } + } } return drop; - } + } // // Pull off messages from the Queue, batch them up and send them all across // @@ -313,11 +313,9 @@ namespace TimberWinR.Outputs _batchCounter.SampleQueueDepth(_jsonQueue.Count); // Re-compute current batch size _currentBatchCount = _batchCounter.UpdateCurrentBatchCount(_jsonQueue.Count, _currentBatchCount); - + messages = _jsonQueue.Take(_currentBatchCount).ToArray(); _jsonQueue.RemoveRange(0, messages.Length); - - } if (messages.Length > 0) @@ -335,12 +333,12 @@ namespace TimberWinR.Outputs { client.StartPipe(); LogManager.GetCurrentClassLogger() - .Debug("Sending {0} Messages to {1}", messages.Length, client.Host); + .Debug("{0}: Sending {1} Messages to {2}", Thread.CurrentThread.ManagedThreadId, messages.Length, client.Host); try { _redisDepth = client.RPush(_logstashIndexName, messages); - _sentMessages += messages.Length; + Interlocked.Add(ref _sentMessages, messages.Length); client.EndPipe(); sentSuccessfully = true; if (messages.Length > 0) @@ -357,7 +355,7 @@ namespace TimberWinR.Outputs LogManager.GetCurrentClassLogger().Error(ex); Interlocked.Increment(ref _errorCount); _lastErrorTimeUTC = DateTime.UtcNow; - } + } break; } else @@ -374,20 +372,19 @@ namespace TimberWinR.Outputs { LogManager.GetCurrentClassLogger().Error(ex); Interlocked.Increment(ref _errorCount); - _lastErrorTimeUTC = DateTime.UtcNow; + _lastErrorTimeUTC = DateTime.UtcNow; } } // No more hosts to try. - - if (!sentSuccessfully) + // Couldn't send, put it back into the queue. + if (!sentSuccessfully) { lock (_locker) { _jsonQueue.InsertRange(0, messages); } } - } - // GC.Collect(); + } if (!Stop) syncHandle.Wait(TimeSpan.FromMilliseconds(_interval), CancelToken); } @@ -395,7 +392,7 @@ namespace TimberWinR.Outputs { break; } - catch(ThreadAbortException) + catch (ThreadAbortException) { break; } @@ -403,11 +400,11 @@ namespace TimberWinR.Outputs { _lastErrorTimeUTC = DateTime.UtcNow; Interlocked.Increment(ref _errorCount); - LogManager.GetCurrentClassLogger().Error(ex); + LogManager.GetCurrentClassLogger().Error(ex); } } } } - } + } } } diff --git a/TimberWinR/Parser.cs b/TimberWinR/Parser.cs index 3eb03ac..9fd69f1 100644 --- a/TimberWinR/Parser.cs +++ b/TimberWinR/Parser.cs @@ -297,7 +297,7 @@ namespace TimberWinR.Parser } } - public class TailFile : IValidateSchema + public class TailFileArguments : IValidateSchema { [JsonProperty(PropertyName = "location")] public string Location { get; set; } @@ -312,7 +312,7 @@ namespace TimberWinR.Parser [JsonProperty(PropertyName = "codec")] public CodecArguments CodecArguments { get; set; } - public TailFile() + public TailFileArguments() { Fields = new List(); Fields.Add(new Field("LogFilename", "string")); @@ -605,7 +605,7 @@ namespace TimberWinR.Parser Index = "logstash"; Host = new string[] { "localhost" }; Timeout = 10000; - BatchCount = 10; + BatchCount = 50; MaxBatchCount = BatchCount*10; NumThreads = 1; Interval = 5000; @@ -646,7 +646,7 @@ namespace TimberWinR.Parser public LogParameters[] Logs { get; set; } [JsonProperty("TailFiles")] - public TailFile[] TailFiles { get; set; } + public TailFileArguments[] TailFilesArguments { get; set; } [JsonProperty("Tcp")] public TcpParameters[] Tcps { get; set; } diff --git a/TimberWinR/ReleaseNotes.md b/TimberWinR/ReleaseNotes.md index b7c76f4..be90ac6 100644 --- a/TimberWinR/ReleaseNotes.md +++ b/TimberWinR/ReleaseNotes.md @@ -2,7 +2,16 @@ ================================== A Native Windows to Redis/Elasticsearch Logstash Agent which runs as a service. -Version History +Version / Date + +### 1.4.0.0 - 04/03/2015 +1. A re-factoring of Logs and TailLogs to be more efficient and detect log rolling correctly, + this requires http://support.microsoft.com/en-us/kb/172190 which will be detected and + set by TimberWinR, however, requires a reboot. +2. Fixed issue [#38](https://github.com/Cimpress-MCP/TimberWinR/issues/38) diagnostic output not showing drop flag for Grok filter. +3. Created TimberWinR.TestGenerator for complete testing of TimberWinR +4. Fixed ipv4/ipv6 thread-safe issue with UdpInputListener which might lead to corrupted input data. + ### 1.3.19.1 - 03/03/2015 1. Added new Redis parameter _max\_batch\_count_ which increases the _batch\_count_ dynamically over time to handle input flooding. Default is _batch\_count_ * 10 diff --git a/TimberWinR/TimberWinR.csproj b/TimberWinR/TimberWinR.csproj index eef68f3..4ad3c76 100644 --- a/TimberWinR/TimberWinR.csproj +++ b/TimberWinR/TimberWinR.csproj @@ -32,10 +32,12 @@ - ..\packages\csredis.1.4.7.1\lib\net40\csredis.dll + ..\packages\csredis.3.2.1\lib\net40\csredis.dll + True - ..\packages\Elasticsearch.Net.1.3.1\lib\Elasticsearch.Net.dll + ..\packages\Elasticsearch.Net.1.4.2\lib\Elasticsearch.Net.dll + True False @@ -43,33 +45,35 @@ lib\com-logparser\Interop.MSUtil.dll - ..\packages\MaxMind.Db.0.2.3.0\lib\net40\MaxMind.Db.dll + ..\packages\MaxMind.Db.1.0.0.0\lib\net40\MaxMind.Db.dll True - ..\packages\MaxMind.GeoIP2.0.4.0.0\lib\net40\MaxMind.GeoIP2.dll + ..\packages\MaxMind.GeoIP2.2.1.0.0\lib\net40\MaxMind.GeoIP2.dll True - ..\packages\NEST.1.3.1\lib\Nest.dll + ..\packages\NEST.1.4.2\lib\Nest.dll + True - False - ..\packages\Newtonsoft.Json.6.0.4\lib\net40\Newtonsoft.Json.dll + ..\packages\Newtonsoft.Json.6.0.8\lib\net40\Newtonsoft.Json.dll - - ..\packages\NLog.3.1.0.0\lib\net40\NLog.dll + + False + ..\packages\NLog.3.2.0.0\lib\net40\NLog.dll ..\packages\RapidRegex.Core.1.0.0.2\lib\net40\RapidRegex.Core.dll - ..\packages\RestSharp.104.4.0\lib\net4\RestSharp.dll + ..\packages\RestSharp.105.0.1\lib\net4\RestSharp.dll + True - ..\packages\System.Linq.Dynamic.1.0.3\lib\net40\System.Linq.Dynamic.dll + ..\packages\System.Linq.Dynamic.1.0.4\lib\net40\System.Linq.Dynamic.dll @@ -149,7 +153,9 @@ - + + Designer + diff --git a/TimberWinR/packages.config b/TimberWinR/packages.config index 9a46d62..1bfdc1f 100644 --- a/TimberWinR/packages.config +++ b/TimberWinR/packages.config @@ -9,5 +9,5 @@ - + \ No newline at end of file diff --git a/TimberWix/TimberWinR.Wix.wixproj b/TimberWix/TimberWinR.Wix.wixproj index a187d94..3c7c4d3 100644 --- a/TimberWix/TimberWinR.Wix.wixproj +++ b/TimberWix/TimberWinR.Wix.wixproj @@ -63,9 +63,6 @@ - - - @@ -103,6 +100,9 @@ $(SolutionDir)\TimberWinR.ExtractID\$(OutDir)\TimberWinR.ExtractID.exe $(TargetDir) $(SolutionDir)chocolateyUninstall.ps1.guid $(SolutionDir)chocolateyUninstall.ps1.template + + cmd.exe /c copy $(SolutionDir)chocolateyUninstall.ps1.template.orig $(SolutionDir)chocolateyUninstall.ps1.template + -tbL-aYodJrMEOBleB%B( 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 E7 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�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 Zu - 8080 - . - \ No newline at end of file diff --git a/packages/NUnit.Runners.2.6.3/tools/agent.log.conf b/packages/NUnit.Runners.2.6.3/tools/agent.log.conf deleted file mode 100644 index b5bcd9d..0000000 --- a/packages/NUnit.Runners.2.6.3/tools/agent.log.conf +++ /dev/null @@ -1,18 +0,0 @@ - - - - - - - - - - - - - - - - - - diff --git a/packages/NUnit.Runners.2.6.3/tools/launcher.log.conf b/packages/NUnit.Runners.2.6.3/tools/launcher.log.conf deleted file mode 100644 index b5bcd9d..0000000 --- a/packages/NUnit.Runners.2.6.3/tools/launcher.log.conf +++ /dev/null @@ -1,18 +0,0 @@ - - - - - - - - - - - - - - - - - - diff --git a/packages/NUnit.Runners.2.6.3/tools/lib/Images/Tree/Circles/Failure.jpg b/packages/NUnit.Runners.2.6.3/tools/lib/Images/Tree/Circles/Failure.jpg deleted file mode 100644 index c245548b91600f0e984c68b8c86a91b176de70cc..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 761 zcmex=^(PF6}rMnOeST|r4lSw=>~TvNxu(8R<ECr+Na zbot8FYu9hwy!G(W<0ns_J%91?)yGetzkL1n{m0K=Ab&A3Fhjfr_ZgbM1cClyVqsxs zVF&q(k*OSrnFU!`6%E;h90S=C3x$=88aYIqCNA7~kW<+>=!0ld(M2vX6_bamA3lv=asf&WCF+YYG-#?3t`0{nYJKOS$`>i>3iufO;9-@bbf=coAZ z>#6#9NBHG`hSwV($TPhP$S!#GYl(cCcY#mg#?!k6dnVrCnO}2##@zb+YuA59{H|QH T`nR@sarE=E`TOf9{=W$T56=@C diff --git a/packages/NUnit.Runners.2.6.3/tools/lib/Images/Tree/Circles/Ignored.jpg b/packages/NUnit.Runners.2.6.3/tools/lib/Images/Tree/Circles/Ignored.jpg deleted file mode 100644 index 0549b70588bccd8adb8fc04a81ba8de6316c9ca4..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 688 zcmex=^(PF6}rMnOeST|r4lSw=>~TvNxu(8R<ECr+Na zbot8FYu9hwy!G(W<0ns_J%91?)yGetzkL1n{m0K=Ab&A3Fhjfr_ZgbM1cClyVqsxs zVF&q(k*OSrnFU!`6%E;h90S=C3x$=88aYIqCNA7~kW<+>=!0ld(M2vX6_bamA3^(PF6}rMnOeST|r4lSw=>~TvNxu(8R<ECr+Na zbot8FYu9hwy!G(W<0ns_J%91?)yGetzkL1n{m0K=Ab&A3Fhjfr_ZgbM1cClyVqsxs zVF&q(k*OSrnFU!`6%E;h90S=C3x$=88aYIqCNA7~kW<+>=!0ld(M2vX6_bamA3>!guB^J!c9?e?D?>Wxj6uluj{<~#4|`j@%(?Y)R4wWl|;Jo(DP=f?l?y<7Xj rd)_OZO+I+?1e(3sam!QYvBb;Em-boeq+ff#?qB-CteW}C|8D{Sc2oyv diff --git a/packages/NUnit.Runners.2.6.3/tools/lib/Images/Tree/Circles/Skipped.jpg b/packages/NUnit.Runners.2.6.3/tools/lib/Images/Tree/Circles/Skipped.jpg deleted file mode 100644 index 3d84255ccfed9df405586367652c74f97502f1d9..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 689 zcmex=^(PF6}rMnOeST|r4lSw=>~TvNxu(8R<ECr+Na zbot8FYu9hwy!G(W<0ns_J%91?)yGetzkL1n{m0K=Ab&A3Fhjfr_ZgbM1cClyVqsxs zVF&q(k*OSrnFU!`6%E;h90S=C3x$=88aYIqCNA7~kW<+>=!0ld(M2vX6_bamA3#`Gk*DeytDS`p*NhTR=)COsQ-Tx0Pmadq5uE@ diff --git a/packages/NUnit.Runners.2.6.3/tools/lib/Images/Tree/Circles/Success.jpg b/packages/NUnit.Runners.2.6.3/tools/lib/Images/Tree/Circles/Success.jpg deleted file mode 100644 index 15ec1b7fbc9257d3638dff3c5819416078c6ff7b..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 731 zcmex=^(PF6}rMnOeST|r4lSw=>~TvNxu(8R<ECr+Na zbot8FYu9hwy!G(W<0ns_J%91?)yGetzkL1n{m0K=Ab&A3Fhjfr_ZgbM1cClyVqsxs zVF&q(k*OSrnFU!`6%E;h90S=C3x$=88aYIqCNA7~kW<+>=!0ld(M2vX6_bamA3^(PF6}rMnOeST|r4lSw=>~TvNxu(8R<c1}I=;VrF4wW9Q)H;sz?% zD!{d!pzFb!U9xX3zTPI5o8roG<0MW4oqZMDikqloVbuf*=gfJ(V&YTRE(2~ znmD<{#3dx9RMpfqG__1j&CD$#Lw@(3+VvIHN35nz&0ck`WdGLPx<|T}MVBQ{ zmdyY8Ok(cxRXv&(OiMn<_ms{Tu2}55#Qh}W$4?WO1uWO8y!stK|J42GfAeasBji_n*}CQS R{CRh)KHYy_|8D;On*d5cE201Z diff --git a/packages/NUnit.Runners.2.6.3/tools/lib/Images/Tree/Classic/Ignored.jpg b/packages/NUnit.Runners.2.6.3/tools/lib/Images/Tree/Classic/Ignored.jpg deleted file mode 100644 index 95b7fdbd142d9de0d244e866a43fb0aef35e43f2..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 789 zcmex=^(PF6}rMnOeST|r4lSw=>~TvNxu(8R<c1}I=;VrF4wW9Q)H;sz?% zD!{d!pzFb!U9xX3zTPI5o8roG<0MW4oqZMDikqloVbuf*=gfJ(V&YTRE(2~ znmD<{#3dx9RMpfqG__1j&CD$#!+YsL^k~Nr0>4-Or~Wx3Z9y@GGnH*P{@PCDU%pwgy)&m z_~%#5;#;G8?S09#%MwdAIelI%YH?#hQ-s_MzhnOH(uCs#XGvATwdqxV(I_?CIF%499sYY diff --git a/packages/NUnit.Runners.2.6.3/tools/lib/Images/Tree/Classic/Inconclusive.jpg b/packages/NUnit.Runners.2.6.3/tools/lib/Images/Tree/Classic/Inconclusive.jpg deleted file mode 100644 index 32a0ff72f11713991a178d600e4e6a681a40d0e5..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 784 zcmex=^(PF6}rMnOeST|r4lSw=>~TvNxu(8R<c1}I=;VrF4wW9Q)H;sz?% zD!{d!pzFb!U9xX3zTPI5o8roG<0MW4oqZMDikqloVbuf*=gfJ(V&YTRE(2~ znmD<{#3dx9RMpfqG__1j&CD$#!<#?Rk9ae`9^G`Q{1~&*p0^WaxR$V`aUIw! zRIqyDyyXm1-3RaKU%7oGe3sfu{rRd}R;<-YcsnsQ=Gf^S(}H`LmQ1ibX!+=R_ZRCI ziC30yY!bdrD+hWC!ca tgD3C!8Be|~`5^q1>!ZD!ch%gvm4CnNceHozl`pz{v0t`-{cQjLCIG3OA^(PF6}rMnOeST|r4lSw=>~TvNxu(8R<ECr+Na zbot8FYu9hwy!G(W<0ns_J%91?)yGetzkL1n{m0K=Ab&A3Fhjfr_ZgbM1cClyVqsxs zVF&q(k*OSrnFU!`6%E;h90S=C3x$=88aYIqCNA7~kW<+>=!0ld(M2vX6_bamA3#`Gk*DeytDS`p*NhTR=)COsQ-Tx0Pmadq5uE@ diff --git a/packages/NUnit.Runners.2.6.3/tools/lib/Images/Tree/Classic/Success.jpg b/packages/NUnit.Runners.2.6.3/tools/lib/Images/Tree/Classic/Success.jpg deleted file mode 100644 index 3d8e76092fbea18dda6339c414fbdd675f3386f0..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 768 zcmex=^(PF6}rMnOeST|r4lSw=>~TvNxu(8R<c1}I=;VrF4wW9Q)H;sz?% zD!{d!pzFb!U9xX3zTPI5o8roG<0MW4oqZMDikqloVbuf*=gfJ(V&YTRE(2~ znmD<{#3dx9RMpfqG__1j&CD$#!@IBl8HDbhuK4zCO+uG(bA!2XMZ`M-{H@Y3`WLF{6BWJzx zMaTzN-v{=r-ivSFII5Fop>x^Z;NZlcrxPakO!Bi%+hb9inKV0h_ugHq_qW}uxj*r9 b!LLup%x;&LZNC|~@9(^6@#Z(>|K9`v$M_Y4 diff --git a/packages/NUnit.Runners.2.6.3/tools/lib/Images/Tree/Default/Failure.png b/packages/NUnit.Runners.2.6.3/tools/lib/Images/Tree/Default/Failure.png deleted file mode 100644 index 2e400b276fcd227a2f056b4a2c704a3a17776bf2..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1445 zcmeAS@N?(olHy`uVBq!ia0vp^0wB!63?wyl`GbKJV{wqX6T`Z5GB1G~mUKs7M+SzC z{oH>NS%G|oWRD45bDP46hOx7_4S6Fo+k-*%fHRz`)E9 z;1l8sRKUo{$jk&pOzh0e>?|xCtgIXy9AX@7f`WolBEl*>9IAX==Hfz@lA;O<3Z|x} z=H}*(GUDEnLVmJhVG{fi(t<7u(jH2(0Sb~Ks&cUk;@+wXk-8eO#(GKWa-pH2$ss|h zp~2Ke@2e>~Y_E0LUi+wv!C_DH6K+N)-Azt;nV<2oIOl71F3|2`ko~DZ zhsz<3S3;eyg}dH}_PiDAeIw52M!etQ;dFk&lg!9x zxiPQH(%x6+%xtKg)mS&HsqSDyX-iAX#EBDU&z?PJ&YbPrx9{1r=fZ^x*REXy2Gl4R zej%{GtG*hT1sF<#{DS|FY`_rwom~|e!<+>kk;T9Q2$?i7*PM82?WL(g zN`WPzD}+VwdMv!tclO`E`;B||X1=U6{T!X0cGlpZ__Dns(^Q{q33<@@B{==%nWLWe zk1k$d-u?gaXS02Y?em%@UT;|X`Le6Q9%a@~-wSg4Dw&gQuTA7S^0aqm1jFsXn`gLK zuT`(x(RJ!s_RG_k0(5hn3;4_C?KACI9eX3|FH6Gy)$UIicifXYyG!~|)yo?vi~jBW z6jT{=a3z2Dp~83PY7E{_76^TyV3HAkJ?rKPx#1ZP1_K>z@;j|==^1poj5AY({UO#lFTCIA3{ga82g0001h=l}q9FaQARU;qF* zm;eA5aGbhPJOBUy32;bRa{vGi!~g&e!~vBn4jTXf02p*dSaefwW^{L9a%BKeVQFr3 zE>1;MAa*k@Gd8K`;w1n80hLKaK~y+TrBh8y0zm+Mvum1}VRX>a5ECOUFbLEBLWhoa zi6A1VQ-uAUg6QhGTbB;`0YL_C&^3&pvb2=U)oEvKmR)!C(u0NB+4tVOH#%vZdKtPZD3)JARZMl>29Liu3|I&1kTfJPgq+%9OsiJ-toOPO!~H`OqK#nI?@(!6 zqwT>U@y?+aOKW2gMZn{+;qu}G$;FaJA8N3d@u76rQ2qizIPApD)t70VfdNS%G|oWRD45bDP46hOx7_4S6Fo+k-*%fHRz`)E9 z;1l8s(!-;v$fu>mr>!iYtt6tUDypL{qOT^Vt0bYJBB8A!rKK*Rt0Qk@EN!c;ps%fD zpr>e}r)s39Zm6$mXsBy!qvh-)o9Lz!=xO8cZ4?%09~ER96Q+?FW|$Ufk(q2+7U~t1 z=2@KXSDY14R#9G2TT@$KU!QH+Sm7{nsr{u{5j$FQC(J5Yy}V@qDzB>xV-BnhxV}E< z#)i-v%af09O1ru(@y_;?I~y}E@65QjJNy2g{QDbfj%}(txux>_&a!K}Dy|)>dfd>^ z(9+z}+uPgU-#@iw?zFaf)22*=ZP=V$w$ot^OV-0Y|Km*2m- z@a@fIuWzh)|6=3yms@T*mXFhFlJ$A(H^yZVhQkhwqa=!#$zBDQ}POMF^Q*x%A)1RPa-{KM&m0#}=i4RPCS&+>>!C^t~!qAdQeH&7owuBmZcyF7% zZ)WnIu7;vLi+5U|2w1SyZCYPoRaxJ(g$ddJ|CjR_noWKjV8CD6W_kCvu1AyiFkkj&ff-?id-yQAc$CUKbKq=bO)z4*}Q$iB}HW4*& diff --git a/packages/NUnit.Runners.2.6.3/tools/lib/Images/Tree/Default/Skipped.png b/packages/NUnit.Runners.2.6.3/tools/lib/Images/Tree/Default/Skipped.png deleted file mode 100644 index 7c9fc64e3874e15f3f22a234083c1da3ce8d62b8..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1405 zcmeAS@N?(olHy`uVBq!ia0vp^0wB!63?wyl`GbKJV{wqX6T`Z5GB1G~mUKs7M+SzC z{oH>NS%G|oWRD45bDP46hOx7_4S6Fo+k-*%fHRz`)E9 z;1l8sRN(9D>+kO$5D*X;7#I{36d4&A6B82~8=H`jker;HmX?;8nVFT9m6MZ`o12@T zpI=Z=P*_-4R8&-4TwGF8Qe9nLQ&Ur0TU%FGS6^S>(9qD>*x1z6)ZEoQeotUc4CddXRJaa_yUX@}NK6`G*Q rap=JLd&hddy85ua{(ro-{sHGx)snNf1MdKfN(Kf`S3j3^P6NS%G|oWRD45bDP46hOx7_4S6Fo+k-*%fHRz`)E9 z;1l8sRKUo{$iT$F$i&FP&cejS#KytK&dtus&&t8a!79qiDb2|%%gbWKB5xwEsi|pi zZ!hR5DCQ_8m>_8BYiS!{tB|drnWkx$Z|30O;F9a&R^cQtT|ji2DC;^_{!RSCn}wye zOUdq#Rq0dFZPT@#YOA+736d-j|;b5^fjy?y)kzB9co_gm(kXq|kyZOXm=d3UF- zxj1e8wK-eQ%-ni$?$wK1u3ftZ42n@O(n8?#y__;&7GNj|@(cbyvH?TzcXm}^{Bss~ zL>2=JAYg{zy~a2pzj6*xP@=>&q9iy!t)x7$D3u`~F*C13&(AePq0Cs%*lgwVM<9)7 zJY5_^G=h_V^s`AE_`@OZ??1oe|Np)J|Fd&fNJ?d7NlEPTHmYb~z2o!biRe_3R0~Oo zAC63MYDEjzm0f!k!^6X*pexu`^zUIJBcBZq&!IL!2S)kYxVsM~C}^^=74jO(FKAdU zz&yERfxa~J{Kb8}>K+cQQyU%qTN*E3I(bV>4OIj9Z-1nd_^+fC85L>3(lN5 zaNymeob{wrblmH;2j<40nnP d7?&t8Fes)~X?EOwb{gm}22WQ%mvv4FO#qjX@@4=4 diff --git a/packages/NUnit.Runners.2.6.3/tools/lib/Images/Tree/Visual Studio/Failure.png b/packages/NUnit.Runners.2.6.3/tools/lib/Images/Tree/Visual Studio/Failure.png deleted file mode 100644 index ba03e84853241e5fbd33f88b5b051a6d8f36e94e..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 747 zcmV004R=004l4008;_004mL004C`008P>0026e000+nl3&F}00009 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%0D;`JV-CiezL={Iboek_WYW8}# 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 Ofhh}2S>V5>1^zcjBoK@M diff --git a/packages/NUnit.Runners.2.6.3/tools/lib/nunit-gui-runner.dll b/packages/NUnit.Runners.2.6.3/tools/lib/nunit-gui-runner.dll deleted file mode 100644 index 7161b97b7fb1f5150dfa6b5e663f2a18408419a9..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 155648 zcmeEv31Ah~_4m9b^IkR}1YQCJ-eU{TBp?ukh^TCWpaKdgii!aOL_-GWh0Pd6t<_pw z+iKOi;cjcK)~!}6wrX9fb>GFMYOQT;-RjoL_xqiDXMI7b|JslL_vJxm?m73|bI(2Z z+;i8N+3%3EjF@2w2W|lOzwpwkO#Z4J|b!(=%H8XYg+{{XAY14?((xM@n^_;y7W8X;3_`{wD9pL2l zsu3Mn97!6+$f#jt6!zVjI(!7~l#ciwN^XQie%_5s5fA)BlVd2?#FGU8?A;|qg#0cA z-+dSY-(-=(1+E*SMo9p%oj}GgPy+Xt1iZHk8ODgVrgd$AKdjN^Vp&B_j|fSQ7-8q^ zB|wR6kWpwR;_mxRG>nNO?4}kAgd!_s7P>ikbd!C_x`JIA=+Z!!2D&uRrGYLDbZMYV z16>;E(m>)yc$2wO`}GEac5J+c;gMjC={$=%z4Hzjyx0hjA3lhxG%dE z+;n-(rqADAwSMHnM{f96@x!mwrw(nnb+^CW^Rx7m-+tu9;cYYCc(|f}k7qvm^vpr~ zjwpO#SnBzi4OiVfesKBOm;JfC=YlKuxTb#DCvX0KYD@Pe*B{t8s^YHezjN~?ugqCA z>Wg8^`;^_Z@rqMs7yspgJGU+zc>E;`?wdXE7eCs!rNlaSWXrv~mszJRFCQ5*`bP`{ z|I4DiI=W$HAet>T3{35#SuAvzMi#iDBGc-Qn}r#7kyVCEvH93^q{{Y0IAxXNT9Q1Y zIrT*}^+lw-psZkcw`A&qHj-Gq6gf2ZCFElb(v!yO4f@hT8xpO`rpR7%?3u73(5k|0 z1(4ZFay4wovZ_38J~s7BxpyaXl30C^tUMlV2d8+#>I=w-wig2^i#rgO1mf9#h_R}8 z5gMZgl~|57hn;bU1(X>vh*e|`?~mkES}%dRX~^nN#-NO42QXBFv~go*!rT9s+~M!%7P*t z*7imw(RIMQqF7lmqdVP7adlIbRN}F-U(_SbE}ZA=DZZ!et?i5!uJ#ElJ+; z@umqV>GRk#%KpM9z0jti z{T>tR5(!}uv+NPblK6g3mINv+G%DJJut>y$`NJk4mzf($8Ad5Wnt3`M5`aj%o~g9} zLbWWEJCRjR?viAZFGDsORM!LH>LT7==;JMf;p!r?zr$OSH2Zk76{_lbAk3ao_VGUU zLi;R@E!c#JAK>I5sZRIhz{U-=^a|7qk@h`4-a@r3T@|PlK^8ikCC%@Boarl6r3aZ4 zZ@=kdE`&R=(&q*E6Q3?}_)D@+ef;Twp!Xg~7!aO#I}!KlR0xj`H9IKNW174X!SgtG(*)f96 z?t)vioouYJehg&~VyLPhhLsb<&=7(c8eb4YQx9U;+JYFi{~(4wCy1ek3u5S1gBX<7 z!Bk|&N%>5>o$6`;(6*3W^{#?WWykCLZgRKJ232;L#!ZlW-|X%x?s8Azsq7xa)l{P! z-BUtG8ul-lb|Ro^eB&CZ2c@ssR)0=nuRkZ$d4Il{>XH5&TG9Ra zWMql{d0R5gL%Wo$?Mva%cQPbcMCQVo1O)CqrFOA}Xx| zyjUr9x*{V_uZ%>vRY{<;swCbW6A24nRc0OokXgrU zY4JgaPLYGIkjaA>Dl&*+6$UZ1pCCq>_*hZ-He9Lw1C%r5I_>K{^`Y|6PpHn}=JhvHgoB(1}6FUQ1d_;p*VlB-*ghBHTa zUO^_y3arCHVZ7wHIHtB1;i9LROj_yVoU)EUWQEnpR5FV-W!@HnKBL9}a)<#Lp094nRmjMHxye`(leTc28)U+ifj9uKL4JujwGX_a5=arQL&&n;fu7O zz@jhWrG>+P=fkEXiK*Nn+*7}i1x5q9t0eQxwK5m`aaf6Ie}HRh<0{si1@x5+WpODo zj>DumZtrBm$sA2M%2}&f+^Zzfjy4eI{JgNNaCoIAob3|kY><~2iS}9_SzjXy#hD2! zhe)dpm+Dk`vf*-!BNEmi#0awqhJ6zFlnQNOb~VW4qLO9TFzs5V72yi4bqE`k;Ioi? z+EG$huC$ix23M}^dQvmj;gahy043L{NV*e}(gsL6GAl)i=~9DQYvLxgD^&u9tfHjvy0pAdpi48bP>&V4I{JUIk^I|QHN!b+g&L4mAO z5pNh{DoJ%zq;IV-$itJL2e^&CR*+32s{Rn z)pAdnX`R9JN{HH|qm@K%2rD~LR#29(&Lo8<)%Sq=EH4|ofA)B@JFtcwvUNmd-Z7krbk zm+$Xzgps%VS9@qIcL|8$4kfQk$wG&juP-PfnAT-JicJjH_R;0I98fHa@tbK~fnaql z1i2CcI2d@fS%9trBt21iytX%L{UE??NDwKGCRFi(WVZtPSGV*li~D;O;Cy`w3a$Eu zD~%x!8qlMvFZ8iSvFO&i8hmos;8J8SLES~IYY~?AFW6$!x(T5`oN3u-^>pGcY`4l)aiQV3-cn{mtDLa8v^k}ACwfDYb%J5s>nNWI~XpPX@^>O0V-Tz{R%f-IYX_x6>hU1Cv*oZx|*5MR0ler zIK2F?Nrcr4ReysV{Y2XljMtT`yY(ATLHYP!8%arzlSe;T)APPf`kCO5;Trpzdlk## z#PB#cj*VtBsIa=?Xm%j(l2L_@>l@7;1LEP`qS^a!uaI4#+DL^fhpK<{jp!G5LWM-L z91Pk=6r)AlkB}myzng>n`HR})N{m$ z>%8FJUT_~T2+!lt9_j^;@PdoH;89+%#S5q!3?nzyx?vUe1h2BCHN$Rdorkv|0yCSN!-&6?kYja6T>cS$}(pQ?ud?& zSvz6I>Tp&^vr$!8&nQ{~smys80R*~uqU}j=8_pO;C3@CNlzBUf{=PEM-wQKmrC(Uc z>SAA&ifz|=4&kcPcjCB{Ypra=vewFmvMGTj3EJAG1jeB-{?z4b@z2*31sH_L?gn!B}9%)MujtBW%YB|5U}s@ zr6K~UMu$_eW~-c31OlS5y8An^1Ty>jL?gm}-j@jx$OK(tu>3TZ0S+4inFD-mh_FBP zu^|F%(8C4U(9+U{4j)2x?^4f#Xnxof)YeZZP!`%`y4Z;(Wbf)rO+&?&oK8(Bkeb$u zDS(b9WH0okCITXl4U5bs?3x_`X^;cF_ILzv(jM9WNqam>0%+_l5nV0sDqfEJ`&oTq@@0Du#gl8(%6SkP3ZRP!|-=)dhh- zX(_R*3j+4DKAuE?CpyC*PZrPB5dr(JzEngY)o$Tbv^dwP5D?Aw^)$n^B5Sw74BaXtU{CU~ zpcHP^5C|xQqPe9ZU^n{G5`i4yc7sZ0IozrtV4vViMFdiz+YP2-pk9)UoGP%CbA5wHupd(DFg@I*BRdCv8xA|Msw>spTiPAX)+1W+Lh zC4lB}tOQUY>m`8ZF;4;*>K-lubgi8EcQ~}H5Rt*9BBws2bkP3-|saSZoG6>i=_)-ypR0oGs zQB!Uu5eQTv)#tV;0`|*3ofnlE1wd+C&1bDInT(3#M{@BNp2=H7G<_Xn$k`NHH z=;QTRkV2USk|F@JKv{h?%`|p#56=LZz^zdN=~YexAY@mBXd%@hVX2sxTfYPXC8Ypv zJrb~Y@$n=AJW-v&dK?G5oHR`Zrl~I4`h&79BJBBOILt#-srhXd80VM`>7146b^#=$0J&{DOOv^mHpY=zNCi4%&FoIGu3mfObT_K6cydS~( zxJ<ds9p*8fr?>+_IBS0rC`neIwa1nDD#>y5vmFE2yCDx8Rhz# zT>-fMfk3D|5oHheF%}x@LnRmiafA7eLeXhUCxGh0aKg-egrpXn5LX7_FdPR$632lM z-N$L<1VTa)W$)<|iimBbPDXZIf*c>1t-Qkn7#5aYXnofO&)6*FKf1n zQ(gaP77fI-A}B#Nic2u>q2+Ov8BRi|34u~*j0Midam8|PJD4WUXvW5zGlL|?Dj>HW zD%vsus9imt${YU^R1g}U&^-s`S_#DCs8zX{Do@lNUuKpiE-1mFzAD7!l87rUG?P{# z0&3Z+FlpgokRqcHc32Pj)td1ZP~(7%+Mi2W#UwA`MMO8YlvW#sTAc=Hefbw!rJ$=e z%5V-2hlmno<{8aj#6{FqTk&QdwWjUXilYlwl6pQ36vJ8Qi-3{sR5=e~7;TZNvm&Li zrO0@Y(6D*13&-_b@VFrOEr8Wt>}e8vqLcQ!1hD}rb=D0cXHlczb_})(F-9_DZLp7s z)g3XbF)E5!JrMF`c7{+RZ&i(D5?c*$PpYnF8S*&>GU{lWy(((Wqlh_-F>e#}<47IN4h5#%>}kr0Q{j%SABq1s z82?MwJ##OQ7fO%xg`BYDv!15FrDgGS#zO+YgO-J5ap||R)xMn5J#p038U_q3QshiV zE3;Xl(3$TC5~*nmPZK#NfqJHWuJr1ORpZtZE8nfBqrpHO7x2{+k=v{%cSOT_!ZWQ( zVAhihu%2ANttWRGPSnhzXXX;SqK<)eySYPe^M`}mwzI%Bmx_<^v zOtt?SC`Jcs5gc^E`RDI>h(Frw?_Rf=0L!EUPTK6W6`dIF`Nv7o4tK@0_l@ z8tTMz*0agHV!_6104A(mDdKosN|JEvd!y*mo#%D~s#Ha5o)bt(jk_(q&~2}-80OH5 z1x1C{?jS>lu1;`DPrepC`Ii39F;270#8^`K3!Ey3lT!}|xO~(a%^qaqE2P~B*&*f( zM@(zaFvZb|VrH1)5GYDFijzR1e3s*tk7K0j*F|#^rIbxrU&2$MVpyZ)Ej9Yrs5k35{4u0M8&v#ffXjc1 z|AA=GGQK*61=8iJak1a=W8J~mnZ)vJVAO!~cjgQ-x|#{uU}ot0_tD~7`?#oDpg77_ z1UQ+-!Ive&soD|^?F(wdaKZfql#!iGG-na^z}Z1?j({AQtxzHwG1T|LkWqflFpVedijkT*KJd{ElmWMu^ z=tY8V$E+)E-3R@m3E(XJ?yB)c75)g&q^w3<+u%+k3fn$Jq-DbPflPfOg=x4;lq7?l zie8TNbr?1ZA;zF_ob`k@e*ikFlcl#7Q<5dPpmUk;bS^g|EBL0ma?@Ihs5+df$NN+$ zpl}$DMk^k|w3Y$=WkS`KI2{LycIlTN{RdN#6x}TsCy-#GA60SsEf5P&vY4rK-9_kV zmLuXy6Jsjcxa9)}~EQhYdO z=~4!)wQv{?X92m|jO>F*VNXY`sJ^PikJ)%D%H<4y{i(eoS>n`cQI|CBl!ajf%D1JD zk4@6Y2G8bU>Ks7_ffqkSmOd3hSH$p3(dmO@eHiBW1>->j<^zAEZQh$R9SQz=ls*y} z7ANXPBxE+FMrqv>z9Cz2EzVYB0B9Puy=3}}K(T!?%9=Y0Y>wf{`9?&`P$b(z$%$I* zqV|JsphPj;E0HWJnBC|)e6k$6uM#y0q1Evnb|0_gnCG4TB{@z0g%%Y z=5#c<*@D+uaa$HZ++OyA4#0(NE%*l8IS+G1+BpIy!PRI!m= zgFtyaRbEg#pe$ZifaRA&PprVK1vA95?V?U}P;D;iBnM@=sBbwa+eMx1pjNr4Z#$@*i#o+YdF)Rms^-@)nB7s= zxE9lcCfv&fUp;vfM=v8JOMP^;v^ci+f(=+Vx^rsx2d>0JRmhm6s zvsI3za^4@!ZbTd{@pRl}5bm^Nv1Tp=cr<5pN+XkQU)xm$sIbliHS))Ke&%24f=^Ac_@Y@odQ(;f6&PC_k*rVxO^cU&R@NskGxQq7?Ux$Qnw1?RX0*q~T26M`P5^ba-*1uiE&w zd3n?R&UhI$XE@A44$haOy!Qg8&oLRxtk3()pI=u43s}Wa#==m=82%5 z;}nBkg=#_;`wF-wX;03J!9Y65*RE94!E&r|jeE+8Gyirt=#*(|NQ)jU+=lS2}E6T8{K3d>$ZS#&*E z@TKah&(hlJLiNliNZ}-{OAupbFU1uy;5q$-LSZf8Fo+4nV_W(bs%Jp)vH*%@?K_V~*i;-7q#8(O!PdxNCkP&D6Z^w4tr2&$x9t znO=blRwTU4tSgxfb_KBZZ>l*%O)IAjYWfhhho&&9xe7!bqaa~TjT;vv+bu{2IXPGQ z8SY@rzK5yRe80Dbtg9vKUc%UbeW@(P;;m~C2TkHX8W#Fv-Rrp(P*OWszW{<2fEnJk zNMKzjsrcqUq>64CtKRH@@RM6A)O#ID3zZOwLRa<5(ac8y)N}kCNA{pS&oxGUi_7qa z@l%LQYwqP3GIi|$j;^d9vpn)H1&qIRd(ew0-4Nwen$`pw$u=~h{W%13m!?4sllJGT z)y4J~H{L~lH32=tygKI|w|)Xy(#06v4y=%M$Gvbv#GET!hP}A&;CT&nr8mBh2yHZN?ISlxM z0t42CaSrX$@q;><%3MvwYT+r^XjX4l>cHHjLib9kzQGm+${RqL`x!2n97;=^44MI_ z!z;>5MDSvg8xbj;-=?xSUQcq953Dq;pZmZ*rggIq>}y)L_`rUqb*m4oGOgQuV1LuP zo#3yLF*3^j0)SSHteaVP0AUaBhnc`H5h~U#D`DLU$T$vNaNOPpu@#=^3GlJ*VzjYk zM2V)!fu=G@Q<0QMW=Z`kMU7UV?Nlj9p62g2VxSMI8i8$MDo^56AFt++g%Is-;Un!4 zZ>)@rtdESSM8Pn&h}HG9Z-ET4>}Jr28DR~buQpJnt>Ky%M(yesZQl(Ai&=l6yN$Ll z6X10PEcXK|2-G!bcf&QXx>_Hg3(z}^s**0-T_~%uk;w#qj?G>sc;iBn4y`9G|2$ka zQ0aj;Eo=Y+Z(2A3H$DGSXBsG{VF3qIW4rKH)Dz}l#J0=AT1ntKeGjuWZ( zcDa6GLYrppaiFay$XDU5CmBZZqU*aO7BCErX+_`rgOR4TRfF^wn@b`}YEi8`b)>#BItT8D^+-g{p^LaCuth z?l5};vIcCV4lBf2KKzLUs8vI zze3N_OW9-AOGsLar7#cAVit+r7bon}!Hz*=x8r5RSX-EvW8LM+vgGh?340RB#Jp=u z685ZW2TEw$PNb-hf(jXkYVa z$7g`n_}uHjm&EGIlGYy(idk?kGn6d)ZF9_9QyfR8l^G8rv zZ}ajeaxJW_C@ZwyVbD~?#geHM73e<`O*OxSZ9F{^FDj!U3N~3*DtRZ;Oe+3_-7VQoyaeRt;U)?UEAKlGfS?kn` zznk?lf>{)0-^Hakk=5Cu4%q*xUd!Hg2V6T}Yflm))nH%yvL8g&x^v^WTKimfNNy=~ zFa0-`MRyXly|~%ycP8NbL)FK{jKiVVu`FK&Mz$^+OnLtf7W6NC`Q3QK9#@AqlUdzZ zH0F(+Ot;-9`$)4dGFAU1DWJyFs7Axoi@>zC2awk|zb>x_Q)kHX3d73QWc;d?rGzF|spJK7yE3ycL;ZNEQu{d{QK=t- zQ5`l%M#%K>dfY%DBNAt1M`vHCX44J-M0xcYQMNddVCO*l-gjqi-F<{e)gK5+AreW0 zZ8jHyHxyOFgMP1g{40Blr%bK^*3m9jk^%&Z*IqbyN1B3cVQtF|1iZS>1l*Ta{Q z@&S_F1S9tkiVjP+K1LwHm$aGICkS${k0_l`@Ske@XSi4Ev0{wp7?pogn)FU_=)=YI zVO0)IRGp`VK0gPOibdKX@qKNiLmM&1vz|k>B0HudV;(izD^i0S z852?-xKX_KW)PyIa`nCP1~di6<)FdD3HFpOJ{@fp!`qZy4f5QrP{1a$!rp_x>jG5T zM-X^PfIjw#1pbBWH<^9yO$2@|G5zcZ2s|c0m5uibtjb|+4&3_Ndk}a?fC2U~1g;h! zU1(oH=&uSYvY#V_-3p}2et|rUni}Utbwx0M*T=#*&6IG#)atPo% zQdPm3i!fRYJ?VY#28=;yxd%ZpZ8xJ{u?!%kuY+G-3OcbjZsay1f`uH8h$er;bi?jj zkKTp{reswEZyQCtoW+t;*K#21Vo2sYU#&zH>5}@?w8+6VQf$*7$wO9O`mQ{*Cbc$q zsBzJ!-n;UkcViFg%stEGsTPerPGuM1vN{QMmGH%jC|YTfPqm@bMYW(ir|!o>_gJTg zE!Z_EoU?9XvI;Cr0N7;`a5hon>WrK|6Bx@TNs=wZ6%L^Yw_+Kvm*Aa%#egh)(x6DK zSM)=PvzIYrLmox&mX>iUq1CAxu5FeYIAD%+34P#fke0!oNeR0l#)uYXFC{BQSd4pj zpp(wlg!nL&sW7`qQ85-ntitT&A^>t@1qj*6UwOz)6p%_;JtSv=tTKkt4piM7XB_`8 zH5A55a!iDeSv^4#v&wN*#m4$f+<^V5U(}w1(!^t8Nn%6UD=3>%x7~us0y)sHx?fdl z$=lu}am6(5GAgwK7o`@pHu_8CFj3X%??4(8-3XP+LcMOzv|p9TUJ%ggjZ1aRO5vtV zQfZx4pQmeE`s`&Blq%xRJmC@2s_*+_Pnq3-ddd zLNPV%zYFFPM@>!{xoob=*lgHicTr`Owe$mN67kxsV~hKudVS^UM}bx0=14MaMJUxH zU(tp;E1_dMt;V=3RlBBr%v07uAID~=t`_>9BK4X$zY*%l+YqTw;Z`AuPC3--45{*$TGxRnNy8=1Ewy=JunLFdfH!RYzq<#8zAP?u>2iOdDoKr)OD%_=Y} zputzD4njoDGQ5iO`*5LnZQEcHBK5V>?r5K#f5(U9s1-~=y21YvQj=4pjb(?BiL&j! z34`Y@@g1L1vgL}R^TM}*2zQ*qY}wTob-?2zI236+z9T^)I8B1p#9~qdg1tz4x<`N& zA}1LZln|6;XL`Z2Bq&*6Dgy$%ld`A-Lr#YlLn3s+gTWU?p+N5AoCHEI`X?&zxfmkS zGt#AjM*xX*A2pODN5TZPw{B-iy@x0XWjKcoeo=sE`$VQ1rX&-(T_U8*0%Psuq22e2 zk|t%ntzxJ}wvavBGP?gSCTwN>13BV+D_wlb0Ltf%={KL6Uc~o`)yyDh{!yXUxC8F z{m6|Zt855oR;Q|sv8c|UhO3ip(3OZlx+e2lSR&#B-`o+x>QK=I>3$PO(j4g%hfUng ziNJsi1`ffZ6CL<)5E1EFp^S)hze^-Zj`8I~|KT-ULSi`inK3Hxl)TX9H(sLMj}#Gb z8!!D+g*9Ahn1H;Rx{vH%NxCW~03!~zQX&H%Kh+$I=V%W5T7`l=mhCV%rq3aD|=;k!W-Wz3fpFze%fZhJ* zyg|L3$6^|S2^YupGGXr68TF|AG7e86Y##>(`s_2hWIAmMt|RY7q*{3A!5_azh_+L6 znk+fq*{~m4q&6B&OEdFP%_G&uXEENfMj@vwC3KN1YfQ#@N>)!aC95?W2?B@DM7tag ziFnRLyT(N$U0sA(VyVAPiRVy${rULj`@l&{OrODuvCU~Y&U25TNHk5Yp* zhT=(ig4vKnWrONKeZ-8*aGxsm;gwOTAJyUt?&%zBa;|*(II%DLusX4DCdNTw&H6FE z@+U+^!w34xn5@Sduh>7uFVq_nc&mRcCdl$otFi=_qpDhoQPt`y#)-jr4>NNAc<;uq z81IqX8}AXyAMbHI+#G}A_|xMs>>ps5^%xAG<6H^K`0hL}h?Nfz2=;sl%24kD2Av@p zdAP2Jz<|DiPK~I5;~^rwAmn(6bUnKyxq!8^mrz9-I)79+^HOP+*}tdN)w%k%^bs9hpeNb)jLI zAWI#WE^IC$8?6M^g)5!nNtFE{X|zB@J<@2Ih=5EJ142*@BQB$F_7J1ODxIyw1d!hq-I(11sG zOjK*IBVeI|7_tmvXpun-4M$__>OHpIec;)txc}KH^47lRP$Ua>8Wc`PUW!Qll%DPc zD5s9}9*a;t1pOkYbd)nf4%)H{29qTe@3Wte|9sLzf^hEyz)oPM)@;ziOviXX6;}v z@vxUlQ0A-XP8`}z5)_ArF)FaTz^iv)Ey)R9DM4|AS9!EoGw66kO5rvN0t13CX(B4% z5s64o2zf*zU5_Y9#_s7EIg96cL_!%1dO~luB0As^g>Kh8k4UuZ5ec{+k*afxLSR71 z*%23*{1K53&y57>&Q~POEMH+*D|ox^G>&4T?S!N-p{$6vS1_6Ot3sGx8lv4%I{~*e zta7(B1TrveBlIpI;sZ+vM5HH$YDbW6E|TV0Ux~yt+G$tz4~f>UkO+KDIQa4+q3So$ zE0>qp?Jp!@HZ+YDq-!FC;P&ox-QHMOF4U>SpUF(rF`>-(D8?zO;*{G5cWzQ##Rtpj7Oy+(gG$|Cqd-60xw5u5cnR}2j)JYJZ zPCK0`A^Sa_SZvWDv52yFo8*Z_1e8)4=(vRH4N_?2xPDl7}k?89O%d-oQ6*EWV+ff69Lo{ z+Ej4zPQ1O4sdWBCWPXvKnJ^gSWG2bJo0pkdx6s`+X@VUuMGRu7$ROs@JPcbwkcO5T z#L!5B7)ud`3jQf`v0h?6xNA#&7c} z!m?V-(pdHitAS0rwtKXl%5gy5_T@t&)~=x7TJ(6_ou*0M>Vbmq*{Z3ci>E2Wk0@6K5{QQkm{kULdoXU9?^5HZ-d6Wf^Uk3JDQl zpDkv*ioB<(yrp7qrC<9EE^4C_JJ-ABmABUQ?#L z+1)`>oH%X|+(wrsj@uJ={S}xL@)>B@AESyTS~j1Az}tob*Db}>hCO{M^ud!~++0Vx z!CF2`B#34wf~~1eJhy5_XJx!cQdj}$2@722RD~htvfclQ8udGGeVYhL4%3Ya~?1j`p zuDz99XaZ8_%#|noiN6A$59+n-@gr!C!FiVo}WC z_v5f8qsD&Mfl!bAek{R(u!oMHNN@^r>yWZ3S}cZw_Hh!hDDKFOJX{Yfr_1-6@Wwxzbl0>eXEfm8zc#byvw+D9?M`4O$-c z_`TdK?PulQ$Nq!d``RDKy`TLrxm$bDGL$7|z74gcYXc%P1G{uDudg8@eQ@XXScLO(mnF$syiwalsr-Cvm}>8|9-f_<(}*NW!(O|6jA4G3}=r{*qI#d5=dZW${$DcDP#i zwT}GaJ6TNu-$_KLzVk8oPW;EdZy6L2*!O*mPVpur)Nb|X62u^-sDo1Ik2PZT4MCY3 zQ%5>T{kXoAJUlNa5Z)#hXmvye=BGqt_RI5eL}S1&2HsAp}UetIk-GBs?~!QDpU-Q7k4n5Esv*%)fC z$eOO)9TnoO=WHdh^(0&rG2JPLdm3Gx^F-c zM7pm_CIIp7cg3qyWm65|9S=zNN)HQUPYU}kUuHyPHo`zd6Eou7&1c1TA0@A_c#kZ! zLshYQA5%3xEdl|E5ZtFF(jGkBs}Z3(IFvt;?mjJn3QOlN=?`Lhoxh4z`42LT%@c8% zGby((#Ley}GFN10$z8i$CI~uN79ohCih~&1L=Zz84`OJc8e<;~5j%I*BWxb9-9Q&C z%Wjy0`5pJ8%5fhDW5qIo9^M~^#W?6-7@doZ{neBAD3-)1((vja+9G{_(El*Efd3&P z&;M{e6sKX;Pdk}AD2-aT!#V|mvH&MC=47euE@GYaHB!6XIf3vfjkv%lO^6N)4QmAH zj?yH}mA=ZSAf5{#l)+duG)f~nFiI1;$~+IInQ0eB$aP^-G^r2!L1wQf`Ye39hc#Qw zOQO?*(^Y{cM-qG94A0&@R_^i$X)1I^pzfa_Xy^I1v?AU?xsf&?c#} zAch5VthC?EZCmMl#BHG6iIqNxfNwhTgtF3YooymDtW2M6BBV{sceaT(_9W&s^3&Gz zE9RoQth>G7W(kUo-6O$)P(a78B`96tZ#>$2y&(Lz!wkL>K}q&o2}&}IkvxNC)~>-y zHtj^&KZY8d`X(YhGV?M-4pg!bHtge7vX|biWYUOnhFqQSbkAi7rxoO+E17CYS#y+y z5pZQxfUGJ++f{}{*;g>NHc%q47zD0CfrYSs->|@nrCy98kb#oJeS`3H*NIgU?VJhN zOUTwIJ-VuA!d(?>)GZYOw^XViMA_GqkuC@kD9EKos31bP$A0005bbK7K;|W+3~8Qt zcXgP6-9koMbRs$voo44sOCa4Ncy}FbwoRn{hEKypWd4RsLh6*%L!1&xvR<=1 zeG&nEKJA*q{>rA=N?i#EK!V_qfk?ZRtn?s`h|KTuC6LrZ9SJ1a6+Q`w=u84S2Uh|G z=vGAl;tUKZgh=~+pEyKh9?2I+Qdc|T5OPN`!ULa}bghku&Sayva%Cfs?vXhaSp_5_ zKCr(dgkg&lWY!T!(ya1HKxgP#93io|{M;B7*y0h|e5(_N!<_sGIaa3!ViY0RHIXQY zpgFjC}!gr3Z8wJT7l!=HnvWHD9ZOxrP2# zfqN*4YsVM~^L;!#lk^-6zc^8OFqTeaJ}cw0+5@8PERZ|nW_eR;saQUN?EoZXIXfpL z3!SQVr)WEwxP(mQa`Y2ICQMn(KIo>S?JTM3LAesr3v41fuFR}PwE_PA`jM<^61sKJv4t;&3sf7MQx-{ZKP7A;&`;e%VV=+6vJbcAQKv{l|4z_dTZ-j zP;{)VBi**fvrOQPX9;yao}EwtCj9A%(nHKhjXNKfpv;+m=LOMifIzUA_&LGfOHjtB zxHudhm!J%TG5q#MuFS;q+=MbefC$0!3`7T(afGfOJ}fv^Ale-i5pbM#I}6};MFc`8 zCWs0w=@5}_2#tFL>5d*H%|0uE4v1}VRw>`hFqM~S3Ce;wQm zCej|hKd6Q&_vIyahlr%f`~*r1jcJ6TJ2)3k`;(KFmbK?ftJo4{pG_Jq6A?Im7TgRL zss#sxWm5d~_?tlHJNYsRL-(|oa9T%BS|*xNNG77}Ye=JIA_6ik2#g|xYRcTOOp2eD zNfNFODM^s-Q7>WBNH$s^8nY{q0(6xsAW)@5*(Wiz7L^DL{C@~N1f&(h*u1c`ilvs8 zK<0vc4GK^944-fsMowB_HaV|75t8NSXAYu6Y% z2iZDbALF{f8mL-+s@>}`!(~Y0Uj&P`Qw|;ZT3#eY(vkJ^!zn49jyyROS)}?XV@yeXwK4 zS+YLeObF!lzeEPymr$(;WuuZhvqeesye}KtN~JYlsa=erohZBTK(DJH0%|=_5fQSu z$=%m`;0MHf;O8p2SK2qry^npr+?`ErCd{Du7@={53)wbFC-RG_NzXzh=5oZhQ$)X4;F;QQY>|MOdxZ6zF5N3T?!LUgAew^q8A8>MU=gq zG1yn4xfCR)4LNW?ZcR@!uHIkE0Ml318f$3e$Iwd=urYk!ES9S&H zwJ&8?MA<(eS6vVyP>>J8nij%S4-FSYvD5`2klB=P0K(H0fFL!r%g;KI;d zwIt+v@K*t34}uSKKCDbcg|$F=I087uy??-kuEGk=8;FN?C_0fE}r6Pwg~& z#-*2svM16$(wDtZg|jEp&0Z)*IoT6(vuEFJ+TZFld&bF_JR||}_H{l9h)9PeAkvjU zC`LOH5OO8ph{3e)?NkEBsYCF=Dj?qe&?f;Ac@hxmN+1;Vjs%2U2{=wM?aISDvjE0r zZZy!L1SKHe-h)ZB5fG6l0grnQVq)w_q>Uv!=fu47ES7~=vjqB3-_Gc%#0Yu zEVWKa!S(d)Cghje2rl}uUI|^KdR3N2lRcgaPc~UF9r-?Z1n02So{p?r6kJU|4u%w$ zuU8FErsPF#wM7cI2qncSwbB%xVI738US5D>xnf=znc>xCn|V;=2+&mHHPj3EPP0Pi zd$q$K*O?uH%;emseChzNM|IODtwtop>ax5o2n*JXNm`4QcBKbai}*hT3tbpJYM=o{ z+r?<~n!j4JmicS`bI;UhR7UdZ!D7*<><9RC8EqF+3C)Oo`i!=V<#bL!okrWmMDqxw z#C#+;^+g9DS^YLFtYp2LN7{q4OZzOwKRXZ`AZGAlvfgY;ra zF?mBcKEzb5dbS^H+Jc8wCt8!5(L9ubUsF8wV8&fDpH!G0$Z021l z)?8YcvL}KRZ=APh${jYXzA-dbzA=QCF~t+|LLU*cBzGiY&%sJDU3a^)#Ugr-=+(3M9x zokC7}C_x0e`}f`MzLv%qZD-ZEvJyzwg+?+&+V}W`A|kUDdJ9P)soh89B-zJ435amc zfVI;M(yi%(17jv41IsT&WF|xN>0<*U8A_pM*gS6%fR*Qi2%TQ4m8T))>1T`F6e%&2`{7 zz7V2+Q875(?|85FR0lFur7IFy{&lv1DWFbsJ#zB*{WbDD_*9R-tTU6dkB_g1@v%|a zh1Z$oac`BOXn`G`x512jTHwYWeduq$LhT!86P~+1*VeRh!~sn?YqhhwcWIPYt!mByRoG%GiUYUmgXh< zG_9X!9o5vj`{Hrq8h2T;%h*x7){ki#*|6*2{LEIjwl%M8a&n*B)P~N_pm6+Krs=2J zjcc1*myejS#A>a}1d(4ytdaH0c3C!V*{D%VcNy7O-#Gcm3ok%!245}IYlzWitiWrg zbNHme3}cC58Lf;nCW=IOb>&t{#$O3V-Tyx>O#%6r2iZ!=nO%}9nA+IZD1o`n$22A4 z(J(R5B<5cs`WvI*pAdUnR0V6Bm$t1iS2Q&*U(tpfl1%3Ox-bqa3;TzN)^>_Xy=U?&}?&LvJQJN2P48l%%zV5wvc;zcxniv||;+yAC+`yFyd`A5h9AoczJ7gXGH&eWaW?l`&rkJFo{ zR1bM{O7Y;*=?eyr+W)ybzjf%Lu$Llqdh_tN1|44x=7U+Ek8pfeFZ0O2(7I|H5x_^-IX34T8Xjvf4d zg@#e*AFoWstA&;sjmB!D1*4e#Fm_prk<2puH5s;uXc$$&1UAUm;z@NIL`#i}kYj+r ziI|J%W5DGS5Og|3ngZDZDfb2AR%1D2X~eb3I0ggHLH@k=g?LL4*&?hPjl~Ex8Sj+f z8!Gu^Mj(EWiaG0L4M|QK{jnE zEFcFfXX{!8A(};udBCm%G#Svk?GWkjU^ROCSosA#y(iw4v3<$%#Xl2?N3@{M7DL#U z?b2LbIo|abOyU>kK}2VQ(fQdv3?g5)qqjplD|!X8WfFh31-%2=GCDuo1c>&aBgx^P z@>lZMt!tk$n^8ZyCIRr!J-8Gf(n#y}i z0eMsRuBkkl$baS6HI?5!H5X6GbDR8nfZ?piZgcKe1fs$vYN>d})RL8pnsZ!Rp55BA zzIchXa#f?<#3^F3t!Z5w1BuqvD|s(j+St}K539oxyQHzDsdZ_iZLVC@+PJc*XyqbA zH_pJ?b=k^At8-2Bb4~W_HBGkNytE0+_WVJ*WMmuSdHMG5bnZG&3p2FS*jcN&Ffh%s zS2l{s!#btHI<3g>(RH5J6kW7r>Kbo@dm-PQg zS(rd1c4*yo31@uGnRl1w zzOLqWaCfppS8SK=&>wxx7Tcw}F5P|IgH->cHQF6}d;+83?>88!?(pZ-u=CJ$Zs6ZK z5Ewe1@ZUW*@V)om-Qb)XaLx?yya3M%@SMPPYxe%-(&L(cS^W0hZ`^g}kPmr2fM)`D z7J%mf-d(tE*ER2bG3(Ot@6P`HGfy|+1;*|ffE-NWJsK{4-1i@aznd{NdK!PngAUIm z%U=IR;JL5QJ^ed?!x z+rM3#ozAvqV2{z=)C}!Yy7#pamL({Ol32_Lao)^Yrt6k4q zE6pf{xX)Mff$Fa3tsSGNw%mkG!XR|L1~y#k@ft(S$&kOsJ8KW}|FR(N*!ebdpX z93DLGdfs|_U!)T1LI1n^rpxu|cIP!LbFAjpwr}8Jb?(pZwDJ8Dxkp=lmvQQqz4rf3 z*?XH$<8$85e(kQuBrj|zpZTL(n;+Qp+3BTM`uA@)_gnJ|`Pdl`$dJLcI-iSS2J|8|2c76}SJZR5n#hrcP>#^6{j^nf6 z#(~-!*%t6~_KlYyt~w6?g}*-`&1rxmpnCyy*8;a0{Ffsf#k~M=*CXw;ke~a+Pz2~{$vkd8KyOX}^;rGedZLaxp7Jd<50r|);C(jr2H6)s_0wT6RxH%Bi!gnS3 zo&yTKJr9E)hkfn3FJquYx$g3G#)!4N1Pn&i_0d{r`%c|Mx($T|56D zfUtr4{)^?|{8ki)y4t?SzR$v=2ia{W4!&SwIG#+{CUN*>6FY-=$hJ89jpIoW)@+L~ zU*k`Mylz|MoxM52#zC*qD#09RiDtMx*3*V$gE~tV)JYkh9PflItc`Mz4an!_*TZcf z(F*g+nXiFgfUr8BS7&8E5C`!>W#68s@)saks8A|du(v$BuJ6D^^#*Kdbwn}B4Yva4jlvOnKBS-9*kf-F>aa`V^w@p#}S zRCbc&*ZT<|43(XPot1q6p5B?-221C89cIRNaL{l5yN*5sMkBX}k-tQDA<@|FNt9p4 zyODIqUb2jIy(Gc+_QkGqLz_2aePRO!?l=a*lOSF1JH!j>WHl@J{==?wL*eD9u5&}~ zdk=Sz_Z@b@{U==alv!e}T940{WvpeHwiQj8##|2Hm1${i%4OOt z!Q@snF16MQU1mumIAs>Emxw9*9xx&^Z$)!1ga1ssv}su*-lRJsGs|jg0;Z8UwXMkb zI54NB%{k@_X&?%cwpwi&ygxM8OmUFu%EqH0)(X6P)f2)e*4h=#pi>1wYI}8SD?h)+ z(%y`}9lqYBT5!?zPMN#p{szC-*NMJQ#Uyu!w-fpY{;dej(kC~!t!!NN4V-XQ2AOQX z@Q+kkBl2$GcWs*CQ7jy-;GrFUeQ>fIzgml<7flFz-!I`830H!K2ax#N#+2h5TFdC& zsg|g}IN$S}h;m&+-dinS4g40M==2%W8g^|g!fRnq0*E86@+X_!xZvLgeC-dL-?Hs3 zU-whH-?Gs;aBK0bz2?oGGHK3U_~c|Pf~*F9%6E=;H|ofYY>ngqBb}_;`)8Nlb5as- z&d#iA{LRTF>4xuDj=Jo=?iA}x2yesli%y4g8BP@z~AnTGkZI{-@-ZX{~Lbm zfmcVJTl-k=`*(j~Rs6!4J$l@>;H0LXO2w-)<|iY(6aM2mWie$@?T6Vjq&jd#w27rBxu?7Voj} z4>vLOQHG0gPHe(uI*G=b)-_{o~oW-m46J|jY zuPHAqOcs^&DlI84F6q;=ynCh&jGpKHGRaJJ}PIV(kjTtj0J#5$A z8%9qUQ9ouhnM4W;3rmViDoaZ%M-QwTIQrlIZQX2?CGq9V9Q$2IIae#+FnrcK{_#>~0% z<{x;_f`boPf+6+t70pNH+E%YwyKen4Cw=SWZ=Z7NcTPL!d*A=Tx##`x{0lZ+e#Mnn zU46~9*WL8&seUAfnH1hRLMf+Dnq%V@i@M5&vHegYgzEJc)`F?X3t6cCmN3~ zA2j-eWUt9*Uv}d?g@fx4_o)Gx5WV8> z>5Z!|DPMQ_em6h;(LVQFb@|QbKHP8pen)2xFS&BnBLnKc^~H$drAE!&8z&V0^v}l) zeCn2kE302^-m_)(K5Kt_;ch$KbJkCffBM|SiZ2G9xNdO$y6*RU_S;h?%)jcecV1|E z?THtro$>M$^|cEhIOxru*SspB3w|>raQg^ZBAn9(v`E|7z{nZ9)2)4{y2o z#Y--J`Iz@#`Q!2LUb6N1ZEd#f7=x$YT}`>GDR0w9eKSq@!@JAgx#Ppz&OLX0RqY+G zPkVW7rn-2=W2gV_xy;YUuDT}q`yprbdfG~Ua`l``4t=_<|3MF*^YMNck2!b6q_T(3 zxpu|*Q+m#OwekDsM5@X!9&_w$YuyFielq--zqOtFWaSk%P5$8W-VM)Pdg6isKOFoc zyXJ-y$MnAOv74XTXW^-9YhFHV#+s9dUHsbjE7nKq)}FKe!G=FwTyX4_JH55&&?B2) zyl~btcfGsim2T($?Wdo=`_!(pcl37KqpRI^wcG!4yZy^Q7rtKF{Ly_kJ+b!w*yua| zdUjRO73Q*{%|GwC>c?kae6`W{yZ3C_`KcH0J?Mh!Yj?h6=*`z$Uw6b`&u%*O{)cZr zckagM6=&^w&#tdO``r(Bd%N+et8e`FpYFYJ@5gW1^tT@@xc1SfD|b8LPiMB~=Bz9K zO~u%M{G;c7D|6A)Z>zuSp zh5M|0>cipP4*T%7k3QIQM{lw>Vzv?J^{u``$~} z-}mdk6h3tAJNp^O@91sH=;{W$y21Z)H~8*HTaBJCKfLZA|M0-&fXOWt<;*v>~1S)9;53yJ_8%o1Y!`?4C#ce8kX$M!$I2 zYm(lyDwX-1@??ublnCs?XlPf9#8E*WC8}{=fRy#pf;>_k0>nlr#QYu>`ZjuP5qd zB4_>f_43<(LD`?hU&{MpH=mMqzKYH0$V(B~n#?t|wQg%lgb> zZZXQHXr_5t=D@j`oYf*9-OFY0$IhAUqZjcpOceY3y3XUsx~ zu2*qE16#KSUcD8DyI#fR*yx6@ZRh{nU&Un@ljqKytiEh(7E3voQzTBNu%%Vj3sO z^~boTjH;L!D>CNB-UI%q7&-hrc4^GS8;nT#2f2QRYhUA*_;vA~#(i<}`8dwl;(|vb z1B_h?u8W(-;Ru_?@wgTl7Z<#T>&FFuF6d^&6QAPCsDp9sY3!Y-j}9_UNZ5&#ab?0p zEOxHYj8D<(~_jWK(0T*wVUy53Hg_meu{6B z-d1KOOe58k<(ksdjCC`bdNSYJde%p~86P0r%~;y&Q`0nl-;0vpp1LkRz<3c?(@0m4 z^C5CQR<3VW60>_BUVn${0OQPlq`whY(|EOtCGD2}=YS$(C%I0R>q5D<$@TRA)83oF z$yHVP7=tK5TKKEpfP)Qz^E82-Ib(FZ&Y<>QIYPTV!O-` z_oxg+WEDnG7{NgWamx$}Q4n!lh>S}{To@OG!5_cx_ndd@y{hUC(Vz4C%>VaKpl{uC z*K^N3_ndRjz3)8@Z`JT&4S%3vB+gn*@!EK~Bs9EMQ~puIhvTH)(;EI%!;5PglYttp=a^_^F&z(#RH)(hP;YHq;CzBt3ig>x4RaaIwSr*ojGJSPy;fr;j zswfb}G;MKR@+3#DA#q^QVyyH%)s1-TL??XzB+%;`M zq+A}>lE*YRK7I7`a#=rp+4L&unax$);vETAGL>`;P7K&!G{A*^j{7!_$at%^y z(9C zG_r+vHL|rkH2$#0BlF2`XKOeOA^2oIXa8gKNsR|I{v6^}Qo4Y3&tJrLHZNj)*CN&( zSTq{*b%UmiUCfkOi#gKQEan(f8vdt-l}p(2!X<1irQxj_epSOCBE-XnOIfC7=?nN2 za?{euOUKG)4ZpecQ+4I?;?keg*T|e@r0r^iW z$GN!VJmPSsp~uk=$8fJg{~^Bu^rpz^ z2!|r$5MHa{bsBzB!+RqWkp7^?zpml8G<-tCA87b94PVf3T9j0}Ke`;@H=^eww3h!Z z%3hw0u0&W8!)dyV)6n{w8DmM-t(FI3mw?tU$6k-{jH2yG-&4f8*7CcHNa+t15!+jf zuEJcdDgH3R^%`EP;p;U_7Jn4!of`IP_!bS{rny5JKZwwJ^yJ6IO8t`0qUAXypF_C3 z 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 Z0;ec&iUOx7aEbz_C~%4b|8G*@e*?2S@csY* diff --git a/packages/NUnit.Runners.2.6.3/tools/lib/nunit.core.dll b/packages/NUnit.Runners.2.6.3/tools/lib/nunit.core.dll deleted file mode 100644 index b306faeed071434b0f26fd13cc71af5772864acc..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 155648 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 diff --git a/packages/NUnit.Runners.2.6.3/tools/lib/nunit.core.interfaces.dll b/packages/NUnit.Runners.2.6.3/tools/lib/nunit.core.interfaces.dll deleted file mode 100644 index 4053b0ddac1462ba0c8fbba9855ef309fa44bfd6..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 61440 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 diff --git a/packages/NUnit.Runners.2.6.3/tools/lib/nunit.uiexception.dll b/packages/NUnit.Runners.2.6.3/tools/lib/nunit.uiexception.dll deleted file mode 100644 index 34f2f4ef9f31ab8adb02a1a7918ac772972cb557..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 90112 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

  • Q5&I! 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

    6Qr0z0UhqRvgR(vBsda_$FJ31@hlq0 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 E8+^?ry8r+H diff --git a/packages/NUnit.Runners.2.6.3/tools/lib/nunit.util.dll b/packages/NUnit.Runners.2.6.3/tools/lib/nunit.util.dll deleted file mode 100644 index 122eff440fdcdaa9d024314ef07ff0d6628bf07c..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 135168 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 R_{UCi?_U&X}5wvFu^+becJ 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 O2Ra<+aNz$<4*YLl-@M(u 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 GBk&()3WhTP diff --git a/packages/NUnit.Runners.2.6.3/tools/nunit-agent-x86.exe.config b/packages/NUnit.Runners.2.6.3/tools/nunit-agent-x86.exe.config deleted file mode 100644 index de2caf6..0000000 --- a/packages/NUnit.Runners.2.6.3/tools/nunit-agent-x86.exe.config +++ /dev/null @@ -1,37 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - \ No newline at end of file diff --git a/packages/NUnit.Runners.2.6.3/tools/nunit-agent.exe b/packages/NUnit.Runners.2.6.3/tools/nunit-agent.exe deleted file mode 100644 index 6f057bc214022bb9565b4997ecff028e5f96e54c..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 8192 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 - - - - - - - - - - - - - - - - - - - - - \ No newline at end of file diff --git a/packages/NUnit.Runners.2.6.3/tools/nunit-console-x86.exe b/packages/NUnit.Runners.2.6.3/tools/nunit-console-x86.exe deleted file mode 100644 index c71d21ff0d8380c7d9c31dfdfa6992b47421727f..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 5120 zcmeHKO>87r5w5nqj@KJoCJ9kih~@1#B)f^HJsz8l33hg7$4=H8|KSM2l80{ptGVT6?v3 zsmHot4G`g<2Gh~kp2AzU&uX|e~w4akq>$g;?Y+T z7WgoNXSAFcFRaC^kwc<#2u9b-Gz}iROQSEXFU;Y66a7P;d&7^m(C3Ef)=Qu6q4V7N zz?!7T#V-OF2@&LihWi&6^ddQ+BjgEvMb{o4$U5!e;0tSvLyf$k*BZ>1(#$*HrSIIG&*8bqMWJDqL%Zp*9r6Ze)CKi^>Oa zq61pl`j&PRT5`OQY&VGvIR;6TO6@hh?L+KEAr<3T2V4F@#Y=o$Opt6_%|ss!&*|7T zUV~Ln3QJMYaKeL=f>i@Q+~lO76g3WvSF4{Qsu-uL1IO%~oVB4%d@6v2a62-A!{{9U zOf5ue+p9H==yj~OW6=x~FVKi*(C~b1%G&IDu8t`kkV$LWclL#gJM$5Fo+v>`ye-f7 zlCDsk*g+~+ij}(2PPJp=xDsv(-pbaFa-Q@m$rk^Ei$A)4^QWb^cYgBM-#_+-p@BEQ z{f&)_Q}2EcCuZQY!%(yOlw}Pw8R+9|8hHJWKfd(lKW^>yK4c9%V$qN!O}3RZ_}ECw z4O?_R&8EoIaN;dGCtZ9>er3_&FORlMT`65v`CKla&F3cas#JH7Y+9{GNKboc@Kn9r zl)B{vI#!#uTGo3zp4k~wOP*VIw699Gs_aE$s^}xJJyo>TMr5KeiKE@q?B%d-F0WSW zh;l=fjN{dyR`h+f#@Q6BH63H$bk!z$%A(8Sg~EO8sHB}&D%w_E&W>1gA#Y!^C+&&J z{4~z%fF&PS!V$+;sM7QJrg0j}Q8>TvYB>Pdy=X5+;O?~U4c?qrnODr6Z0-A{Be`9Q z%>2HVV<|^gYrE?6cOMnV=SdZW`-J>IBG4oEsY32Qf#s*uYN`uJdQ+{QF3A-3TxXZ={#tft#zw%h`n%wj@ zP2j%IV+LR5izuEfiBKYQLSXf~5Qo%k;mrb5_nKMShYhx=!7+v(SodIS5qwRoFvbQQ zh$l6w!xs|V$Hx?1!RS?dZ1NJzJY|KO09BCGVaouM2fK<^VKepFrXj@oSc41N>X6@1mSM?0`@K*un$1m2Z(HP&SetXF|nB=VxfoPG8%UKHsDWCl+NFL_sX zG5TQmaxH&z;_oWf<*ens=ao56J;XD$#w#Z~-^t&K>!AJ_fQ6L41k7i4Y`o^u2PoMImttMCOmeuB=L&oO-e z*T0>)z90B%H!bL9GZS_$qjcy-Rs6=8&8$~m%uZ)ioH$|C@uN`BW)5_mx&Fe?;0#J% zDO42qX~O4Yw~mrA&IX=qqBz>-k~w(Zi359gBBKH)^tN@JvO2GN1}kyUb>m4vLM2@3~U^*-oR88BZ-FrWq$(e?B0dd`9MB?O3}_gEd=y zj2Qh&6F7Bs)p)z8L2D?Q9?Z+hwpE4Jv4axBZE{t-sCQ9p`AlasPP`EAMmySMRMRWE zsBsa-ZO4yw%PBE3ehQj4^zmcZXU30$0ELn9NZ=Mnff Dgi;4h diff --git a/packages/NUnit.Runners.2.6.3/tools/nunit-console-x86.exe.config b/packages/NUnit.Runners.2.6.3/tools/nunit-console-x86.exe.config deleted file mode 100644 index 81e5346..0000000 --- a/packages/NUnit.Runners.2.6.3/tools/nunit-console-x86.exe.config +++ /dev/null @@ -1,24 +0,0 @@ - - - - - - - - - - - - - - - - - diff --git a/packages/NUnit.Runners.2.6.3/tools/nunit-console.exe b/packages/NUnit.Runners.2.6.3/tools/nunit-console.exe deleted file mode 100644 index 8d65c8257cf6857e10dad63307e57a88166b33ba..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 5120 zcmeHKO>A4o5uPW>vMgJIo3ufUrtX?b0yz<%C`xtQK#ECIiYr@^S&@>Hwy5>=xFTQl z_#U(GQ9nHdI`juEdI(S;hn{-Ksiy)p5VuW`9(zgAOLGp8Q+f#s^icGW^qYC4NJdhj zqL&89N;^9{GdnvoJNtIH{GHdSpNIy~KmC;GAx3UFf&UpCfIa&4-;dIRbMIYwXf3^W zrCjqO)i7bzICbSZK@i4jQ!CR9lozP^yCqc*E7~3z8Gf>*y0}2JWcAZuZ`@mL@Ad)p zS?8@GBK*^ELVfLNj0!!6&Ol-4OY8usa`5Q1Xs2FR@I5%jK>Bf8l&6?B8+ipI9}(HUweqCcJ?vM@(y>;9|uXvPv7 zu=Y#TH$H*`9DbGtpSj#OJ_`Jqo2A<~EzzFXx|6jt_BS%mWuN11&X5oI0E@?7Ls;O$ z5c*gtHeOJTSYjNB${`qAD^UhGPM5}Rtu4-D%wc}OYj67DCg$9*+`9FZK03#fe_7M? zSmGOuVV-m>A)cQ{XPi6pIQbaoFx;XXV1vF7_!EI|3VcW4`vU(i@PfrMPYJvu@MqR5 z)*$^_;QLk%T0gPIL~o)!iN{5Hg2oU5o)s0d-=Gz-peC~)KVE{jY?nnZBe*5{GF=jQ zMc`F|Qv$y!FfVXX;I{?740wqgz>DMwd{y>1C%7V)E|X2qVzlW|Dgb_!76HfTCBXBP z0i34GmJQwl;2n`E(K_(&(tT@!1`arOgSdMiPQz5RKf%c)n#tTEIqDv%G5RP81<~ws zSZVtD1qzyh7pL7Yh(cf6dQVfqccN&DR@T6<3khSj83fu;J#s_idz)0+k78Y?yPL0Q zH>PFB3&?ik(2!%0Knd4g)muK;UKmh5igbO`-!FTyuk$eyZL=BcL-M?iT;nxZ^eD3s z)*DW+f0R))@WG9bG74d1-+0y9F|4w2D!T5N?W3#KwTX^3U@_PVP2FMZ9REZqL~6^c zHjT)2w6|l?3}UaY5zl(V^R+2yv*WosqJ$ueR<-Z!2^MwMBl5gZf)IO~p6|t7q3Ah1 zDwXr)n$b?Bv%E(jjTeHCv2~i9DE&&(<bB7<^!AsQI0|=;)0e@%nXD?-5aEU@7{{wZ zEbsejl`|<)t2)A&>55JCv_)6M3x#*sQE@w`RJf(OoV{q#`K*1-p0=l^v)6G?hb;N1 z60SDBF6F+*?ir`C5(W!4m!y0{2quz2L(M7*~uPZS8l3=zbwI3wv6wqFht0 z?TXLec~l%vk;)171^9o6K%cy)3U}afm~$OtuT{xQRXl-SJBH5dKcfT`xq7Z71$!(#jAB6;|je9oZCACAAiDn2l1|aINg6Z z-Vkn5A9kq~>O7zYtqvLJ@lbnc=nQC!Lg7D2Y*-mw2h<3BhhoTum?iBu15ZH2f=w}` zJkYDhX!>VA%VZA!W@r;Q(Tu$A1?a1zvfw@T;gN%x7WFH%2AT)mHe?KR6V0Piu@3i` zhh&7;n)hz>*w$H_#v9ERM}X`hpX-G#9qXVOa65iwvEMa$>1~?Ad!NM$e$3}lP+Ah9 zSk?rv)$g)6pk~Y7G;HeL(}w(>?EQ1=0dy<@ugYq+tpUH;gDTbF1Bt!8G)3c}Ud6{I zD^bi+TCgcV1x^jR3~ceBS5Xl<6JKo_L5z>?agx3a&P37e))_>=?;#EfK5E*fZRj_E z6QC>ucV%CVec1+EOxVhAnok=Mj zxM2mqY35REG=+~N|s{=5^_?VYKVsyl(VrK7l23?{oll~RYw7AqQsTfE<65q^ZhssJ_1Txxkg z-)Q)rD+QnJG#aVNL_=(vQOq^xDecLoWF7X7wA(b;vo#0B=vSMtQ&)<{+d;Vz3i#Ym-tK8Ln{Ve - - - - - - - - - - - - - - - - diff --git a/packages/NUnit.Runners.2.6.3/tools/nunit-editor.exe b/packages/NUnit.Runners.2.6.3/tools/nunit-editor.exe deleted file mode 100644 index 640a253323d927153719155130d9e3be41ffb43d..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 143360 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�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 W1)J diff --git a/packages/NUnit.Runners.2.6.3/tools/nunit-x86.exe.config b/packages/NUnit.Runners.2.6.3/tools/nunit-x86.exe.config deleted file mode 100644 index 9301f94..0000000 --- a/packages/NUnit.Runners.2.6.3/tools/nunit-x86.exe.config +++ /dev/null @@ -1,23 +0,0 @@ - - - - - - - - - - - - - - - - - diff --git a/packages/NUnit.Runners.2.6.3/tools/nunit.exe b/packages/NUnit.Runners.2.6.3/tools/nunit.exe deleted file mode 100644 index 5cd35b91af5ce85ac67c690130d44a7e08b97150..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 6656 zcmeHLO>7&-6@Dwrsw~HX3a5b$qwbh?0y&Y^6y-QhD%qszpUSahR-)|wq4A0wky|Zy znc1Z*_0Z_j0tI{sdI;hk>brWdiyDd3AH;_qatYdFZ#9qrEs6l?p@&+Bs^5D{iljst zZqOWxc*uG4-n=(&-h1OwCuWug+ecQI(*m?LB+?j?`7>&JkU*cF@PCuTD2+ zdq7>*ZmX9Fe;SB;r=CNrP}8Uk6q>HsZeU_Rx3q$aelA^<{;?QiKmdL9IC^!GxRiYUdzK5W+%>~Jp$Te`7>TH2bv31SQoz1MZ1_- zvqtHe*f$O%cv3M$!nzwR<6N1?fo7b;@FLlO-=|A}HGw}9_)CF*5cn5?YXbLLEcvp) zCF@&O54|n$ca{yU53B>CH`dPau;9tlbN~@xJg1ob7LADoWubnuF9R92%c2ViZU*xE z1s)Q3RN#ofmjz}7P6+&_z;6TYCkJqVT!F949J>TpRG@?K^99NQ?xn8-9stLt!;}Qv zEpU`}!-p)T0ACfE8Oj3xF81*db+2&jdhks7XcVTRyaOlWXvVZf&kE8ib(sDbhk|Hq zGAPzOeTw{=??$#>(vBs6CthUYLVXPKC8omajPu4m6;7HRmWf6%E%d5 zT!^+ZvO#s(xTSIjR^B*8U2)99)=^iq2|F4v;m-%A;;?m&x2;q*@aNr9&4^r6dm|P# zKXNPDW@lVan;C5u-GUA&?vO##+H;l!3!CGoGOdf)of&kw%)&x_Z0e97wVvuLLz2Oc1jM*SA;inAp!CA<>e zvuNel8>^uPvqx1bnM@6*k|QaVEj!31t#U!&;nmdFQ7(C0U34lsR99^^rLQlzW?@K8 zx`nc%J(aap{(3N^G9I$kRT*1d2~6NeVX)XqUlQ{sQz}k!MLi#E}779A2#6ke>3iW+I7f_c^A;ebWEQ}zja)E*g4oy5lLwd5&DbdVn>`L1WK z8mBrH_~(`iTJjqU6#z&E$zz1+5Ml=y7p&($MMCJO#o(LTp$bTnD`&_zp#o3qZx?PWLBRI14sKkaE#q z>Y(WZkxAn1AODWi95ABeayrREUxlhN$1*%}Kxt7wMYGW8LbnYW1Km8P2lF+oJqyVY zrw*RG+GbmGEYV4vD4S!hV2r`2rXMNjKY==mIs%x&2tIto_Hjfa8RNq?uf;+iC%J}w znwG@s8`fRSbqRP$q}jVFEsKRE>;yiuZ|zewh~A^5FgM32MZoE?2Uxf|@pEO;k1?V?`L+F_VUXXb;W?~yyE)S_d_!*g> zeRk2$XFP>W;#K18h!Ed^79ZQbWZhr(oc$|9D|=f7m4!|Rc&V<9XJ(70rH>=ZeoVuX z5Y=E-O-0D!ERUVmx)yOJ7s0PcJQpy6OEXs#bh0)Fl{4Cbrlz!lPxIh3<(qjKpR_My z3|q=Ofpevir%c6J-6>~=B&Ty28(_W~;vThRS*v|G-byaF%Wlr-?eaM-V>9rOBUQmJ z^pKgnZtXi_yYU>WK~#mBMz!Sm0Ho!4$IpANaaoC<#49TV3>7~h_wV0F%RTsDfIojY zkOq*yA*?g_oD1f7WLZUl0KiQYM(XrKrf=2hwbfN-iok7%Gkt4){UHxv8iO81L%fZ@ znO^za9h@q0X8c#eLKzp}aJb?YOb`b1(QqNCyyAovdvPS8Dvs~Y>oBTcbK}{dN~sNH6Ge@? zY_!~F5k4ltDj!$1@x%N2s0%fNIqNif zjDEcaJ9RN<+(q1|OSmIGo|mHytqP^72Un{?jqmuE^djz-9>ej36HfSx!GbmkRdX{1 z+}IJudB+QN-6>IWtb;WT(~q^;K6Y#)2oM-M)>t7B@p?ajUyul>_&aRw#23WhCvLVy F;6IY<{igr` diff --git a/packages/NUnit.Runners.2.6.3/tools/nunit.exe.config b/packages/NUnit.Runners.2.6.3/tools/nunit.exe.config deleted file mode 100644 index 9301f94..0000000 --- a/packages/NUnit.Runners.2.6.3/tools/nunit.exe.config +++ /dev/null @@ -1,23 +0,0 @@ - - - - - - - - - - - - - - - - - diff --git a/packages/NUnit.Runners.2.6.3/tools/nunit.framework.dll b/packages/NUnit.Runners.2.6.3/tools/nunit.framework.dll deleted file mode 100644 index 780727f219d08aa635e12a56a326850ef82dbec5..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 151552 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%0ANEfz#`T+5knLeJ%5cmKE0sc26YHG1oPt)XZ; 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≺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 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - \ No newline at end of file diff --git a/packages/NUnit.Runners.2.6.3/tools/pnunit-launcher.exe b/packages/NUnit.Runners.2.6.3/tools/pnunit-launcher.exe deleted file mode 100644 index edc56d3276a82552a7549afc38878b09e538ec8a..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 36864 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 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - \ No newline at end of file diff --git a/packages/NUnit.Runners.2.6.3/tools/pnunit.framework.dll b/packages/NUnit.Runners.2.6.3/tools/pnunit.framework.dll deleted file mode 100644 index 573b9fcb729b6f7c31d3a2f2f81f199349aa1b5e..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 9728 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 E3;KotZ~y=R diff --git a/packages/NUnit.Runners.2.6.3/tools/runpnunit.bat b/packages/NUnit.Runners.2.6.3/tools/runpnunit.bat deleted file mode 100644 index 43b3a69..0000000 --- a/packages/NUnit.Runners.2.6.3/tools/runpnunit.bat +++ /dev/null @@ -1,3 +0,0 @@ -start pnunit-agent 8080 . -start pnunit-agent 8081 . -pnunit-launcher test.conf diff --git a/packages/NUnit.Runners.2.6.3/tools/test.conf b/packages/NUnit.Runners.2.6.3/tools/test.conf deleted file mode 100644 index ce825eb..0000000 --- a/packages/NUnit.Runners.2.6.3/tools/test.conf +++ /dev/null @@ -1,82 +0,0 @@ - - - - - - - - - - - Testing - - - Testing - pnunit.tests.dll - TestLibraries.Testing.EqualTo19 - $agent_host:8080 - - - - - - - Parallel_Tests - - - ParallelTest_A_Test - pnunit.tests.dll - TestLibraries.ParallelExample.ParallelTest_A - $agent_host:8080 - - - 2 - - - - ParallelTest_B_Test - pnunit.tests.dll - TestLibraries.ParallelExample.ParallelTest_B - $agent_host:8080 - - 1 - - - - - - - - - Parallel_Barriers - - - Parallel_Barriers_TestA - pnunit.tests.dll - TestLibraries.ParallelExampleWithBarriers.ParallelTestWithBarriersA - $agent_host:8080 - - - - START_BARRIER - WAIT_BARRIER - - - - Parallel_Barriers_TestB - pnunit.tests.dll - TestLibraries.ParallelExampleWithBarriers.ParallelTestWithBarriersB - $agent_host:8081 - - - - START_BARRIER - WAIT_BARRIER - - - - - - - - \ No newline at end of file diff --git a/packages/repositories.config b/packages/repositories.config index c216dd1..f1c5939 100644 --- a/packages/repositories.config +++ b/packages/repositories.config @@ -1,6 +1,7 @@  + \ No newline at end of file From 4e5af689f668a2c2bc66e28812abcd20eeda5a4a Mon Sep 17 00:00:00 2001 From: Eric Fontana Date: Wed, 8 Apr 2015 08:15:17 -0400 Subject: [PATCH 02/14] Removed redundant Finished() call per Markus Review comments. --- TimberWinR/Inputs/UdpInputListener.cs | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/TimberWinR/Inputs/UdpInputListener.cs b/TimberWinR/Inputs/UdpInputListener.cs index 615611c..bb74075 100644 --- a/TimberWinR/Inputs/UdpInputListener.cs +++ b/TimberWinR/Inputs/UdpInputListener.cs @@ -55,9 +55,7 @@ namespace TimberWinR.Inputs _udpListenerV6.Close(); // wait for completion of the threads - _listenThreadV6.Join(); - - Finished(); + _listenThreadV6.Join(); base.Shutdown(); } From e8a54782e4fddd6eed57c53eb4d901fcac53e479 Mon Sep 17 00:00:00 2001 From: Eric Fontana Date: Wed, 8 Apr 2015 08:49:55 -0400 Subject: [PATCH 03/14] Remove extra Start call for standalone operation. --- TimberWinR/Inputs/UdpInputListener.cs | 7 ++++--- TimberWinR/Manager.cs | 3 +-- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/TimberWinR/Inputs/UdpInputListener.cs b/TimberWinR/Inputs/UdpInputListener.cs index bb74075..020cc23 100644 --- a/TimberWinR/Inputs/UdpInputListener.cs +++ b/TimberWinR/Inputs/UdpInputListener.cs @@ -38,8 +38,7 @@ namespace TimberWinR.Inputs { _port = port; - LogManager.GetCurrentClassLogger().Info("Udp Input on Port {0} Ready", _port); - + _receivedMessages = 0; _listenThreadV6 = new Thread(StartListener); @@ -74,7 +73,9 @@ namespace TimberWinR.Inputs dualModeSocket.Bind(groupV6); _udpListenerV6 = new UdpClient(); - _udpListenerV6.Client = dualModeSocket; + _udpListenerV6.Client = dualModeSocket; + + LogManager.GetCurrentClassLogger().Info("Udp Input on Port {0} Ready", groupV6); string lastMessage = ""; try diff --git a/TimberWinR/Manager.cs b/TimberWinR/Manager.cs index 3417691..ee15bdb 100644 --- a/TimberWinR/Manager.cs +++ b/TimberWinR/Manager.cs @@ -152,8 +152,7 @@ namespace TimberWinR if (processConfiguration) { - ProcessConfiguration(cancelToken, Config); - Start(cancelToken); + ProcessConfiguration(cancelToken, Config); } } From 7f6e56323830af4cae40769550742d66f79f59c8 Mon Sep 17 00:00:00 2001 From: Eric Fontana Date: Wed, 8 Apr 2015 10:58:27 -0400 Subject: [PATCH 04/14] Enhanced to log JSON errors to Redis/Elasticsearch --- TimberWinR.ServiceHost/Program.cs | 5 +++ TimberWinR.TestGenerator/Program.cs | 2 +- TimberWinR/Inputs/TcpInputListener.cs | 4 +++ TimberWinR/Inputs/UdpInputListener.cs | 7 +++- TimberWinR/LogErrors.cs | 48 +++++++++++++++++++++++++++ TimberWinR/TimberWinR.csproj | 1 + 6 files changed, 65 insertions(+), 2 deletions(-) create mode 100644 TimberWinR/LogErrors.cs diff --git a/TimberWinR.ServiceHost/Program.cs b/TimberWinR.ServiceHost/Program.cs index 73d2b44..94ec34b 100644 --- a/TimberWinR.ServiceHost/Program.cs +++ b/TimberWinR.ServiceHost/Program.cs @@ -7,7 +7,9 @@ using System.Text; using System.Text.RegularExpressions; using System.Threading; using System.Threading.Tasks; +using System.Xml; using Microsoft.Win32; + using TimberWinR.Outputs; using TimberWinR.ServiceHost; using TimberWinR.Inputs; @@ -26,6 +28,9 @@ namespace TimberWinR.ServiceHost private static void Main(string[] args) { + + + Arguments arguments = new Arguments(); HostFactory.Run(hostConfigurator => diff --git a/TimberWinR.TestGenerator/Program.cs b/TimberWinR.TestGenerator/Program.cs index 18cc313..5711f74 100644 --- a/TimberWinR.TestGenerator/Program.cs +++ b/TimberWinR.TestGenerator/Program.cs @@ -15,6 +15,7 @@ using NLog; using NLog.Config; using NLog.Targets; using ServiceStack.Text.Jsv; +using TimberWinR.Parser; namespace TimberWinR.TestGenerator @@ -54,7 +55,6 @@ namespace TimberWinR.TestGenerator ramCounter.CategoryName = "Memory"; ramCounter.CounterName = "% Committed Bytes In Use"; - Options = new CommandLineOptions(); diff --git a/TimberWinR/Inputs/TcpInputListener.cs b/TimberWinR/Inputs/TcpInputListener.cs index 64db158..ae7a37e 100644 --- a/TimberWinR/Inputs/TcpInputListener.cs +++ b/TimberWinR/Inputs/TcpInputListener.cs @@ -113,6 +113,10 @@ namespace TimberWinR.Inputs } catch (Exception ex) { + var jex1 = LogErrors.LogException("Bad Json", ex); + if (jex1 != null) + ProcessJson(jex1); + LogManager.GetCurrentClassLogger().Warn(ex); } diff --git a/TimberWinR/Inputs/UdpInputListener.cs b/TimberWinR/Inputs/UdpInputListener.cs index 020cc23..d7f0cd7 100644 --- a/TimberWinR/Inputs/UdpInputListener.cs +++ b/TimberWinR/Inputs/UdpInputListener.cs @@ -96,9 +96,14 @@ namespace TimberWinR.Inputs break; } catch (Exception ex) - { + { + var jex1 = LogErrors.LogException(string.Format("Invalid JSON: {0}", lastMessage), ex); + if (jex1 != null) + ProcessJson(jex1); + LogManager.GetCurrentClassLogger().Warn("Bad JSON: {0}", lastMessage); LogManager.GetCurrentClassLogger().Warn(ex); + Interlocked.Increment(ref _parsedErrors); } } diff --git a/TimberWinR/LogErrors.cs b/TimberWinR/LogErrors.cs new file mode 100644 index 0000000..698f09a --- /dev/null +++ b/TimberWinR/LogErrors.cs @@ -0,0 +1,48 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using Newtonsoft.Json; +using Newtonsoft.Json.Linq; +using Newtonsoft.Json.Serialization; +using TimberWinR.Parser; + +namespace TimberWinR +{ + public class LogErrors + { + public static JObject LogException(Exception ex) + { + return LogException("Exception", ex); + } + + public static JObject LogException(string errorMessage, Exception ex) + { + JObject result = new JObject(); + result["type"] = "TimberWinR-Error"; + result["ErrorMessage"] = errorMessage; + + try + { + JsonConvert.DefaultSettings = () => new JsonSerializerSettings + { + Formatting = Formatting.Indented, + NullValueHandling = NullValueHandling.Ignore + }; + + var exJson = JObject.Parse(JsonConvert.SerializeObject(ex)); + + result.Merge(exJson, new JsonMergeSettings + { + MergeArrayHandling = MergeArrayHandling.Replace + }); + return result; + } + catch (Exception ex1) + { + result["ErrorMessage"] = ex1.ToString(); + return result; + } + } + } +} diff --git a/TimberWinR/TimberWinR.csproj b/TimberWinR/TimberWinR.csproj index 4ad3c76..cd0fb73 100644 --- a/TimberWinR/TimberWinR.csproj +++ b/TimberWinR/TimberWinR.csproj @@ -111,6 +111,7 @@ + From b43e26fc0124e332dbb1f2c7221784ce3eeae7a4 Mon Sep 17 00:00:00 2001 From: Eric Fontana Date: Wed, 8 Apr 2015 12:16:15 -0400 Subject: [PATCH 05/14] Cleaned up checked in packages. --- .nuget/NuGet.exe | Bin 17408 -> 1664512 bytes .../System.Linq.Dynamic.1.0.3.nupkg | Bin 22441 -> 0 bytes .../lib/net40/System.Linq.Dynamic.dll | Bin 48128 -> 0 bytes packages/Topshelf.3.1.3/Topshelf.3.1.3.nupkg | Bin 259779 -> 0 bytes .../Topshelf.3.1.3/lib/net35/Topshelf.dll | Bin 245248 -> 0 bytes .../lib/net40-full/Topshelf.dll | Bin 278016 -> 0 bytes packages/repositories.config | 2 +- 7 files changed, 1 insertion(+), 1 deletion(-) delete mode 100644 packages/System.Linq.Dynamic.1.0.3/System.Linq.Dynamic.1.0.3.nupkg delete mode 100644 packages/System.Linq.Dynamic.1.0.3/lib/net40/System.Linq.Dynamic.dll delete mode 100644 packages/Topshelf.3.1.3/Topshelf.3.1.3.nupkg delete mode 100644 packages/Topshelf.3.1.3/lib/net35/Topshelf.dll delete mode 100644 packages/Topshelf.3.1.3/lib/net40-full/Topshelf.dll diff --git a/.nuget/NuGet.exe b/.nuget/NuGet.exe index 9218fe93fd0cca8b015af1577ec4b1742b8a044e..9ca66594f912a1fe7aec510819006fb1a80bc1a9 100644 GIT binary patch literal 1664512 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

  • Lwf^r%-H@DzHh{LVwhYNrsj2GP&c=G(6JpHscs7` z2^Y{xOR!=RV^bcFPPLlsQm}p-YSpRZv3&N1r%Loxn?Za&mULg3blnPwP)^0NdOXYu z+E$IPNk`G6^cz=O<1V>OIkv|U?%;2#5!8S<4o6+FmdZlq*=@Dp%&GFj}^dRha2Z7~j6NXJ=>NU8~Is z+ByO8OR){#6PU<1+1%h@LpLbFK+{V9{bkYWaVRu|tPA+Z;Rk`~=s3=U@jW>zFN;s(wRBqOrytopyfltqLZa z^9Sn1d2D!)-7`}@LGk8|nW-Da(iFF))r#O#kxhq1zAwZ9??2%dmn>oAyX&>5!+#i#JNO8^szn z%c{)h7wRJSnR$esokU`{*0gWy)`Ho*Xcsw}1~jZvY}WM{Zr<1b?XY3^o{92i&)<6x zX%powE{ic%>|`*$gpgvjX7?OR222mOTqxD*c6cuHH39vfU)7xUv|vQE|MM>VBD!~# z&!E!1`rYT;r0VxdB+LIt$W*{hM)Y0=%;SjOS7*48gb~cM-WWmgK81a~g3FcuYZN_W zPe%Q!uX=vfQmrD!`AT)Rh}{(&HtSfkxL&-50?U{IVmAd$`uz20u{F6kQ|CVAcRB1< zD~r_%7fz5^EMY{T|Al;MN7H=d{ErM^rI%-yH3xXAIjatpyW?&r%#toONm zYV5+Nq$`&Hu+`oyx-%z7kJ^2uSFnj5`)*-Du)U%z`wkF+lTD^^e*L)#8W?YihbiAu zjmGFKW_I<8EW#odIzC^%GJg~ABw>jW25SK?Rlsm9E@G-UhyAUe5(#Cl#us9YLx(e_ z``SwP&hG(irwO>-fw6Qf#pLrzZ}7BJ&_K)-<6@of#@*XN&~NwstDqL#m&Sc*cy?j= zzsFmq{>u@s%r0Cj&CYyFcDrzU@z{}*&%ef%ek3}-`trh+MQn1J!op;8Y~+i4w=WO^ zffojI0ROsN#9KfZp-5K5)@_EN=xWcF=C3bd_i1q+j=Z%PSi|l;cmAa-uf%s0)?)p4 zk%If7_sN($>c(7pffcMV&Af+E^Q^yV>@xs><^K~4A%3?_R`4Pvc0L|CJC66{kJ(7# zxysaRsfzcFO6Aw*XK!CzsxwOEExs{^6%$juCJr=uZDwxHQj8ScyIbhH*;(n&GG1X` zKtJA`fuoI0PE*(l!R`3P`GrFZiwulOn7S%aviSu}iqHl4iybKC&;F=@ake|1vr{^! zZljNk?P(W%1~mG96XK2CXIU^)8lwKkZa8 zW@4)w4{zf*o72Dq z%6$X{-zodzXU490X4kv8Z}jdPz57N_-w3_$Hux{nes+xBr^v)TR507?avZETkv1m! z&e@HaHQ>h()4<8UcG=+kEk^cb2lC7mUzdwnBzV#-5>)NW<7FP|`1ZvM*no*sXSh^U z9Rb;Pe}zI$cX$TN6GxApc;4TT>A%e5&cb!e70nL#6YCdxlQV$JmmWFK9nX4zF5X6# zn7%#8(mp4N!Gi99ijqRqGs4%u<%(uEGtD+|>SAmPV$Nb_9PFI`14*!6! zEE%(OAw|9#^Sk zcQf0r#hb;@Hfw|MUJ#<16>PA?hmB%vkloYyob2iJPGqn~A-Jcr*(~gTdv3OfEt+C^ zzJ(1|jGRuDxH@(N%a91DVrjH?4~nGa#hZeB!BJYx9-G0+_`MRr-hz2V?ezuQ8RPQG z5Kj^_=21jS$_Qi3E-dm5CEtv=z3TT+u^z;Rc=WJ4JJQ;Unmv9~Y=sT`&!U)?w<+KQu6 zwtBCHk=S`X3umSKCEObwk#Oq0Df;0;?1>1E6wHq3K?(9c z_-C~X07L&E0(&w)4wJQBp|`8%UZTqjyTH;v;2oLJWKQ-wbE3yWHnl;lN%woP`z72P zya-hNV>#~OxEVVM`Akm$BZr0fi%=dmybGMD?VWWJ9dWy_n)KMY+JDcS4qr5ht{Cpf zZx8twB74Xeiq~crrto4F_99enVLt?pSi%|`cZbf%yUcZYDQmg}$(8+jdwnWN;X6Oq zy}G&E$}WP8M=3i!$w-4H_tuF#}R9boHsA~ zXK(q3mv*mqah#VMF*?d`nBc=-HY)fULSGsal#Rm^^A~Z3TctXQ*D*`=CAIG8>)+Z*%6U5dsIY|ew*uEUofo9*#Ycw5eN;5=KN83fB=eJy7_#5~*gOnIWy^D*Uj zBwS&WvVoq8Juj$#+bp}Hb7X9?qs1q@Mkf#_=2F#EzIG$7Gd>9C=RHviEEfe0MRU^yy ztMTcRMhEJ1@3Y(mFYewqvV$5#K6;q(1b~+(ta&RhOf4;O(NH!$&leeX6}XM>X$t_(5fXa9B34mzfTEX&^uITLSIW@q#hc6cR;ALo9a-xcOdxeM3i zP+hpLm}}!*Yn*C|!$WHPa&)tcL#GgL2^XihipG2;tX1CBQzUh=j;9#d>}nfU20uMD z5wYP*$W3$Yj(pT+VGO#6h3E479aE1fCbcVZ08+OndOC+(4$LT)u~z|oP{ym&a)jSK zDKzp4^MI8|eCF1XrZcyWzg0N^b*oozv!OT|0ISI}{OXV$^m%^POchTgKr}stL$$bn z!|#UsSO4_h6TaW)|3v$Iym_a}v)n@}dsSs`i93kGjd^qWnc-p`N0?)A?R*Y{CQgw3 zU-C5muLUMR)e3^=^Tm1W_0c6RJ+60Q3P*b2v<#l^j6H0=y+joZjxNYrOJtv*Va|*l^Dz%qx`+MeIui{%_|9E>cixzZ+mPZn`I!TJXJcdIP_z|a> z>Dy;vq_Jc;F+aT!-dZ@UpL??hxZ+!H7l^#*R>L`-DAqd(z_$;N8F5v%eLHNIsZ+34FxYdcdv26 znJsLZ)uoV zl4W(_8s0HRyzNFMpz1iZnqDQNa6|#R%zm~~75?sdY!S_sTWlZ+td->z-rDQL1G%U( zKuxvNg^ovmY$Rw0}|%sr@R>C zk)BOG1Cl&Ec)n-o!J&zP&2qa(eoKX+qEZzHkbUdMO+zcc-h>>b!T_$9e}crfnfS=Y zO@qrH;i~Zy-u?)GR=+{g<&S#?B?L??BVk=dAva$gKOXG*|cXXZhL$1{5OT3 zo-J}Sv~qH2)()1qgTpr^ly{rdk2K|zz(^?<83`8U%P|9%3ic z^>-NjE1=sN4>9@wXY5@7?5e8!|9#JW&Sd6h?#Y7$X2Jvm280MmaH2sI4HXnxP*A9` zCN;5%5=&}ggM~WxF)xK0G*nWP3N_JCNlg?hC@5*6LM0k3C}>cqLBp@0s8B-%{eQk| z@3Zesq`&_!nK@_eb=KZ{?X}lhd+o&rUoU)ov9%}17!A=;&67}PlHly%+e%-fP`+PK4ax1d64AYCkV9nbo@ zwNZvUEtlC+eVwWE77^W`%gws1)@7G32Ou-I`YsYO*x`rsX=7g{9epU!j6T#qImoNN zJn82_|Fpx?rop2R&GcA|sy|@7TKJNhUAfLOvwBA#qP8Hf1}s!;t0`YoK z3jJgd#we+@{ydk){0_?I@g@W`x8X!^t0htRhRdM(W+*1S#vzEeuDc=Kid$t%6v&IKf-C9cDdx(^er2ggn$(Sk1)QDi~zq z>Qbi+>2i-WL!MHj)I(zGWK~2bHipbCBYsiV8u#h)fbu+=vC=r0(H_h?ym2tAuemKT z8@WdPd{b_UDcf#IxtSxSdY60eJ;h}%1?HwW2!^<+=;njeZcfztc7@acxx~s=v^(H- zY1fK&2lzCoObu2T8#G1*%SASZIv)A*WB1)|;-$QdvsQ+o#HcjQZPDF~T^&HQEBe|^ z^nX?W{(uyUgrCiH33y$s@=i5?PB8w|`ORpLP06lV&}Eya_dfbA`N-c+EtPG!|_dEcI}Dk;D7G58=`4Uc(XQrH zX_p*XQ^8gJF~;4Zy8L{vJxwepZC)T1GKG@F$L>l{AIYax49Zwv6MD@H=>au>pV?Ux zG6eiTq()@vHfx8YlbG{xJX!aLvSZC5a`QDmYEK(GGZkoM2p)^!X=={BnE}>!ruCij zC#~6-#n_|PF15ax6y^7tJ(=35HBoI2SpP(fulb-MqjU1fwypSdHJ0JiWDV_TRx%@Q z?8IfI^|ihUzVIiLv`HwkCN?WWfc|}4eNAAy+2Xk@4sSyT;(zg&^VONs^_Ftt)aq*y zz*#0Z6H@aA@nq((0~M*?9n7ph9hbJW7Te>CDS^jn^X51#%aSU3Xx?+79_}#B88Bt4 zHRZ}Qyw#c-&pg?al6N*3)!%^w_FcdCV zrm(G6R(|VgjVEC&55w`MW1uF2qQ5(znupvZFJaNu5Q2x|85^MLi=uvI2p-FT4pW&e zlAE~B#y$;OQcrR zAfkZArhGPtLIQyT5%c541VoG@7Qsi>zra~cAw60IBjYVG=}Q$$1WYEf#!zhb^CkzI z5BkB&rn@$5B%!}FQ8NVBc9@x!lrg8=bd@^ASJ;7QvyUqxaUht6Y^Us{K))ssq*N`iTp=5jm?=d>fXn;=V@Y%c zJ84X9Vv#(I%CC?bIW_p3i6wMyV~;LOhSL%G$<}jRCN2`$CgHZ}vO*6Y*X2Q7F4g54 zT^`frelCrbf*$5FqTqI9m0I0oilu_q33H_`gr2pL>jiDmMM3Du@w%L$ORq#?lX^H+ zCyeaVJa#=J;uVGTs(ws5B!}yHrPYoiLuFO66`A4FQ~M(wbF{1a`$KyhL#z`F=@~-` z7Y2^H8s0nveqr0*z9KK6*&kHBJug?&7=WC2ns$Z8uUFPUASC^A@Ih9LeyP#FNNT!V&1zoL+JZ}9K zO>583nOHE1DNZFfi#~p0s;X2ipoxK}IBA{ahgFlmxmf;9Vr*V2ai`69*o3x?srE;T z<;C=>ba8+62#P4{y3I1w)vbbfv-K1U?ZrmpX==}UJ7V!g^kr#)etZNj#+H!G9IO#_ zKA_NsWIwhv8z>u6(=i)|GzhMsvwQ=A{ft7st$v>91vR&+40S}dekLzQ(#PI512*-* zXoz^SZdzkzeVdXBM02Xc2ckLY#f6|u(wD%!%6^1POXUn-tIKU%>JJCW!-VXpsore1 zxHPUiTy-pLYj;2*^=MwNdQjp1tR;1oJTCofO%)^)9KS?Kw3jg`b2T=I34Mk*)FQw> z`BEGMGd#N^0Ppi#3&o$X#vFeld9uhJ)O^GMCLI)x*SW&`9W7L4CZiJgDzcM1WFf!s|Z&q z4ko#3wLD19#rPpo+>K^Nw-STi^!TJqKkLu^-GhcgDAkI~F&JT&{e8LOEN9B6TQQmC zcwo0`b&{yUI%@&AKkrq=W*B;Cz zu!m{yFR3Ao{S|KZNZ8>Wh8^CaOqW9vb#wTD|7#EhCNa{X+eTUI+ z^Yq)4XfCrvbD8H|o?PhRJ%%3Mqw@N#!k$WKU4NIchOBr1>4RKZQMc;+4GXr0F`$To zS@isXhPNK-1-H`jbTmY)n|LuVo!Id&k;sT(W=ye53TwF<-Zov zdOF>}w0?Yn?9w4nX4$QcWg0|4**i5Np^p0wj>+COA1ZE075oj=q=3`~7{phVESiTr zmN5)fL@t4Pt*!S*BAL)tv3`v!Q}3BogF&mFlF(> ze>GDspOk#*{-A4RF-lT*Da9oDOuB(7wR}qL9QA(f9QsWwOrm0t#V`xGbcTW(5S6s2 zD875(FYQ5HolrQ3O6DAD;@I|KGE8^oB~UmOErknyqh6WhdsZV~MO}b?BVDf|u!bOz zBR9BVYIw-ZiPb*@OEnpRBx~AM??KDyGpSn?ohGAKdwKTYCTWQYg86zEO(O}^Gl*g$ zo9mUJ3||D*m}RIq8U65mszoRdYT9Z=Wi!j|LVcLj zqb`)h^0YUZ;aiNo;aj3$SV)b6Vc-R(M|uWj!0@8ZBS(@Bx4PiaT+I+Jfd}RX(SR-;OHgCBbKEg}1|WXfYw@0M0YPzBNQ8mU6YmOlw(VK#!PP@u*T|D8q%G(!)^2 z&1a>tBnBoA7FdI0VS`-*_7ZUZF6|9WS&s_(YU)YoL=p3Qm%0U$xzP zLEDMNq@-(phz{fy-5$;A~a2N#m(`hJls8-(9Pf=wW-3>fQ7XnY^+*HCG~ z*>A-RdVN?Ada~2Nu|8 zs-w7dtF_{)ZXT=NBh!@Q!zNAUJ=Qp+XuYTr2`1#^()t-v6LX$z0e6Y4o-?xg5-&AB z@sZ@~IeWY{(l>UQ=F09jMr7R&`P&U)3uAH`kofon-L5kr%U>ASHpuNvQ9R{#8@>ry zeH5bDHCRY}X*=uEh+Ni2`anV@Z)hVoOp1QH3k~5RyQWK#0t&V?I;Q%Hh}_UduA?N& zqP#)R%{2bF* zN%Icrdxb?(;rp@Z3h}j}8V|}|y)&(kGcY5zE^j=XKahH%#;uLGt@uDDL}CN^vCws9 z0$a?`>o?$pdoWG5fPvEH0fIJo+}f8m&cbA|*kqE1hviV*au{4y)r^VDa~hDV)yZby z?KHkufuGFnW{YkZTSYRKfqjZYPZH{+)Aj3I+awRO6&-$;xv#l&oXi+wN0 z$B-lWcbOuv3cagrEF_i5&W|HEu*j})gg{8+iVZEt_T_xM+A$SkQ&1_^DrUJ_pT(!w z7zQcKa+AP#iSSffO&>J&c@Z`Cneqh;k{Epmruum_BIL5Iayc!zFE8 zVxFC+Qz>bd^9vsm1gkT%oOvuilO_zGZk1`W=!0@WIDWWO8mObsfEi3p75>EUeYtlAyyX)^;`x7Y9+ zeDRFsx2n{Jvto`{+0En0?=@!Yz+fpWW;4x|YHsGJL0Uh6{b{55`ExW}2~nMd_kOyE9J;K9>m&~wW@ zb*c@=@^xwUhwUp^&_k*9_j8b7EOR@f!OG+{A}<*X7bU3t7?Q>Uc$E#ldq z;8@!p;y1NHg4bYyp?kMl(?XVZ;KkXbjF3UkdvFUJ+Cwco@gSRD@1KMW#U;N%7)y*{ zw!%FC=S$!mjb4wnYP9l4DHytFU`!%92sMcTrK1&^u83N2j~-qh5*7L0KCFW%nQ11_ zke?D`=TnG}?<=5c^YPe(jSUU%YCukWDlMs6UBno8-QnA)iEt4z3pTxuRFgS_MXwi{ zewyDtFUdT3(4Xcu(}l(cf%lYXEb!r7Y60T^Vx z8X(T7n5SvAEF`DtCZQd^H(G@mQrvn>+B%3GyBSoGFZLkI2|wxBT=fjS#F(VXrq*E$ ztW2Ws`~b|vQ_9Z5y>84u8DNEnDo}lcMNkS+8wV3se_5G8%TBhZ+?qwNPw%Nx0E-O3NodV`1%PJouJ4A$er^`4T9JK0 ze8!1(LkwXXA&lla7-fj%o@rx&7OT|7zBnW@GYcQp4pm3^q*%ejr*^;^HE4opIxF^^ z$iZZrE^6&GV=eB>gokm|Xsl?fAId7zX);%!tZH%;mHIt_6@J|tb)MyBIj<1RU}her z!r2r;OWNH*!lE?FAcNt#v)akk3STbE@&id@MHnyq$uEr;%EG}ddfVHM_t{y>7fLG3 zin0@4nyQ4H6b>l2sWTHcjG050O8S<`o75N>#5Jp!+=ZDE9(ST=2955-`7+Yb<(*G# zY=}joB`O+5%=P0XZ3Ky9{U)1UZ9vhMYrsnDo6Kc1gWP0tfVtM4#+`zUro;bmH4j{^ zF`igOcC9rZ!D(siVu^t51CbXdV+d-NqD&4s`ru5%naqnD>gOjL^4yr07UQE@G`0Td zyN(m^qRPv^2v2;Vh{oJM~sy({IVc zkG#d_Q}F~O4u4AU&%EdN(7xRJsBI17;hLkZ+|I*mwhP*bZx1m)Jy#sbZonteP}w9YI@UgIf7X}rc$47C(Cd>dyBZewuZ>g7Cqn|1$8 z%*qDT`ertl=q>c)Iyz@zm%(ya>bySrEi{}kL1FbdJ_Ko=!%;gMLkx<(Ww#&4FeNsZ zI|_ZS1AbwWdA;UEa9gdJ>3i5VK>EE;#Qfxvo`nTQ_x{O7=8=opEtL?)?om6&?%{a` zOHMDZY#%XvN{reV*)~AANcFV;fAe zsveb+_>~qjNGVf>lcW)%jR4OAcp;crNSXgPnVLsLx%nP=#o^mj#vCxcowuJet#Q7bP+>w0r`#ACLA zkR?Ju$}XG4DKDz!gViwZ0q>P;9br%=8BZw66`6r~j5n-5zMMsno`4Wk(@c6)|Uq-Qc}Zm6FEkr@b z^~&=%TkRrRc*~9=P!h<6lY!8jCfg2pcwdG&k@2*CW7-_2IVuQBmRS^7O+zP)&=y{j zN`|q81{?F(abuT-?PX-Ph<;I_Y?igOGlKaoO6!-{&PW~fB?&GEUIB;~DE`Ppo#I8Z zR(^bm!BQ6VhXiAn=35nRHumhmeH3OnR$>^BV6c97LhMAZ_RVsWt^9Bli$IhTv_Z)a zdgd-FrJGxV2{vz+05#RVAw>5` zgLxztXo86mq!0aB43K-xal{6M?|(ypmcJdq{3xH}sM2R{LUOaU{pNj`VvbEUYAj?Vo?Ue-Wt6yTFu$`c_&JkpK=nvC|G2$IGC#)R! zy@W`@*;=0u5?~g0(S4CG>P8ZN0dtY;WAYL--MOHNJREIHC zJ&MOv;w`NMPj05zIEF%C92Ru&!0QPxtEl!wCx%(OVEv~6RzVj2Ks#YMogn5W0@K^e z;)?nzuYp<`_HE|`R_HP7Oxl=Kq|9u|18U}Jkb2fP%XTb;yTF`~O2SXJ6U3Jr;}doP zE-(ivvK7`>9ek@_tI45&|7 zy7%J@)%u+pz0775OqF+eQ*K=gB^JKjZ@8haS{@Hm{sM|_eImIref0LX){Nbj6Bv7y zXbqa3v<59P$0z))u?ns9?Yo+;0&Jg^uJ#h7%f}!U?58G{SqW+r%oHYWJ9R#xBov@c zsk|-Jy^XPMWCg9m(DBcW6=IQ@Ee*?Vt=2Je+nS!J8#ehHcB0fG@3q1MTe#~Pq!r6W zNuG{%8hL;uZO3SS6qx0vI>wG8T|7rg7!waW)y-LC$;T`aCJuXelpN}jNH8`)#-rcx z1IN`t$tEIgyrne}fj+~$#uJkQ=XT}pnp@~b35|8B7sCBHPq1In4nB>}TFld5m~M5M zWu=@+lm0ZfnRnGH)CE|IB`8s+#r>{ob76TfH&FD+fg&%hFqY|l6jjn_j-dLZ!%R2)DZSY1 z>%Hmlbyh$uSGuBFTG=7`S;{h^<35t}@11WX7PM_L{}`hb5vz7S9k+@+5>Xi+9dc3A z4w`5>qqx1s)w=Vt#JEY73(8a5P(*d6H-9%P_~5@;nC1$|WHA)^YBE;Ve# zMzc6qNfhxgjCKpbbO?>&f+X64R28RWfsL=oX#5IZ1Ut_664@F$<4Wu6)hq&+BgHK` z9V#|Mr+nD3l=U>>sRbeGWrC_Mj!9T2h0^eRh0e6km~ddv6EH?5Nju&T3)}5@zrE5e z@6gs0^5M{4dKh1xMP3F9o+vw2U^*Oe6k_^MGgeF&v$0(<|55VR9TLhOm=`}1FEudD z+1-Cs780s|y^N@h5YRe5s|mhm1l9Vz_iZfn%3i9$ViZX)hxH6aa81I$PeX(eAA1bZ zi&a9$u%_qFIr*(d4Z>_cqR{O${T3`hqR6Ox`b4v#sdau|p3iLw&ncf;9-r!q_X40W#fYdVtqtiUDg~%)Pqg<-0T~^Bo#o zM7u+cTSBd_xTs`jFc<_?LQteGU%kkHy17M28?Lrk0uZo7hJsKP+3p~FI$1HZ+|h=V zvZ?UH9&+ABhB8NcK)?48OdnbOgFrGFgv!pcR7q2U-(4_O^`>Y8>vA=RWkow*!D%B8 ztY=iqh7!f&>#K3J(Hfxfxt=kQ%!=0e8IV8&?3K6kU0^S#HEHW!#t7t)5yk{%>T?`= zGcL)9S+X}jLWMd-V-INQdVbIXLEc$$_p{Q*Zqv!uUT)~>ZY#*jR4_rK>sp24rm4KQ zqPZ$K{#cN?6Uk+0(*jg+r!R3QF<;tx5bM3ai&Y%n#M7~MAdI@dOZ(!Liebdv%&Ki& zbJrfeF!QUWQ`I%hSvlV74`(#?uzb(ElWfj&m6KdfX}uCYfL&z29#2?b0moZ%)MN4I z$VF-E5rbNfq$8IT>{b0O$BkNfXnalWLxpn9Q%US+L0B$fvv|wl4T2A>x1MVWc5Im z&7%NXOZ}91WJNmC%Ug=PqiCh}mdQABNuMo|v>vn6hLF0{3VobH;YnSibX|KVwmK;w zWAT0~tfp)I+R~sc!LZeVS@q#0T9464&Xx4LQjZxqgHo6>rz2;0Vt72m zSQW=8>0+G_fvv#*GKo&D#p%0_F$X z=_rQQ%!IilJ&h}V%-}&kAL3mfW0>~gLqZ@G=GCpX&vQo`qo!@ zi&5+{zF2(UXW91oHAvown&PAf;mv{tHdFONpmE(OGcQr9<;}%48i0dkQzrW|kP7Co zn=MUcr@>?^Hj6Pn?UaJA%0Rki3hfOWYN&{vpXduR&=S2p@+F4z0%oh~J!_73{o&a< z)0gDC*6-Ep41|Pfy{(KkkF)aIABy2?W-p6%zv@yfKvcSXae!f<|8R=CyZ_O$nH@}0! zK%lV&FRMLxTHD)Y#mw2)8*dvj%ch$ID{t%Y<_<_vN|pWfmNBf)B-wNGp%DC zd8VQzb(TNEZ99qhigad`!?zlkM14G%Tsm9eZ0SHcJDoj+d?BdS%`#?%@*Ybr<$Ge# zpU6Oyo?@?3rl%;%uSo#!5wCm%@9rFjF4vz)-;5b*GqSOww@cEM*GSah6WyCXPL9fecx5ARW| z!4$B{m-H+sW;UqT*9u-FQ5KcKgtk*6xg<_R%?>B8S5=ruBFuv0MQX`mAa*m-;dtKg zQ&Rid@Gn%OLl67xg{=P2$mcBVKCF>a@ZlFGAw`<15s`pOYg&C)d0Ljz#Eo&yl%D8*(kG@Upk6Px>|jKL{L9V<5hieT0bSNpJ@2Ak(`QEJ-pyu8$Hpq z>fDq!$xv2UNbBd9B;)#pv;LR9@g0S{sZtv*H92Sli3m}itSPW(%B*&or>|;^C@sE9*yv?T5GKd48j4unK6=aK-bdD`u#MU+k>@HJ1thX*47_X z%S{CMI2Nfm5agvmyLZd?z`I831XeiOk=9>8q0{=a82CV~{v3wuouZ7MC+eNXG@F?; zj#p?GX0>1w15?Xyxs$4m?$Hw z#yfZmmj*I;`PV~bw2Q5dl|D4p_h4tfm^#~gN)*cT`DJb#EMC(MTigJz=t5(FuhM#m z0R#PUDb+eOYhObfl=#*DE{9<>bcTf1$;LIkz$kp+wj8|ib)8hdvDudVuVX5{Ic;34 z4zLqHdEPEZ{srd-{L1O@2+Gji$2Z=+m7te?j6sQB)U2)a-MZG-%AEDO;951Nf}>`= z0k>`ztZ&6k$*};H&&Diyq9~NwC~wNa)aYVqUt@3D*poKy)zHznAEq@SW&}c=y3l*$ zjlEE{f3>xfVcF&n)Xi9q{OW55_>P8e1un+ReeKk~JbJ`-IIQJn5isa#E%16`4!m&| zfea;VrQWlG?;{++jDp`_xrknxmGjRy1@Q+lS}5Ctv1C8 z%`&G}&F81m^x>zF`ZQInX;5wSY-@6u6DjLV(6Re-QwH;rwI(pIC_sU|d;@|zA0@#a zhVMm528!PEW^0!XqCLf8TTR|)sp&-wWuPe0H03*M&9h`eOdHQHV+PH0?VV`FGEK8B z+W@CIwb6?i+OQYiD97-c??9AOJS%!bng_j%sm2rEX#GrI zTXRORFS$M~7%0T8^f(SV4UbgxTd~qM8%NC>EwNS60O2!15Ye3ya@mrGMi*&obEp3y z>_Ra(U#9=?%*tF)%B`$Duyl`H<)k%l&PE|CZg|4PjmRieM`#$%G!Us7bvehhc^g6? zeMc4Xs^U9*NN5g=$$_^DQY`n;EBGY50RCF8**fBWj>CCHlG)+;X1T)yBtP<)Vlp_0 zcNvn`r#M}(v6?>14fN9>9aI=7)<&1ZJt_qrl`(-lQ5#)Z8(nSkdqTRzz$)SU7u##2 zYkY(?y4IifZFRv8(F%qF$akEmTF%!uBW?8#q|ImB?sYd&YT7zpgVN$Qc4wJtG=$4Y zYOPZ!haT(q?G%NrN$>@fqu#0CsNTV^ z(<}vXH}cNDjZ3xG_88zI?tFA22H-|$_bk6Dv4%l=k6yz~TW4!7Y|~)6N*p8E3Lg>= zQqR`W78ADQI6B%DLz#&A4KlYjDDqY${ipPaSUbp<|l!2TbfD5eoQudK<# ziQb#yg%9r>-wod1nUN)db_~9O(pPBwHuf^!-D~PY zZ|#+!7>4VN==Ta%7w$zxdpN&?)8wDRKUc&viYq_H5K0)sa**U{^7=r@d^b@YQ{p_G zJCH}hxR=1d+^lD__~P&mmYw*)l4h!(JFPE{?~R>paCZS?(R*@%n$-^rve#m(@+$Qg zL4b`Y>u{!E8b_&oevj59 zmIE!opQ*|97mV-a?82PiEiSAV8lUj(7L}>#QwO=1!*-+chp97;>np6S`WB1w=^*IR2zg-%w;|%zsV)2& zg-}atqoub*23iF}+-%o_Y6xEufcxfb!`z@N9|X{~$MZ8l`CW#XD@68Ix+<{7Zz_;| zzRGCzs65_N73@VlB$&5bg*n-t-e=bbtiVTw=Zpf^=AOtRJz4=_Of(DjaGNsm-W7z6 z1-gz|kxkE{*l4ya(+(rwV&o49u5UK{0qYPu>@LRrVRzp?JIHRNmqjVAvI5o$%Nb*? z94^*%j;@V^ZB~aY3uer6w+cS&IG~aF6Mj~bwTr_nBFv7jh&w`FU8Ta>mDP2VGO%f= ztCU{*uDbRb<}tfos%!mP!(X5)o>X~F1xBvyRWJ zV8um2&}|K~y&65{9HB3cjSB&?j!C{9wm)Gs)&*?nLeJE@%%e{ zCzXq7S9)T4+CYD`tIRs~0g|T;mN^l@U+FOc>Td%P7U%6Kr@o?i?m+*s<;m6l0oGh_ z$2?0{^JDtQ5{UlylneIxMqd3N=$}(A`_YUsPJ$v zRhg{HK2ywS7lXQ)3$uU5a%?5-8|W|ac{Ba79EKde1(!Asr1fp3a-ODCrj^Tl8j{6Y zMqGPwoB@QD1zM{~0znC>sjBjPEh!uS{@O!E-!O_P>icQW)X2rjnidCZc!`#ek3G|4 zb#l&&N;meE%Q(#eedx@8nWnE?A}@`_t?<K>tw`Fmi~2>3kvh@n0=TQWd<#)^N3# zq9fyz)lYn-QTt;=9d~nF|9e5 z?X<$SRbm&ljeYhq{8cBZ(&w$XYQCJS9$%h>PQm`da7#xkbVhw9m*E|ZRn}#tvKDY> z&nkE88S@fW!%i7U>!;bzDQTVAFi%jp&W<35`t4kw`+Tu6+GETde@xlSs9w`LuPqQG zVM^{z7oJh>^=i%)qv$oXNi?H|T}W(Q+vjP~HTp;~A4JqaSeUOKS7tZ2i=t&P{;H6S zEo1ei{%*;Vp4&}ro)R_s`CKj?G|V6co|>L| zQh5@(tv;}?wxso)*!9jAz0H=4R4V?;iZBxi0ynsV_Rw0+{+6{EgzC(O@x~(0Rr_kW zZNHl}Od3e_l#6pJqMTAccE_ZMC<116$cpSjCj|25y&TEh<6wLtZmZMdK!^*#A?lt~ zXRD*daJ|CB_j$j*ju3tI_=ldU+J#$NW%= zC=exKompyoy>E-^U^@){8;f{uZf|QZ9_PyRO5gFY*QF9sq~TjsJ9@st4-vz+fWnWN zb>7ma!Q+5NrRF-mD=j}EBke~bVv3w6mHX1slhf8z{WK4>J4dF;ES1CM3}0M^uRFyY zzVGYNQ$s&{mXVtEzHR^DJk!RVFu-R*kwZFqMmjuMy<@PazW5j7fxLp ztlargwWefC7$Pf3I~cEadCCRO3{((33A!wS0&kXQ>W>rE77xFYTJz~yG8YT2xC|gh z{lW!*?JpfYr;;lCP@f~Av+QR9v6Pg_hcRNHUNbh%v+D(Ry+lLmd;^!N>7&cASJays zm&{_tASz}~%3lY#(G|p09@*F-vc}m)yh>VI89;d&XIrd=9nf?pe?BgflF0%a@8Bnh zK4mIj;#L_ipuf0BE*KA6Kxtz=n?K&y1$$ShX=dW} zk0AzLWj1MJByCJs+z?p3TnrEInPlUVvsH`|LsQo5b@=aebb~ifW5v9S#dpd{h%f0} zY1d)9w(L4?*Q+h?yOw<;_Kea|LWnbj_t())1}`zn>kZznVKIMv80YO>Mf?S|FGo{3 zhRnN*=oD{X^4q2&t~iW}w5T>hwb2US(ko35rqkLe(R22fVaOdt5K_O)H;=QoLgSUx zC3u1gqo5zP^kGci0!0ogn43AjHC>XLFzaRob+>PS#!+f%MmXSAmeXurhOC;bNk?yB z%L|3b%li3qjV6J0c3o!IrN;cWsq&VZU9I!QHMXatJB}%Ha2pSS1xVNL)+%Y^Ui-NN zdp5sh?&W3ze*EeH8`Wv!K}7&;S6qu8-DY+8KHCM1)mweH*!5PgBnM6)9P$4BmhA4E zaEs^Z797{@Nn$bgSvVD%GI}RAVTIf^O^T;))bIhv(R;kCc2!^pgp2^U!e}cAl0yUg!m>m8r|<15DT^ z`^IQP<$RLKY~x{P{Q9HS(AbwY_TkuQ^youb^Z5`YDTPitZjCZCEL-A`FQHe>+} zWzou=uk=x%84T?D0-MH0eWQ^!`5zO-R(VPti=u{~1Z%v-E(q{^_*2Sbeov zn+!x&Hl1poL1(6;Pgj$dmD98_6_3%p5JO^`n@xDLnQsSf5?n53j<2zkLCglc#?_uM;?JXtYlTG!D9~J`NkmTW~N%j_Pl+=*;r3-Pjh6EW6b}2L$bTc8T0C@ zF{J2a8QFIizx>@W)S01QuPCw5azQGGcX(!vBTS^&wr$qa=6c}Qlxsvl>~k99>}#@2 zF9M&l$(Lsl7?gZIK_L|t$Dbu>eaXq@+K>3toXQi6i$FEe@G&+u<4J>i5+ZU<|0(zS z*qyvMBv(3on_R`%jI(a`epbeOgE0rS||$Ps)!Lx=n< zjvNRAn;Tkxlh#T(bdkWKN28??W1KX#8qlFID$zwz;37Y;YM{Xi8DfX^io) zG-qYxVA$0c+1Mh>$&7OfcC=d&?P4>gv2%#*G(_0m$}v8mu-52^9F5Ygxr&?lsj&-$ zP z9b1}?ElXyKDL+@X?$f%EPfnH`Nztd8bPSm_t_o>Z0L=yYN9ovQ>DcAgWTRG-$JR0S znRGUsiT4`2(vOh7FOOL2%aGEN_JR9XD%9S_I;_h#vyTyhFRe!doN#K%}CpL%Cpw& zv(oTSc4`Fa*k>-}u8L{vas`6TC-_PHbas2lb)xa~EKSdp)IVqyXG&pOIyWM-v}m#4 zUlEF*`f4QrC*FM4Rv&L?l_?#&$HuSK0LRJq$Pw6w#rD%W3+K6VAfD%ecI-YL*t}|N zpIM(bod+-i@z$E=(+`oR5oRd#tZHoW_7^j-)zvQAGnXP(vPkjGFQi+A?WB~Ehn2TKkxZ(ZDeynZjIiT zs%Xp)A4v-Wwm#i(IwO=-gv;WUos7hstiD1Pr)P#S?&cWR9rT^V_+}#-FfD9%Eiy$> zvahPW)^F&rEeA#W&&eujtE??AjAqLyC^JCWXVk>|I59YzDvGTTY<)hRd?WME8~H?< zgw`DAhh;l4r%fF*xaC1ng|IRTlG!*O%I|EM?Qkpt+0j?~n9HZl`>HI0gb+1Gs@5$C za<$|--e+xA6h@SwN8?lZu?nUVx@hNxsfV_9K+DL&cgwO35L@(a2PX?@lp>LMhsnSp zr$!k``SWV0(Nty#MN_}}X7f1BE!L;E%O5q_K_j#pA(vchZbB+{<`CY?}VMa?JS+MkE;3wWqvstM#pQR-`)ywBi)#rSo47A+=h#VI3 zGhITES?Qbqbf?Y6Y;Dk*uDFd=LS_U{YA+9u(743=Os&RI7KH~@T4bxOdJ&tEUi&FL zY#xwT>`Ghbu!D6Zx%I*fyAp9Rfh3m10V+!Qu-l*R1dhl&6uW>9+@DrlK=6cDrjeLpNEc-B5TbnFDE3kxwGR^7nH}OJD08{+Q0jb|ylNN7o^=MfzOUz-;I)3s% z9+`78J*2WAS!QvrP9|S6OEh zp-9zOK+((%d%%l_};tj#fA_qW+3i;?zu z2pdC|q%D3Hv4UaxYI@4$oH7$L8WKLs)!5}zi^7evXngSNo1j8)=Hwf@QfR%umnvva z0ZRYhj9q~w?;8Z=R|5$GqUbtb{g*%1F>n}vI=Q&lcTJ0(ooaHHc8UL=vuCXg zWt#i6>7)Y5@fF%V@Z&-ik7MQ1Rz4aQ71mOHavjv^pYhmQa+#@>;`kvt^YZqH!a%yN zy=s>!4?zJB82@pI_#1h~pwy-eS6bBBI@O9EmK#3odtn4a>G*is&>T~&aD%)g zU&B48Jp#O!-NVl*H2L#sxyp`Y1XXq85Rv~uUQcf?(VefUGQT0sy=pD=c6L)6$o@nOcmd1LiXYhy+@rd zmkYSZ>*INb)}Oc}d{tl_lmLqRGRCY%oAfu9G9aeo4}?}*bi_Wz?h}oh=g<&FVAL%9 zDRT;Fk=_R8ON= zP7D7yc)tub{;08iKvzBkuC8O$-|}idk=3A)j(d$))f`d=mBme}q+@vDV?r9+HWJ6O z>ZCnBRbrRR$~8?`RGi&2ouzr>PySzupt0%TtsljuKRtFzqU6N~_9C2};4GNpP zS&*(UUE2frG=f!zTKNrwQ1>}ZRmxfbC1w+rl~kSls&~Cfj>s0ZZMV<9aMzhM324?n zQK3I9Mc2hI3@LE(`-J2)IrU@%2oZid(Pwe4MmDQl0@89iOZ45G2=gi>x~am~yIxtI z3?L$ZAOuvKhIL(1vZ)Rv8rr2r!(uwY5j-oT+wY}zU6Ku|QZ6`n(VKr{XEp+pF9K7C zRjN_|)Xs*@`zPjDo9E6WVxBnJq{9<$QnrN^z}?#BY~73G*YJ}J>DU4dF%o64vtg}! zJu(n`S|-D1g=`=+t)Dp6do&A@C(f`vd_Kh^9UWqM&>EET!c4mc?>i?JYH1;D?UmwT z6?<7}^+d*$9BT`ozL)P3vz8$spGVc{VE(e8UIFv)jt=YX^LL2YhD- zd{+m2PX~No2dw3sjE4t0;DoH47$2_?O0s;Tu1($F0S|V-b2{L;25X0u-2!>$7Y2AkKpPH= zy{b(tN%`R+(@%dM$Ic~il%7=}DGqZsX$CtHn!r`~aFcZE0u~arW!!q0KQ71|+X}!Km)Y3Og*s5H+$1SL>UD{%U5{ zdeAR9j&#v3E#Jr&k6gmABCpNIE;eMt>c|H9?vYihtg)9ZcQY%sEVR!Wq^1TOJh8#V zAF6-QlW-n{KfpopY$T0L!v#_LP*{7nTGOEL_l#I^9FBjzflRN0sbJw$VQru)Vu^(29X3F*Nzt_k-1rKLLDkl zPgvf8eop!#vwi9^@4-XaP)KP5m6hIlY<9UDooD_{NAbhkAiisTvdQlJRE@zr@Tz3t zeWkLnd^E;l*evg18Alitm!%VY?rNGE$Db3{4OwDrwyJK56j-r7wJFxbW!ex=SxB^t zLb{2|nKUzktxL7Kokfj=CDH-K4c^yputKiXvYFN~nD^27bqqtjpXkEzvPwEJoYv>F zz-bZh$O1-x9RcDe3!`{fXk-De2l3ej)@;1lVI2YT_ETRa)nd?Qr;9JW`IwAj6ui1p z<|374K~MZOPfY8F22>C|5&viu0&ge8x8HD?Xwk>Er)6y!x9inbMa70EqFYuwBP)zW zY!6^&`jyALke8%Q>6_;$-r%SNDIJ*THrG0_5#~&4=cM%|9TQ%b5<6$ZBs=E6ex1>H z*_2H~N?5=b`#cVRM7$xGP>!fhke-KE#S===M+3^H z%erfsOSP~gELtHh20=M2eP@_=1kCb?VZYikU+3@WrKKBUnKJB+eac|hK9pf^!1ILT zETYgnlh;g1Um9C8nbh*4=+(9%htp8E2u_ zKhZm_h=D~pUp!PqNP>aF$5Rj(15n1U-qaJ7e=oH1>&!DAov7@3?K?kId$9Xe zmD9dH^wync{^5M*HoyF#KixAr_w}2)&#%Ak{6GGH<6pve8Q%7ze|}llu_XQ{_X;=N zxg6jQF7Hm9d!+2#ftk+za*3!N z+H`$9ukiaczn|gvt(4D~_xbnexrx>4cvF4+vw8PXe!Jb@a{Zh^Up>*edkp$Ue$do;=UJfCHH8AeiEVo0`mMl2UPq=@jQd8=jwDI-;T2)?)(T{8le>t`T&qG z?{{y@yC$j6yKA`WU&&n`>9$4ai$Ht$ExElB_u~lt3dnQt+X!{9PC|cleJKw{i6?S_&k(w{&o|ob+mbtL}qbr6nczQ6Qh=AAnR|)!hW7woP|m z1lq%I$^C$<=(^pHfuxBg_w#@&xkCY(?vk5*-fq_g|XT%+h&@X^| zZ~Ydi@K2(930LKv?oJ0%4^DTh{xmD^CzoUz@%(Ad=&J54=)`l?y%Fe7_^rCl%QEN# z5jPg0O+Y@!jsTV17l1s^Uj_2*_}q}U^QyZGoJuaa?{Sq*R^4L}_uoK1@B69OLp`7O zdR201ga&}TKA#yOS+d71jkxzk=&ymq%W>`_Kp*3`sK%VFPu8f1e z2ptP_GQTDFC#y2gwJ<(?E0E9orx98co=$fgfP61BBJ|M!mE4ViuH;U-EOGxts^q@T zRTfop{|5AJ!~G{$FPA4G^mKrxyXSz)yVcVJTm_Zfl1AnkP9`nwJi#pndYe+N#dVWG zUyIPUBlN=v{R(K(7gXLUTs;S81Nrv84aobe_r#}HM5qaLHNPjhPjmfegZ4-0X8|g? z-vP-h^Rna@GfSBnpn2|Cpp*D5x%pgW3-jE0K$jZsy<9yn9|+Jq*920IdG5LheG16u zxCzL6>d!~$s{xwlz5(UI`>EneNU7^1ky@ATOac z5xN3Md8=*|$a{;8K=Q29-Dd;cbazXH?gsKY^Z?L7ey6+gmoi*mfJ*LIAeB7bofMy* z8KE~u=xq^tPlP@gpwrzb&?opk-F+rNXS&;fzR7RN{fMh?`4a&;(>)FJf;~O@pR=bg ziO_3-q<AVSG)+0$bqbb5r&j?kqMx;#Sl2z@d@)7?J!0AfabZQfxJ(g7ok^0=$r_>GeVa|XkCEb-XX~rIN$QI zNOx_3O72rYUe2Q*%<8>4(tRyL-;B_A12o2guj<<_N8b&|gI8 zLlN2tq>--VZU(xW-;#Tr>vIOp_fO^qijHjtA0seuA4Hpy}=pfmZT+g1ai=oiI;iqt3a}p6Wo1)Zn}FE zNS1ekdoJRR+LQUyc|cx5XGQ430KLxr8IaIw($EJcWZ!3ZXb}B!G8tlBZVHfQ7)QH7Ak71gc0bzWp^`floR|GsKz^(^2S_DPcS{3Qaw`Hf&;2Ekx5kkG zmE5&JeuTIw&`oz=4p7PM3DBAD8$i;(PrC|}Xr8+g$a~u{AeHi=;@<&z4sHVS?fnXn z`r|e3+d#foe;OdZ6Lq)m59Qk0@VT{;k#qH2pZg3Lt$ZvnOb*Nt@wPB$xdPvG6Xy0n zbC#>Qm+-95-4}CBbEmi)q5fgOICqR2GMb-7nq%BTqj@3H47k_1I^~p_jBETZa0BiS zEZ0E5%yB2XcN^wqk>=&@z0}m_-V`t=yHnj-E9cK*uG8HWmg}zq<_x$Qvs@pJ<-Feg zqtR@RG%MXN4YMPb^FG&`%OQr_0%pSfxvPQbbKi_Ke-SX>kC+YaWTW{>#MIq}=RYIO0rx^KH`wQX9cX6e z4!YlZX^eP&mKF~3!8?_FA{bxJ|8b?{MoL^5Xq@{mHz`qnY5wTt^IvYRVa|@Zo^t0| zu6M>x7Osz`Hg$fa(%P|^FyQgM8p(x<^TBc{S1k5Jpc z2}b`GxJoYHt&$&$G~KzbZuM6(mg#D5ZhE&koE$I*PWSE~t%t^VHVR92$ zOHa;C7^WIAr{z9oy?kuMT%6l)H1i^6dF~g6Srjqv${n&?7e~y>+;6Sz?+uu<-1~Bc zNv4^R=FfBGNz#^2M$BL4YKGYrF&lEz40CtHd@wh2lC3}i8RgJ$wqT&q#4bfYBcYPG^4p8!+be-$OUdJ_j|lBMj6n2+Z+7|r7yn7=Zb|L(wC zX_(qavX*YiO&I3*4$OxQGZZmfa~lowh7QcNlXBF4X~cXgcfGY@ZNNBpWA0PdibkZl zF?S=mocmb7Ot??yK5MydjJZA&Fkk4ve9k2HwOGz)ayt$4orw9z+!w8`CnDx^xi1^f z&qT~ExjT)f_v)PEAz1Jg9jZ5^1FVeaq1 zj2PxX2j*(SJl}!2#xOJfCTsh#$wv)ydIx5swf&6&vj7f1X7YJ!#LP}MTdvDuuH%v$ zE!STK%$3P;$u`4W7cp~^e=-?<9?Two7r2)uU+c-u?sNACng#B}Xl1x0V*W0<+%W6U^83sS+zm=~ky@vT+ z#QaP0kd-|3W0@7)o$NQ7xdF4l-JSd&qj_DV`EJrTSsY%}ftfa0{k1CQ`fhR*Cjk0f zBVhLCzn`37xvq=3_9rJA=JOqxlPuRgG1vZN-egJs2Vj2A?*jK|GT$&SbYRZ3+NXZp zx8nKav1G_FCxh|1o=lb*W?{q}Ng`tJ1p1cfMMMt|BqJJ?hcxpt(>oQV7_3v_QqW0{Fja9;Yd@?-)S_zjx?40U6ZAC z1=eVM?UnpJR##ud^ycq34hJKqFaMxnhB`3cGt8SJCe44}%DFURrsRKQm=ytYdwy2_ z1~Es%g-{*wn#H4{}R53?c6^F%!E53Ki6n-@6XzG zV!+%UXnv7DCI1Qzgb;nja^~gF?2{g9#Y)m}ZeIRXR?bg5XkKlYUk1!O3NOzuvf6vD z^SLJ6>G?Mp&CGzos|U>7h*^?v^hpozS(y?q_effiiSrjo>XR)cSM?R<$q%|f4w5( z@Z0&{SzX@>G|oMk?@6UU`(v&L^OFtpOvF5rKPnZ^$=~{N7ABA7U!JP2-hf%)exCmW z!}JHt8HHcvFSJ}k0dsrutNcZV`Gc&SLb-6IVcrsHx(W@$tcaLNg=-A6E?^e8nT5}D z>aWjzG-75KzHOKrBj#m=XAE;k#Jsxj(kW`icOqs{;WdWQjNV5MOA2RCQOW-mY5t&a zr(yD+$Yl6Oh5M&yPBgg#^RSgO7%>+Xeq^~`5iu7PermavM9js7UmDHD9hhGk=3O0_ zLsO(1?+X~`E-vJz%2KWhm6YtD9hjpH zb63Pn6kczKtG)+D{}#B97T!74QBME$8Rpu6d40ruys*+}E{&M$3hy<{pGV9m3Tq8B z5;2<#e`%OcM$9J*R~cq^#B41z4fBnN`BY)TFposcjfIaI=2sE(>B4n}>Drv}yuI*A z!yFqipDo;InE4TNQ{l6Qc~iuEuCUWE%OhrI;fsd(%ZT}W;Woou6EV9BUpLIQi1}jS zZo_;vV!l-PreVGlF<&m+Zqfx=19IQORkGvOX6yv%6c7iqo+ zMjmM_U>3OV6<%eS>jP#_@^E3XVZInJ3yVK2yumR0Vy+(*&Yvbr`HzTstngPx^OFwD zhYXY7;yGO4ep2{|VdezPvxS3&jnjtVXK|$YKZRX}c~ih#Qv6k6ujTraNb~E$e;8&> zz$_~sDm-ME4+YGng+lSy*7lDFjB}HURnA=Yxt+0`NyR>nZ#nmsfSGX9if2q0KX*l% z*4@+mlprfFh7ViFD+hRm}P(E+b)_nPj`cT?(sk~GxyTs z#natvhUTrF=4xo(MlQ~De$Znk+=<0^8m1O#Cfqz>;BYWtRuxYVm<0i|z`dgQZlifq z#Jr|hpRWFTSH!%oc%9LdU*TJEN%3{XPZ;J^dvew;VKy5kz0+fMf!Si1S!cF${k>r> z4<+9U%?&2Q;eb&&|6nxh&hfeKEWW6uP^?iVRi(} z(&8J6w;1M>UwaOh7T;3**Xem$`gLgZZ-IMD@ovL>Ct@xte#0=2N6f{=d#5+abtq!q zTKuNb9QF5EIhO=XyPUTdziqiri8M=#-#MbLWdUg~IHH`(ijN<`^ZSZV80N~D>+<4%8D?X|tSvren9oGa`r@;O`AWomp!jRUd@Eu$ z6rVFpyQNnYe`6f}XQa8R_=3^A5HWvU{GDOiQvFadca-{~?^Br!>&3ib+P%{#77g=~ zNYg5okHCx+yN<{;R-9y*Gh?oaV($?&A1+Qd%(;=~BgNWL>gA;ob9Hfw(X?A}O~5oG z&EFKK9Z~WpiUUVrt}h;Y1ZHz__7RxBE55`q?UFxPJpKsGKNL?nBG>1NXC6Vbvp94F z=F7#!M_~38-*^P(--~ZK0<*99cEfxuYiZ#J#g&HHmSNlvimQ&u^`qkDhWVFB^W)+M z!+a-Vep(zpBG(hehGE*h{8aJ7K3BB3pB1k*%uixDKQI1`VcPsWUEFAx=OWEB#p?~z zF8NUL2E(*+HIIWjF?HK+YIxr zh&j6SFNXQ6i0LnV!!R2o=GfA`hG}y+yYx-NY>za@mG&MbFY$$lIid93BXYg8wBPjk z-biy&>4!#hFkq%8uLzi5bzmMhnzrq{qV%L;+R`|q^fSY>ZD)SzX~XK zUWmmtO_8B#dSFp^qcDo*c@b7}8-=A}5vIaYG%6PV&*%GnpYLtOVQnnoxHuZ?nwk(8*Rl zrCc96#me`T+)%2OKPclvJ*^!6Pk+n*Bh=f<@syiGr&&p(ObVr08BDn?bcU52%AKM9 zR&J%-6*|*y!y-yy=xkdixL!;RooD4Smbo`{ft431MWMk~R#N7MF0-t8JO!{BuaS z+DdQ+Xc_*n%^}kA8K`wxvm?T5ZJFR4eq{I)E5X_3sPH-~!CY+@UT?SRMeMzO_%kb` zD2d@OY^`8C9l~E*3GU*K4%b-;wrZ#Fw^o9qI}+Y%O-~H(v~nN&IywB4m0-)C65b{A*_g*s=3bK;{>7FF`sxJ< zTJ9a*{g-z7g!ftr&ito^f435xGfxlivr;a7y(jkOZfzwP&!BJ{E5TMhFWk;baMe3MoMNI z&-n|(ovZ}&=c4d2RuWlea5%|Ia1>k|?qVhA>ymI+E2pqlR`>)f11VRBdsqq9>)LQ{ zD_5}0b>Y*j+(a22KHW-i7QG?d*GllDkQ?r2B{+wV4G*vqT!qJl&$2RwEl&uaZDlTH zQusnE!8|Mo53v%==PBXKtOR4eCp@C9UYGT=68-OkgQkbCvSorZ$$jBbR)TF<6u#y! zW$q7OXXP1==YjATD{oO|g(p~9PnjK_XeBrX=Y=O*`I%)N3*Tua^rXMv9}gE;3C@S} z!&9sT&u9z6cUuY8;-BGZR)V!y7{1p^u*J&4_gM+1f3e=_`_mF|>9;bJQT zC{Kk;+RBSsb1CGqW>1G_+3h@@Wqi2_xyNNt%TMpKuJX~taEJm5`G0%k` zvr-9Z(d?!0GAnB!U&X!_Ufx#!+O-Zcyjf-VE!%Q%3|59$S_!ts^6g0t3};rFck zf_D0tx5DpRX}-wcJ5}KitaK1@=a!Y>HCBR_-wUs|BRrk8-VblIWrDq29sb-(2Ft7o zZ?ZCy@=^FpE5SbfB>a_?JeFA({zk-@)30(Ply5DDzipctJzD+}_?EAYeB)LBq37Fd z8jR$bTd>qKg-j1Il`%cb^e;(Mq!rI>qqPdTK0I@Rq-l1k+;t;mbLmv33Z`HLK`TMa zes2-;h18fXEvJ|tB|Tu*BUb(ry4a>}OczU%vNe$MPN^)cVSkhiw;|EFJH(Iw* zQb>|#n#uS4TG(`wB-hFyrhiD%-cn47q{D5wg)q-lF>R9M>h5D|E8jYD)<=@I(#q)8 zJyKd}WwOPNv1y8=6K#4LmKpsRH8P`{nRYTYG94`6L(!HqqwSbZU^mB4(nb z-gb@dkd$WAR7tw+Q_KuW1H>ZcF-dMa2mA7AG40ngt0bLk>u#0g);BEQt#IiSrgJ5^ zR&rsjj2>kdO5IkbP%PV~a!KQCs*!Y?O^uQYZAy}F9L%sOgDFqaBi2eK{nMr@Np73g zODY%hOoDu}?M9`a@4M0WXUfLXh#4=*?df0-PG`Bl?@P}-i>0B^N=bTj4~c#tX}R<} zB>E|mXKGO{sNuQaD6m^HUS40jQ5`4AjdZXiZKa19jio)zB&O+1bC?z~y~MOy(pz>L zd~EwK96n(Q}EL_p4+C zt;}3my4EH=+itW;&qyxmQQ>OnQQ>OnQQ>Tb)ZHdEnjXK~*smv_2D=gX$6yb0w3x0( ziqTJx_etFp)1N5|DPnGrwEt{RF%w~)xkr*$r*kMc_8%8>dn*`0a6Widmb$Tg%oH38 z+h~Uz;g>s+DL8tDin%@}NebB!_~%Ktbq^DBTh|>kx^><0F+*y&q+8b|-MSH5<7HXu zj+rkcb+au8^T6Nxo(ajPvF>WsQIf7vuH$zqbvZ87>gY4W)!wo9

    w}k|O3;Ng3Ak`gW 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 z zpXaYP$LY5z1M|9koI^Wb&i8|`rw{U5jJ=4k&lj`{6Xuug{g?JUF!$rIxDof|kO^sz z2XI~=VCSi9e)YP8A?A1lx>Qks^vVAHc{XmhoPQ33`mM+5TNIOTS_6vu+q#bHW839? z0(R_s5*}A~pZD3iAGRO#=f}Ana{J+s>w)jzb8x=rn=mY1F=0eBA%8s`e-Fpm4)<@# zoPJXjcH5x;#H_>WUe07Yw!hTvH8H=zxNf;?$gXa`Y&U3!$AR3>|7h|-zo3Tv{BOtE z5Bs(6S15<)=<7TM?^|eFoPOUXKwLN1FD??;%sY@dE4iF~@t> zaX-h`0jIO=EiC#4{02Fv4|3ao(JvgD^BnfZRfiaRA#dHz5fs<&ACG|_9v=;dt{9x_ zg|;t&WH6!E3EOJ*j{)3IJg=0 zYr~Le+iIM~qyLgeM4xl*^}i3o?4*!>R|oMC2z$y8=kH4Bf+3FswiWX8DnEbQ_sL;# z73a&0&uJ~bdCwfi{f~Zc51iYRjr;HIIe+Z`PS~@d9lz^-kkfNG)#yT4w@2#=kdBWB z!#nW)+pag@>oy|(VtA^UZ^9IB+!0LA=Y8uT{hAEY2ahx7FnFBfTz($^@w_*WgILFQ zIBZ4#!N-%s?&C5p7vFDYZ=>E=&;9fwGY`z`DMKRLjQePwEQ#}RKeX$4LgE$p<8f

    >2--I}aFCqV3hWqn}_Ps+y^e(pjbMW|1 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 RGHFl)S5g03{{M}@-vCWeV3Gg; literal 17408 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%0AJm>}bzotiG-;WMn;os8j1^`I^rN_?NgxSH| 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 Cl)!2L diff --git a/packages/System.Linq.Dynamic.1.0.3/lib/net40/System.Linq.Dynamic.dll b/packages/System.Linq.Dynamic.1.0.3/lib/net40/System.Linq.Dynamic.dll deleted file mode 100644 index b6e30980efdc305dc7b969871ecf680cab5c2d30..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 48128 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 Ko%8>%2L3lrNVp^b diff --git a/packages/Topshelf.3.1.3/Topshelf.3.1.3.nupkg b/packages/Topshelf.3.1.3/Topshelf.3.1.3.nupkg deleted file mode 100644 index dea78dbe15b03cd09c96f173e51321a70dbf05cc..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 259779 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%0DtuKV0H4a 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

    hJ;R_+*tof(dbvT)5$!xl(QS@FW=kg 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 Hl5MsYY)H=N;S2Z54&&!4H(kiu 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∓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%0A%`p$~h@(nusL!m>0H&52~X#v;R@ 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 diff --git a/packages/Topshelf.3.1.3/lib/net40-full/Topshelf.dll b/packages/Topshelf.3.1.3/lib/net40-full/Topshelf.dll deleted file mode 100644 index eee82ea63d0de8cfd3796f4309448d002b11ec44..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 278016 zcmc$H2Y4LS)%Iv+H7l)(y^_2u%SE=qV%U`o*kHgk1IBL5EG4^_}e}9O~{jcS>7ZX2pQ@Hk%m6mJOEi&XLb-r=`7Xm=jwX znhaxgXa$eI%614(KwvLwI#Y#Br8fYgKYimGqys*Gg+}CS=E;UJQvM=8hzhb{IN-ZI z!{GZ&V*reMgDImG@$0uu8Drz{WrZh%staZl;+w^2rp%vv^nAomni}Mbd4=Bb-vnqi zrR0_N1yFQ@j)slMbojB~Oc-QJY3?B|5UHyHorTxBHFz7v$RxNI?TR0DGmS=Lhus^D zZ9X%NW`P>Us@pXflQM>}%>=LwU`z9ywO_n){A1bj2Ot08=l4Cn%33=d^z6O!ZW=v% z_Q+3OY2V_cUBBG#{Ttd}TI(NQn*@=9><=X8u!$ zpR?ttG0(5Panrg-e|gE)13h!o?K7>g zkBXaR!7P*3`?+b@h0aw?qks$plC=g}O7Q1-c}Q4b9x>i9#@s+BV=tuFpSEnb8)=1| z0xc|mv{I&r&@ro8#s=U8$yu|^6w4h0H)ES+B6z4^nbx6+Eu~IKS= zaMB*sw-+=Oj0RL|{>F|qCZb9-L=q9wc)KJgp6}wmW5?m7?y=yS(uf{${T>QoV5;> zCa8C_XRCTwH-A&W5&2t%UZcM%J>+jS@f-cA;@du|8{lbwb@7}0HN-@Yj3J|*A(fgkRWwefvJO6$t=?zlqz;nj8g8}K_ZRBL@}05oWVrh1EhSk zcl35Xx)kZ?v`?_~XXts1jMxh`J~hx}meE2|#fGko?fr(G9@784es2=Ql2>7pnfJ-O zV6ECH^%N|1{rA>^c=k^zQw1kPK~!W7MZbjLy2M3ePnkJ3kd#?E6n&#O-QIN#=+9Bl znOk&^Db=PV(~Pp0M_WiSKh~-(#->yPKeH^zl4i1nq|7o!IOyDqCL0a_q8~dyghi{e zD8#0e@?IA!{d+cA-?UPVk?LY9GDX0WEEc9K>6W`b%M~$d5yhxY6r)yAjM=c<4M=yk z>TXgPwA^UWve=E#Q0NB4K#bB*5?AFu3N~s%{je0&&7k|tn6|SKeA@Eg%Qwp)Wo!$2 z{!I2jDfe9T{{53G=$TTb{Sy8&-|z-?P(rr98^rEPvlLQvShk&~8%(x*?+tI(aLnIR=|PlkF}+um#s1whKt} zW}*U6)uLS%YTY+jKKetJJ~~IqI-@LoiO-Rq2>D{n!;~Qy*J%?pjelYOv!uF*?v~P# z5s}I$rAxe~?hzW+y&e9ex_3qey>hCwV?$WO$XvSpl;v5>=@bW3pW-0#!usQ(#%DM# zp(BzYx@7h>=)IW@j3uHzqs)fH&zDXeycv^z8m`clF$$%;CNb;3*@oDyk_$Tps%5zw z2VDdu1hJ?Bm1iN<@-`t3%8+9g1_Ps=b!aw#8Qb#FDP~Y@HiPG(wPXtWo0ikajxcu? zdXq7Zjj)r3gDlG2x`2AJB{0qMR&bprCJArOvqpe-UI;UG&b*!+Y|CjTj|>qzF&CR~2}#hdF}4~V)Zt(X_&yx7 zd^oz4X`{^YJovrC(^@d>GH7Os>6|xR^*dz`5WfV6Mt4>L6y<6e=YwA-_$lg)y@?3` z|7YUAc#Jtpv8rG$lX738#mi*k9sHy&|B48Dh zGUMzBh}bFAfm?H|8e~@J@m$a?kh&s(1-c3;)gnvyGz1zA`*4(#*r|6|TfnCU?7~#j zf$p}028AXdxNKituz@!Zf-q>hhr>q;K!$9$gm7VscQ3+&G(sU`f(+wgqk%RmKhyDm zWP0=A`bRKmmgzZYSjEbb2n}S>B2axY-qCOd2@<%2CRKEfK@?M02RauA%q~yo$ zorgs7B2vf;wLH#C+hbCVJ*Z zu-qHP9WScPSE>2O^lxWpH7S%i(!fz;RG$342@#pyHXd2c%}btB^=uL<)Ib zjYy1_wg(EMs(zrT>)PWQFc5oOOHN`Bf+}>BJr-$<>xgkZoI!#rbR1N~SPm?1f}vx% zfl2I0WAy`h&3Z7GL1Ij}2S^+f?u8$W2@GOP=*)TdA;e9G`{Da^ z5PpE+2N_1roQDvQ@d2$n7#~O;8y_}ALeWJJFKiVr_hI0eWpZ&Jf#W|4r??TiLk8T( z2zne21_)Bg08vXWxKEHEH&t90{PeMvl}T2DQ7i<%S)JAu0GY0W3ZT?rckX8A-6&hfU-_B0muw<;$iMViu9TqQ|UB1qs4 zP>SZTy|qpf0Lml_cz?Go1L+Y!GA)~vzoPdGidN#x@=4(1^+CR+;E>5V(M0$_&U#zO z+{yB(oSpKCj*e$b3VVTks&g2bQ|FKnR|=|p3aC{M*(XK$I}LEj-?lmvg9KIR==^P` zlj`OVePo!w7ghc!%q*V@SIWZj1Rl%Zc;@drLH>x1{1F}b+lInkisw)0Ok*YZy=)WZ z#YnZ>U&6&s8FsdQg^=yO4A=cN98O|_IWuiJfwEo^WYhl*Q7!*fdc*c>@VwXIgtin} zma$4G>kXu8Su#5+ze!pp?JWtu4c8ljqvq+9iT|wk4nSO_yh|+0e~;d<{abk6`*5md z?f^PeN#yT$NR7)>(pt>&2S`Y}zlUqPl+4xql@5BREa&$8f#>fg^pX z1O6*euRj4oz5Wazdi{l7%Kt09Vf%0JyieeS>K$p8KSf+AG}f#(gwaZsg-6>K`Ffv*7p&xA8bkifZ~D>@V4sB%K%F#5o;Q z($n!&GFf;Oh9{l+N|fs6k*LNn%UB08R)!4gh$DfGR=A4Ojbz2&7Afv%0Q&PzkHE>< z7A4&=2=Y*d^=1b6bb`->U+uG7M`psxJMMUcy<3cxI~K^hgb5KZcbp{H(V*v#2LxLz zy<`uAFiKzIoTpUV<;^H>3Oiw!ac0bF)GXr zxLt^yuuG#At1slS+;$ldyZA}FkiRWDCGA4aw&+;jE-#+8=a*G>A*;G}A+I`i!Ay;I z!Guxl!6@w_@p^U{70)@b6L#4-o=P6eZI>xxmrBwuL z!6!6+x$Uy1*yYruUC7@SosxDTXIpfvZU>}?p}a6 z=rnC!#)$v1Y|_R<&4#fy`l+r=S4&rGS6f$Ss;jfHtJCi4Om}rQb#*p(b!NIcTe>=1 zyE>8D-qksxt8-*mXSS=eqpP#CtFx=Cb5vJnuB$WO)!E(EIl8N}r>k>JSLfKS&T(Cx zpbbY{ zI9IW~eIPSqS9aEw>=gp{1#plcfjg5qT2yfSr|KcjTWo0xg9Hg&MuEz%8sk-B>_;X9 z3EaW9d{HUGY)k=KYm7w9eN%5Iv+>jdsk9s~*8!FGJHNl4yc>H$b?ZK`}% zle|gbfg~YF;0|`pi_W7+2qZQOISzT0#J1+j?wTB@FM&jY1TGS@seyKwYlz7d*_q0w zDtl-uoCpO%2@<#x`Zy9$BsIg~5_%IUrplh0?Ym@q5c5Kiz#Z()7kPNB^O9{8#oi+- z&DYtOZLEAxbNDU6VnBifuCikb)%#37m{fMwuI#0$en;^4DVHFDI~c8t*|bo7z~n-W_uo~TC=T{{WTR1-)wI_sR$Cd zgZ->xwoRyTC}(>|kg6@)RyjaZ;h4_$jwBU90(Y?6Q_Qvt)u&88id5~{_R4{p3Ws;L zcQmO861aoCkfMVLR*_c>!YVUD*nCEOG3toyh{{2l4Nmw1qY@-=Wz>;E^$#XXl^K~G zSvgo!eL?Us6i$%99W1Pi*{o1~$>ar8Ih)N^FjlEvtoic2y4391IK-N-jYHS8_)QRRfcK=66(fRK?X)CczcTB}m{7mQBTMPN*y< zA4jTOHdmRasZsopmX8j8KhW z@~IR%COf8bl%^U<@M)wXNZ`(Tq#7$!Stg%OsuY757h`p4 zoUrL6zNkDdJFaq!X46IRnPfwdz?}^!e7sPNV)8-?ADrR`JjD#vQ<(ZoKN*aQijkA9%myg)o(L{$$Q6w|CPXGk;Bn;ViF}+!#(71c0YL(fBR@;zL5(~vL?%e!5wf!wxZD8P z0%@G}`Vs(OOAU|!09$E*1OV7t10(>zcQil(0BoZH5&&RZ4Uhl;+i8FV0N7pwBmlq; z8Xy4xcGLg~0I-t=NT7l#D{e^SR^{d1oO>S1$;`VLMl;^|2;+9|DZrOYKr7HP7qB1+ z5;*6}Ip7uwxT^6p+|j{&9`jsvuW<(Ex!!}pJsu{S&M#p;TzPni*LW@jCud_+gpdjD zN8ST8%e{z_Lq2G_S?}S14-rB>k0klbFh?}Vvfr5uRWakY@=hN^;ROlDK@=A&3WUNI zr)pbB0D#jpKmwezTL#*&f!3cLgNDMVTyv$LVjpLboj0A8z-N)&U3yvoqfKXJ02ZDF zv_*DL=>>s07fWu)%QR+!S2O4T`e}ix2M5Sdu~ir6Mp-UdVn0Lib}k{aW!;^dgj-iN z4-^QnAIu8Sfx7eux+rIx+Gw%lu3BM+zW?s5 zuCU6dYlBK)cIlU}iRny3>M|aoAWDF^3v1ZYZwszaFUJC$PDOAdko?pm6byxrP)ud= zc+Q7duJ_kJ{0-t)Z=esIs1L3PjfX=%^6+Y5+Kho#^=3aH%g z!qg_X+e?zz-Cp#BMsX+H?G;u+UZxro29YookHC_bf?#@OtX9MgUxG>>AQPp};5Zm; zZU0`taMzby5afIUF1`wv>+= z%BK)71$+NIa+_n81y*Lvy_MLJ*b9iA^3NwC#WLV+8;WJJdz%uw4aMG0u^8uS#9l~7 zmU|P$UPNvXE3h(S?i~~ho3MV2gpcV+*79}&OFqc*3;3qokE7irEyWF@SYoKMgAF2f z+q=Pws-LqvqbQ+^DVu|_1OT{110(>z4>UjmfljQmGpp+C!zfMG*@xf?45qbfnHc!#X<#{REbS2Btx{qe+ss=1pt}K#|Mkvdxjmf6N_?jqtzLEI6pf!oACX zltRkn>F$hNbvbv!cx(R&!~t|yKnMCznTb;xuu+ds2grYrgn3~j^;q~tjAGR8kH9ix z4-9A~hl5G!L^v@d>6BFqp-ROSZSO9S;d&|Mrro;{acTFVOu8S>jbTv9yfw69tLFI> z*fqI72A1L^I+D{6GD5$9EKnIxn)lSz9NTuW%zm59?3g4;uFx$K~MqEfE=pp zPGQ^L&O%$orl9TpgofG@jmC<#yq^MymiIGw6wWApiK}*kNm}B5Ca!r$H|mI=I8WLm zo=PsueV&AQ7w*HnnmkV;e_OOlo+pvBEn3z;Puh3x^_NwhCy`a%^Ca>L&y)1*vBz7F zk2v>uyDM);dU$%`NtoZg2Nbfwd@logTJC*hu`kSR9*gT`Dd&E|v5OqSz10+(8OqyP zdAliZ4!zlmcgdvz*~RjdgWadl*bF8| zZ@YM8>v&|%cw_@cP(RbgX!IGFXk@+LsQ$*M8Ei3za!bck?FXQC1rpR;WFJ<#2LT!+ zNZ`&^sD1&(c_GDRnquFOf}jc=p>VK1(PTG-WS48Q{X#N=Ds*bd?$TtK>%WRjcn?w6 zD>MtNUTyDT>PnEn9jt+hzG56Q09WCw<11XbwNki9}O4wIE@G}%EU<7hcZkicc!j4Sz0DD7HJc5o<- zpbDKDX&;h|6%{smoi=)mk{4+f*k`r9$0?a0fjd|tCd~6?sPJ`~?2u4lf+}=s6mDzM z`Mh3}9U77mRH0KtHYOyyL6c$MHZTuC6*@I!10mUsn#>K!2&&MjAzLpb!(>D?2#m&o zG=eI0YRGmB$$qHG4iCu)s?ez+b3?M5HCZVnBd9{BhD_?G)R|ydU6UOdk`Yv)Q$zN0NOp%N zJ1Qh2s6wZP?BkH^PEB@nNJbE!N{o@Ii7$HAJaXaf8T6k^i12*)bd0C`nI>0QnaYo} zm}5dQ1PNTUGr6{sM;%o)T0lH$({~Y%PGo9R2B*s1nrWHH(g_nJ@Tes#-M0=`$k?$d z`acFh?S2%VTutF&!1Ca~_QS^=zCX-nI5PlIQ=*u|AiE3BzP%U{Bj zlyfP)M(1*R?J2IMxr|otd$YLF5<`;26M{rBjUo^61Oa7oKa47C5eWeBfCfkafCn`| z0suUu0TNKp?{COTi(hF+W{+D)_QEw-jkymK6jHZ}$nxBDt{@zWJmsCKyi4dsnZ>%Era<4oJl_P5_3L4+m;?ZLL<1xMz@r)<0qCpum1eWP;8j64 zLymgC9p85ML=^L|8i_6SuzGW_sFh8PtKo+c>`O$EMezuBDT0(BA4v&dh{cNJ<1wwJ z1VqPmq3fn>CkN|=yjgx4(=4w2ehxoa`!T52e($NdSos-1d^)oBdjn9}uh@fmXP$*R zwqLOU5{k31&=Xcd?qWryim;!%6J%C;0hTGf4@a%No}%2m(8#Ke#IifV1ihG%ya^y$ zz=)J6Q$F*Au0it5bvE;iHB6A3AR}DEP$w5wu?uI=j*XeH+_0j-Y(Dl9APWrjo)7kz z5;lAu@@T{7;0HEjP}%U0fen8Fh)+js_*-Q|lkd3*Y)BI9vrbFHZVXG-pG6>%bpb?K z7df%4Q@5K!Z@Yy9#rBu~m5-RYdmmFjG~Fw?Tpg9xUVZVnyCNg_WKBf*!$p z32n`P5)`Jln87C`_z7Ol<3Gh94)1?Y&RG7~{?h^E141wlw*6-SL5p*-GoYUFX8qi} z%C;{dL$vLS@B`a2sBHVUz_yD4@#%`qYrHai|ZJtl-uoi!Dpxv8PHBIcWmE9=YPI7pDd9h@K)-5aUJ%hY0=Fe@@&jJp^|GXAfag2%Ao`C_2)S|mmQ zBcKTg=Attmc+7M@LA8w=r#gSmxokATt+!dTV@+Lxz2o#!y01X9{&lqo7Gn)cOhiVD z7)GO54iR6lrX)qoZApp{l$eMXE#mU}BEHgn5mdvJHnKGYVwR5`PQ4`94t7=r+tA#ZvQ&x_RkjV%=_UW89dQ z{+$7KZ31C8MR9ComirsjN11D{0E28H{qoO|(BDwN==(diyjOw27mOA8=EV0oOkfPQ z#I}MTL$i2v7~*jnL0KHLExyx;?~l!5TD>)xV2SVq5^eW2Du6VNvz5ZxtR4=>52$Z! z4V=Y?puFVJDdX%4siiwnxkjIba&6#su$=9_4$h0RcHVa1K*)WQ&RYuB?Yyl5?nD?7 z6ELX46_wqRb{!1NcquULrOL#$u&!vsbO{i=VpRG%Y!um@NT(6qA@J%<7rU})_Z

    #8BdDve|%0MAU++Le|!q4%#ZhE-2y*F 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 diff --git a/packages/repositories.config b/packages/repositories.config index f1c5939..c76a6f7 100644 --- a/packages/repositories.config +++ b/packages/repositories.config @@ -1,6 +1,6 @@  - + From ef7e50b1b9baf6f65278f93474f3b442e718bc36 Mon Sep 17 00:00:00 2001 From: Eric Fontana Date: Wed, 8 Apr 2015 12:25:24 -0400 Subject: [PATCH 06/14] Added NuGet.exe --- .nuget/NuGet.exe | Bin 1664512 -> 18432 bytes 1 file changed, 0 insertions(+), 0 deletions(-) diff --git a/.nuget/NuGet.exe b/.nuget/NuGet.exe index 9ca66594f912a1fe7aec510819006fb1a80bc1a9..be85ec2c4ca7dd7044e7c6742215d8d58155963c 100644 GIT binary patch literal 18432 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 literal 1664512 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
  • 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

    w}k|O3;Ng3Ak`gW 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 z zpXaYP$LY5z1M|9koI^Wb&i8|`rw{U5jJ=4k&lj`{6Xuug{g?JUF!$rIxDof|kO^sz z2XI~=VCSi9e)YP8A?A1lx>Qks^vVAHc{XmhoPQ33`mM+5TNIOTS_6vu+q#bHW839? z0(R_s5*}A~pZD3iAGRO#=f}Ana{J+s>w)jzb8x=rn=mY1F=0eBA%8s`e-Fpm4)<@# zoPJXjcH5x;#H_>WUe07Yw!hTvH8H=zxNf;?$gXa`Y&U3!$AR3>|7h|-zo3Tv{BOtE z5Bs(6S15<)=<7TM?^|eFoPOUXKwLN1FD??;%sY@dE4iF~@t> zaX-h`0jIO=EiC#4{02Fv4|3ao(JvgD^BnfZRfiaRA#dHz5fs<&ACG|_9v=;dt{9x_ zg|;t&WH6!E3EOJ*j{)3IJg=0 zYr~Le+iIM~qyLgeM4xl*^}i3o?4*!>R|oMC2z$y8=kH4Bf+3FswiWX8DnEbQ_sL;# z73a&0&uJ~bdCwfi{f~Zc51iYRjr;HIIe+Z`PS~@d9lz^-kkfNG)#yT4w@2#=kdBWB z!#nW)+pag@>oy|(VtA^UZ^9IB+!0LA=Y8uT{hAEY2ahx7FnFBfTz($^@w_*WgILFQ zIBZ4#!N-%s?&C5p7vFDYZ=>E=&;9fwGY`z`DMKRLjQePwEQ#}RKeX$4LgE$p<8f

    >2--I}aFCqV3hWqn}_Ps+y^e(pjbMW|1 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 RGHFl)S5g03{{M}@-vCWeV3Gg; From c0dbe8f6e9c4e5a4678d09b93e2b65dfef3708a0 Mon Sep 17 00:00:00 2001 From: Eric Fontana Date: Wed, 8 Apr 2015 13:27:40 -0400 Subject: [PATCH 07/14] updates --- README.md | 1 - 1 file changed, 1 deletion(-) diff --git a/README.md b/README.md index a2979d0..569fd2e 100644 --- a/README.md +++ b/README.md @@ -69,7 +69,6 @@ A single Json filter using the single tag (this is only provided as a convienien } ] ``` - Multiple Json filters must use the jsonFilters and array syntax, also mutateFilters, grokFilters, dateFilters, geoipFilters. ```json "Filters": [ From 3b58f768f4fd5d6880b1ed7f6e4f69e6205e9b5b Mon Sep 17 00:00:00 2001 From: Eric Fontana Date: Thu, 9 Apr 2015 09:09:57 -0400 Subject: [PATCH 08/14] Trimed project --- TimberWinR.sln | 3 --- 1 file changed, 3 deletions(-) diff --git a/TimberWinR.sln b/TimberWinR.sln index b32d06e..4fa937b 100644 --- a/TimberWinR.sln +++ b/TimberWinR.sln @@ -113,7 +113,4 @@ Global GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE EndGlobalSection - GlobalSection(Performance) = preSolution - HasPerformanceSessions = true - EndGlobalSection EndGlobal From 775f33c843cb8a44f66d599cdec204bd2a5b01c4 Mon Sep 17 00:00:00 2001 From: Eric Fontana Date: Thu, 9 Apr 2015 09:20:55 -0400 Subject: [PATCH 09/14] Removed branched packages/Elasticsearch.Net.1.3.1/Elasticsearch.Net.1.3.1.nupkg --- .../Elasticsearch.Net.1.3.1.nupkg | Bin 454746 -> 0 bytes .../lib/Elasticsearch.Net.XML | 41449 ---------------- .../lib/Elasticsearch.Net.dll | Bin 481280 -> 0 bytes .../lib/Elasticsearch.Net.pdb | Bin 1152512 -> 0 bytes .../MaxMind.DB.0.2.3.0.nupkg | Bin 12778 -> 0 bytes .../lib/net40/MaxMind.Db.dll | Bin 17408 -> 0 bytes .../lib/net40/MaxMind.Db.xml | 279 - .../MaxMind.GeoIP2.0.4.0.0.nupkg | Bin 20999 -> 0 bytes .../lib/net40/MaxMind.GeoIP2.XML | 1145 - .../lib/net40/MaxMind.GeoIP2.dll | Bin 28672 -> 0 bytes packages/NEST.1.3.1/NEST.1.3.1.nupkg | Bin 1743971 -> 0 bytes packages/NEST.1.3.1/lib/Nest.XML | 12447 ----- packages/NEST.1.3.1/lib/Nest.dll | Bin 2076672 -> 0 bytes packages/NEST.1.3.1/lib/Nest.pdb | Bin 5019136 -> 0 bytes packages/NLog.3.1.0.0/NLog.3.1.0.0.nupkg | Bin 969926 -> 0 bytes packages/NLog.3.1.0.0/lib/net35/NLog.dll | Bin 410624 -> 0 bytes packages/NLog.3.1.0.0/lib/net35/NLog.xml | 15057 ------ packages/NLog.3.1.0.0/lib/net40/NLog.dll | Bin 412672 -> 0 bytes packages/NLog.3.1.0.0/lib/net40/NLog.xml | 14997 ------ packages/NLog.3.1.0.0/lib/net45/NLog.dll | Bin 415744 -> 0 bytes packages/NLog.3.1.0.0/lib/net45/NLog.xml | 15022 ------ packages/NLog.3.1.0.0/lib/sl4/NLog.dll | Bin 239104 -> 0 bytes packages/NLog.3.1.0.0/lib/sl4/NLog.xml | 10254 ---- packages/NLog.3.1.0.0/lib/sl5/NLog.dll | Bin 239104 -> 0 bytes packages/NLog.3.1.0.0/lib/sl5/NLog.xml | 10254 ---- packages/NUnit.2.6.3/NUnit.2.6.3.nupkg | Bin 98508 -> 0 bytes packages/NUnit.2.6.3/lib/nunit.framework.dll | Bin 151552 -> 0 bytes packages/NUnit.2.6.3/lib/nunit.framework.xml | 10960 ---- packages/NUnit.2.6.3/license.txt | 15 - .../Newtonsoft.Json.6.0.4.nupkg | Bin 1513616 -> 0 bytes .../lib/net20/Newtonsoft.Json.dll | Bin 493056 -> 0 bytes .../lib/net20/Newtonsoft.Json.xml | 9108 ---- .../lib/net35/Newtonsoft.Json.dll | Bin 430080 -> 0 bytes .../lib/net35/Newtonsoft.Json.xml | 8251 --- .../lib/net40/Newtonsoft.Json.dll | Bin 493056 -> 0 bytes .../lib/net40/Newtonsoft.Json.xml | 8558 ---- .../lib/net45/Newtonsoft.Json.dll | Bin 502272 -> 0 bytes .../lib/net45/Newtonsoft.Json.xml | 8558 ---- .../lib/netcore45/Newtonsoft.Json.dll | Bin 446976 -> 0 bytes .../lib/netcore45/Newtonsoft.Json.xml | 8083 --- .../Newtonsoft.Json.dll | Bin 387072 -> 0 bytes .../Newtonsoft.Json.xml | 7711 --- .../Newtonsoft.Json.dll | Bin 444928 -> 0 bytes .../Newtonsoft.Json.xml | 8083 --- .../Newtonsoft.Json.6.0.4/tools/install.ps1 | 93 - .../RapidRegex.Core.1.0.0.2.nupkg | Bin 11353 -> 0 bytes .../lib/net40/RapidRegex.Core.dll | Bin 18432 -> 0 bytes .../RestSharp.104.4.0/RestSharp.104.4.0.nupkg | Bin 493675 -> 0 bytes .../lib/net35-client/RestSharp.dll | Bin 154112 -> 0 bytes .../lib/net35-client/RestSharp.xml | 2714 - .../RestSharp.104.4.0/lib/net35/RestSharp.dll | Bin 154112 -> 0 bytes .../RestSharp.104.4.0/lib/net35/RestSharp.xml | 2714 - .../lib/net4-client/RestSharp.dll | Bin 160256 -> 0 bytes .../lib/net4-client/RestSharp.xml | 2890 -- .../RestSharp.104.4.0/lib/net4/RestSharp.dll | Bin 160256 -> 0 bytes .../RestSharp.104.4.0/lib/net4/RestSharp.xml | 2890 -- .../lib/sl4-wp71/RestSharp.WindowsPhone.dll | Bin 171520 -> 0 bytes .../lib/sl4-wp71/RestSharp.WindowsPhone.xml | 3597 -- .../lib/sl4/RestSharp.Silverlight.dll | Bin 131072 -> 0 bytes .../lib/sl4/RestSharp.Silverlight.xml | 2532 - packages/RestSharp.104.4.0/readme.txt | 22 - .../csredis.1.4.7.1/csredis.1.4.7.1.nupkg | Bin 46345 -> 0 bytes .../csredis.1.4.7.1/lib/net40/csredis.XML | 2515 - .../csredis.1.4.7.1/lib/net40/csredis.dll | Bin 80896 -> 0 bytes 64 files changed, 210198 deletions(-) delete mode 100644 packages/Elasticsearch.Net.1.3.1/Elasticsearch.Net.1.3.1.nupkg delete mode 100644 packages/Elasticsearch.Net.1.3.1/lib/Elasticsearch.Net.XML delete mode 100644 packages/Elasticsearch.Net.1.3.1/lib/Elasticsearch.Net.dll delete mode 100644 packages/Elasticsearch.Net.1.3.1/lib/Elasticsearch.Net.pdb delete mode 100644 packages/MaxMind.DB.0.2.3.0/MaxMind.DB.0.2.3.0.nupkg delete mode 100644 packages/MaxMind.DB.0.2.3.0/lib/net40/MaxMind.Db.dll delete mode 100644 packages/MaxMind.DB.0.2.3.0/lib/net40/MaxMind.Db.xml delete mode 100644 packages/MaxMind.GeoIP2.0.4.0.0/MaxMind.GeoIP2.0.4.0.0.nupkg delete mode 100644 packages/MaxMind.GeoIP2.0.4.0.0/lib/net40/MaxMind.GeoIP2.XML delete mode 100644 packages/MaxMind.GeoIP2.0.4.0.0/lib/net40/MaxMind.GeoIP2.dll delete mode 100644 packages/NEST.1.3.1/NEST.1.3.1.nupkg delete mode 100644 packages/NEST.1.3.1/lib/Nest.XML delete mode 100644 packages/NEST.1.3.1/lib/Nest.dll delete mode 100644 packages/NEST.1.3.1/lib/Nest.pdb delete mode 100644 packages/NLog.3.1.0.0/NLog.3.1.0.0.nupkg delete mode 100644 packages/NLog.3.1.0.0/lib/net35/NLog.dll delete mode 100644 packages/NLog.3.1.0.0/lib/net35/NLog.xml delete mode 100644 packages/NLog.3.1.0.0/lib/net40/NLog.dll delete mode 100644 packages/NLog.3.1.0.0/lib/net40/NLog.xml delete mode 100644 packages/NLog.3.1.0.0/lib/net45/NLog.dll delete mode 100644 packages/NLog.3.1.0.0/lib/net45/NLog.xml delete mode 100644 packages/NLog.3.1.0.0/lib/sl4/NLog.dll delete mode 100644 packages/NLog.3.1.0.0/lib/sl4/NLog.xml delete mode 100644 packages/NLog.3.1.0.0/lib/sl5/NLog.dll delete mode 100644 packages/NLog.3.1.0.0/lib/sl5/NLog.xml delete mode 100644 packages/NUnit.2.6.3/NUnit.2.6.3.nupkg delete mode 100644 packages/NUnit.2.6.3/lib/nunit.framework.dll delete mode 100644 packages/NUnit.2.6.3/lib/nunit.framework.xml delete mode 100644 packages/NUnit.2.6.3/license.txt delete mode 100644 packages/Newtonsoft.Json.6.0.4/Newtonsoft.Json.6.0.4.nupkg delete mode 100644 packages/Newtonsoft.Json.6.0.4/lib/net20/Newtonsoft.Json.dll delete mode 100644 packages/Newtonsoft.Json.6.0.4/lib/net20/Newtonsoft.Json.xml delete mode 100644 packages/Newtonsoft.Json.6.0.4/lib/net35/Newtonsoft.Json.dll delete mode 100644 packages/Newtonsoft.Json.6.0.4/lib/net35/Newtonsoft.Json.xml delete mode 100644 packages/Newtonsoft.Json.6.0.4/lib/net40/Newtonsoft.Json.dll delete mode 100644 packages/Newtonsoft.Json.6.0.4/lib/net40/Newtonsoft.Json.xml delete mode 100644 packages/Newtonsoft.Json.6.0.4/lib/net45/Newtonsoft.Json.dll delete mode 100644 packages/Newtonsoft.Json.6.0.4/lib/net45/Newtonsoft.Json.xml delete mode 100644 packages/Newtonsoft.Json.6.0.4/lib/netcore45/Newtonsoft.Json.dll delete mode 100644 packages/Newtonsoft.Json.6.0.4/lib/netcore45/Newtonsoft.Json.xml delete mode 100644 packages/Newtonsoft.Json.6.0.4/lib/portable-net40+sl5+wp80+win8+wpa81/Newtonsoft.Json.dll delete mode 100644 packages/Newtonsoft.Json.6.0.4/lib/portable-net40+sl5+wp80+win8+wpa81/Newtonsoft.Json.xml delete mode 100644 packages/Newtonsoft.Json.6.0.4/lib/portable-net45+wp80+win8+wpa81/Newtonsoft.Json.dll delete mode 100644 packages/Newtonsoft.Json.6.0.4/lib/portable-net45+wp80+win8+wpa81/Newtonsoft.Json.xml delete mode 100644 packages/Newtonsoft.Json.6.0.4/tools/install.ps1 delete mode 100644 packages/RapidRegex.Core.1.0.0.2/RapidRegex.Core.1.0.0.2.nupkg delete mode 100644 packages/RapidRegex.Core.1.0.0.2/lib/net40/RapidRegex.Core.dll delete mode 100644 packages/RestSharp.104.4.0/RestSharp.104.4.0.nupkg delete mode 100644 packages/RestSharp.104.4.0/lib/net35-client/RestSharp.dll delete mode 100644 packages/RestSharp.104.4.0/lib/net35-client/RestSharp.xml delete mode 100644 packages/RestSharp.104.4.0/lib/net35/RestSharp.dll delete mode 100644 packages/RestSharp.104.4.0/lib/net35/RestSharp.xml delete mode 100644 packages/RestSharp.104.4.0/lib/net4-client/RestSharp.dll delete mode 100644 packages/RestSharp.104.4.0/lib/net4-client/RestSharp.xml delete mode 100644 packages/RestSharp.104.4.0/lib/net4/RestSharp.dll delete mode 100644 packages/RestSharp.104.4.0/lib/net4/RestSharp.xml delete mode 100644 packages/RestSharp.104.4.0/lib/sl4-wp71/RestSharp.WindowsPhone.dll delete mode 100644 packages/RestSharp.104.4.0/lib/sl4-wp71/RestSharp.WindowsPhone.xml delete mode 100644 packages/RestSharp.104.4.0/lib/sl4/RestSharp.Silverlight.dll delete mode 100644 packages/RestSharp.104.4.0/lib/sl4/RestSharp.Silverlight.xml delete mode 100644 packages/RestSharp.104.4.0/readme.txt delete mode 100644 packages/csredis.1.4.7.1/csredis.1.4.7.1.nupkg delete mode 100644 packages/csredis.1.4.7.1/lib/net40/csredis.XML delete mode 100644 packages/csredis.1.4.7.1/lib/net40/csredis.dll 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 deleted file mode 100644 index fbc375e54196a4b2a0809aca618a7346119d2ba0..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 454746 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 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 deleted file mode 100644 index 5297654b97476f2d63e30d91ff3467918062c076..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 481280 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

      Dq;={zf#7Bvb5uYILBR)mkPke@WfcPBodE$%2 zgTz;ehlq8rWBC&&5GN9wh|`G26Q>hTBF-S5N}NS(Ce9(wBc4laCAJaUiA#tV6T69* z5?2w^#0)V<93ZYGmWd<8jl}DSn~66Nw-9e3ZYADE+(EpPxRZDfaX0Zk;{C)2iF=3- z6ZaAyB|b)cg1C?P6mdWC8R7xrbHwL~FA@(DUm+eM*1ewPPnKH^iv{lsU82Z+xRpC`UZ zJV<sl-{tX5t*;JmR^;R$?2mow$T}F|nI? zDRC7sP0SE;!~x=3VwpHX+(^8RxS4nZaSQPl;#T5q#2v&ti93n+5O)*rBi>JZkhq8V zFmW&OQQ~97Cy4uqPZ9SMpCKL~K1Y0>_#*Kj@fG4BV%-FmKXC$aBC&}$jd(n9I`Jgp z4C1N8S;S`I9O69Uxx`jt8?l|Zgm^Krn|LX46){cB5Oc%<;#y*vI6~Y=ypFh;cmr_@ z@fPA%;%&qo#5;*QiT4n96YnG5PkfNLhxjmYFY!_0W5g$j`-o2w_YO(cs=nW#G8m8Cw`82C-G6@ zW5g$j`-o2w_Y>cpUL~;#-L)5#K>PmAHi1q1fnkPqclQ z?uoJw)99_Bd4-zsS_k=ui5rQVh|?!qJWn8=M?9Z+!Q_=2WPj%n&94&2O)+;z5hoHS z6Q>c6Ax1Z;!ff&;%?%-#QTX45cd!tBJL$VLVS$)IB_5GN#cIu z)5HVBXNk`fUmzYNzC=7ke3dw^f#pw}NSsWZMm&Z%op=Iq25}~F7V$LV9O7K!xy18` zZNx>yCBzP5H*p1V74dRnhL|M|5C@56;xKU|aT9Sf@p|GG;!VV@#BIbK#5;&PiMxoq ziT4ukCq6*jLwtz1m-q) zGI1L57~*u|3B(!1nZ#Md(};73bBX5?&m*=G7ZH~bJBZ!H6~tA<%ZV9cmN-BhB$kQ8 z#EryF#LdL(iCc&_5w{Yz5qA*pAnqjYBJL*MOT3@>0C5lTA>v-*BgDsuj}!M1pCs-l zK21D8e3tk;@de^R;!DIs#8-*qnppnCiNwjoX~biQ(}^b#XAox+XAw^$&LPevo=ZHB z*hXALTte(1b`w_+R}n8KW{6qh0CA95CJqxf5;qYy6R#(3A>KsXO58@=LA-;wlemkx zn|Lqre&PefJ;aBIdx?(_A0s|a+(&$pxS#km@c{8z;`788hzE%;5f2exC61fQ@+VFt zP9{zx9z&c?Jb^faIFmSwcp7mIaW3&(;(5e2;v(V_Vh6FCxPrKfcsVgc%n}EPgTyj% zn7EO+iMW|~J#h>1CgN7&HsTKA9mJi)UBunQdx`fGA0X}_K1AG0e1!NI@p0ll;*-Sv z#HWb|h|dzAC%!;DNPLNSi1;dT+%%RyaUyXtaT@U$;&kE(#2Lhy#974Ch;xW@iRTi} zBeoG25tk4!;COTBaaojO1f8s>qWa2d9F~sS_6Nod2Gl{c^rxE86=Mv8) zo=0pWE+Q@=b`ZOXD~PLzmlHF@EOCH1NGubFi5rQVh?|Mm6Soj=B5oyaBkmyHLEK5) zMchrimv}$%0pcFwL&UwrM~IIRA1Cf3K1tk9e42QG_$={x;tRxs#FvPNh_4dI9n113 z9!ET$IGuO`aRzZFaTf73;vC{!;4W#TY# zBXJXPGx2)j7UE6Bt;B7_9mG3`JBho9yNUM_?|{@iF4##C^mkiTjC9 z6AuudB|cAlfq0Pk67dl6RpQ0RS$TI8A0U2}_#kl)@gd?P#D600CvKi${#~y)-rGX+ zO~j8AZy|0aK1X~Wc%JvnhQB{<(#XGhT_fGzx{($5eeJk)BP)Tc@cTcYe+$2V!|y!r zY1kha`6l!qoU!oA?*SK2?i%?C@W1il*nz(5u_L z@eR}S<&!ZrO(o0{uBwP~Ms@TzaaZam!l7VaUZ zJF*J?eh6XS0{4GY_t|Ujue|6xZCji{0$$RG5*G{KtF5T zZ8xm&ZoA>#<8Hcf?zl&999Or0%MZLwo4UP)ANv~Ye}Me?AN+0@cgIbOC;#(JE5Up5 z_)Ryj9RHP@k3F_)Z#90s_e*cT#ukiaVe!s)-&8X{tf!}%FFK+wBaR)}eaon-DH=*pO;rF%Ux<*cW z-8Hv=AQZ0`t}L@ZpH6sGd6FW`-by(bbA|j z&U?egozo`V`^9M!rr$GdLJxj_br0T|!0UJKgxu?Fyx7))-!JN0fO)9-`hTq(1Qzfs z;)j1N9mU?^e0ILKD4#A@a+z{AUCQ*&UY4!Q?#<`D_O9&O;cU6mRxI@8)(n@@m0Yoq zzzh3AHY1j^qpXSUlZXqmzR!XQIUVEe@T$YH>mN_ePm43#&z0g-I4O*3HzcAOE?OgoxQIcS$kl=XNx2yR)Tr+0vp?33Z~gknJf#A#Fn@J5-~3E^>BN>6Pr1 z9L#7WeXgoRw&inR@)qZZ0gPslJE#p(O)J^fd@fy%S$pk;-drYI{v&xT%tae2*+Lnu zs_ZQvt{gsqQ8UE6?#gD0$kY+3iNm#1;Mi&=(J`1mv0!?#gF|^Vfkhi~@9jtr4WWhB^k%et7MzwqEUb>q zVRU%~#(1c#cg!cS!~*DCT`o$+^)y+d3hMAxuqrcS0k$th{-AryE-w|=p+89K)}2+^ zi!rx{y8H_(m7$O^(kWH<2LWHGg$G3Fg0bzAG+KGtt6?iWe{HK8Hr}E_?@%#Us8~-Q ziK-5?fxG3!BF5Y*b2sX5KD(^go2{~FM^9RmW?Rap2VK5-iNx+guCEXIExt&%?0Rb@ zSiD5dWvYTucL=|V9E{MOKUPQkX+MBSavc@<=(}Uh)kqvBf63jLVVqz$6ti)FX$q%P^X%mu-+8I+^Pr6I#n<43hbgOE6BN_YV)G-6Q2nc2Fv48Qo~MkQu>1 zI+W)S<}Dbhp!zP&uFK}VmFZk%aj_&hJB)#E!w}|2D|7kYOuE!t_UO071p`=L8l6}t zIx3xQbq*;Rjxl_D-8v^!N>4xPTCZxmhu5sZ%n# ze9GD8w;+N-#*W?Pxc5XaR^troVYEhz9h+DVe7 zRwE1}-PuY7@lNvJs#?w5HS5<%H>>Mw1=5u*6^D~X^l*KznGCJS3AV}g$)7*esBboZ zjC*JF1tS*^V+L2t8X1nIRV~}vbFGEN%e{fTzPGDb%9I&lxN&O*;$!_xBqu$DFFpyqaE zx-^*7u+`66IgiCi*{!oeeF*Za#uUxjBz1zYs~JbwX+&zbNO06j0tOTeUWu97iM85b zE~%KXkf|A)6+`H6vEZxKJHT!2`U1;Z5$($Mm9j}0+MQh^4IrT-Lb_yKSEH4OY?GE$ zH3|uHh@2#_Mq{>_n{LR2%6uv20sfen5KppfDfyQ5gjF3k;Od-`*=+}YTl;8fN; zJ=xOWC7A9MO9{?(P`a>KvC*IwLvoVTZFm20r58hgJaDs?nMK^r??)4?Frp+-hbuLE zr5fW@txPd`t&x$_D6WFz5$P_ZhsyoMgmSVD2-Cb`Ifu-y-ObnZ!HpiZeLw}N9RaO9 zwcTP`k7ytv=A;_ZS=Htb7L(XuLr0agSap`R#}!%Xa7yhs;M{4I*{0Sq$MG&I7YnVW zQhG#nwixibbJ#4&ij~(cs&g!pY|PQKYeu}~#Z0k=6}mGnLsnFB*d0XqNe#eOY8KH5 z^sYL33NFIqc{={CGT$i6GL;wsO+ zAd5)lGAKa=fTfHvB4oD~M9i?db`IdllI)14ZFxFZf@R##uwS||$3|HtCyCH*HG@gH zpL5a?OP0V>uSdQ0mJR3gjK-R5CB;fBTOgQNdgVAtxVXX%b5)VZh2>vG*J9!kSbVeC zb8(x)a!{;8M$~stI8X;Oy04%Nfl2I8S`u$v536;A5aN&}a+pEQV&9t27uRQdt?9SP z(ofkE$ijX2-EB$0;W@;QMFokn>4Q2DWf{R+BMO9f;<#0GRLs=JOQY1fU(6lEc zFfshu(we-MXf);zq>#|e0AjAIORpswuS9!S>~YH==5aeeDRHZC+G^TLV&j(a)W>-a zTat11q}+>fN%?nY^L^3Xo~rG&=-Jfl#KW!G;#0Ix#_nfALyrs=e`-9VmE*|7^GN$C z`5A6aV@`N=XE$aKC5AyuIWoC;B>j{4`K|THMDGZCC$S567)K_8N7lzs9JP-gbCr=g z81D4P?4iUk-gh3Ey!>Yhg3|DoTvBc9H zkTBtMJN+$Vu5-~*E;gi&J%H#?^5+Sl_T*>G`4jZve}<_0J@B8w?{JO!^Ld{<0UUF# z$9tgZB1kMKB@6|nj74&u}vt9owN0z(-RdNF~VZfd+pqsvF!|1!$)|Y zQaTIRtH?u4COFG>7Hk7JieH@0<%h9Pb%7k2Y{(4`4~hhVY_g~y2$5yq>o$|xJ3W)o zaGoueqjqqq&{eiqHsN(c+v_P72k={3#DOg&G$5FO%{tk~TbA8W5f*R3ut;%qV>dD` zyU>v>m(y#qVPE_$HfP7?GSUud&5|RgFqzfERxg$D#W=%yl}Z7ZzY&@mOcFdv_4?A9 zsY-vTxZZ_^ol5MIVdKtgFY5`169YlU$iA>_4zXH#vYpl0=NQ_GL&(~Nxe_uVFS!93 z8j+>wEQy>0xR8_H!eT)Lif|TFhL!9{20{Bduo7~9%d(J{?DgDn9)G!?|hf;+Krc#cJOT|IfpB~8i zh#XH+MK#&iTJnq>6OdJr;aTK5Aw5zVE}`m+5K(6-B6(?6QY3*iW?QjXf=B^&k^@hj zPV1~Qi0AEvo?_5;*baJ%Q6K5RTIxbnd_CYYqa{lkvdc+tG4}P!{hg46Km&;|TXZ8S zK%QFecDiFEsd8u}=povQvc)dNWv9=wr;Ov%WRcJ+_ZBb9G(Tn*KE2KMN*EYZn8A*# zwJdZYR>j`(s}jmD%Yv{xm&V&`ha89`0wU9{O)9H&8YYAb@6*_Ml_E7ybh)OYL1kIE zsZMCV10nkcu`v-_A)Bs69mVD>*uS(O<2LFpMt1z3d26K!X`vkCn1ecH?QnUz(%)HV z8!nZw?$Hj=;;a<}^(qkC)BSA8(;ON&x*C--R3gf|RLS;s7R;n_a4-e6()H+)RBc|u z9JiK`yU~H@CbnvX5{{dA5H^S6YLZO00nRGxNc6Yh_atR+@o*t?#T+Kda#!;MHMJAR z4<$%WYAjq<#w=Y%1Zh7^!Za=6c!Lm*P0di+adwn0WKa+FWGCyT3Nl8ehEQr=s$|XB zCDWbj{yt`5yTA!|Dz>MR=Ki`KvUZJ&vVw8FB7@~-s9($W%( zV4Ni(R&gdjigBw@eB+ibvN0RY*jVhUi(a!R6aWT+bU9h=y8~wK#~(_J7B*sUGA5etWIHNeIT=(aN5)y z^4Yi7kxeZ8A#M>)jfcuu8|3o&Tp8Ch3J};8j+z!#X%}9XmHrVU;uEV*EfQv&niNi) zD;j9ro-v47XgZUE@Yad=eJT}QGwL)|Dvi}K>p*lM(CqaqtDnJ9ip?dw7IPhoOiP42 zX3a1oOd4$2Vjww9twa&SGp2k(G+m3?#k_4%>lm3nncJS|Y#ogrqrV>!n&p?kcCqU(1;LAR-rVkWCLx;%E?HZtuy%yDzz$hs`1Ibh_qPw2H)DG zc*V|iA&dNwk@G`7kur5cr`ESJ;b^fjoo^vkO;e;ApB$DC7FS_&z+|$~YHwQK%85pc zozwf4CIBW@rt>XqpF)?@unbIO2t=bHQ16RLJIiX(XeV@!o~E09c!bsEt!-yS^4Cb= zG&|42w1{u0CoUA9Hy}k=DK+ibXpFFQ>ntd|(-N~rp#>W;Wm=2qG_F2C4H1w5MuR3q z_5}fb`!FSm(R}f_j76k-bgiXV{PZrUktlMFkymVJ3cE3>LfV@lZ0+P!$>5B}Vq(9L zk&>%&j-;~Ik{XI#`{||G(T!gieGX_C9be~j+3Ht#P3K#tRq zIC5SG>@^tugvVX@R<)fbI;vvF7F56nL)2R3+I@R9B{0bDU6e^E5k@u=7OR;O7<7Pf zUXe>K%_gu?0zAr0VgkFXs?qYYAfk2&j!h^$8kEr@%xsfPWVmTYNs^*yJjfeZB={T2 zn~;M9)@XuUyv2dRcSX!bM)&4u%Pymip%^I!DAqP>5YG>AVW6=telbwV@NNE3ZnZ>r-_at>~4V< zEtn`Z(Sh^Yu~sqZm9uJ3L&PNZz)NLJV)6TgDqf#n!%>_)!su?oMI#)gCOUBbI@Tx? zR)SRnt}G5oinIEj2~*5^IKeANOJELrHXQZME*WXp=mvhronRI5TaUQ0%dh+Hex^Iu z$+m~}pqA6xj-q803DT@;J53DCvE!1I?1!2$dhgJS8jYo6O}2s@@Q49XDKzGdMZqU| z9eEB^!RsmN(~x^h1txO)Bro8lRau`dP=~%YV&!!hokX0h^4?il9YxJ?Ca)vJVb;3Q z6x@4cQ6y3m9q5xB<-mgwljMEazrb9@WPSuirJ=j~lwlvDw2&{(!hCY3FhkHv$rBK& z*+L9v9fu)#y1~(0X6Cyj-=!QtGZn zM2)G@{fPGX-JIA)Oy)Kqg>22rhCh#^pssNvLPdI)$z81quBq$2s?bq%^oXaHqcRRs z{%A*Q;Hc_w);63+6;BEBPj@Y0^O!JtfIsT66J0|P&R+O1Ndt`NIL#H&Ft4?@H=IET zw35byE^-I83sQRPY#QRk9!3?5kbkiQs)S1c31yv>e}AG^N!bze>W@v<=qg`QDn{or zDbjjqn8G68zxwMNQjrxSXpN#~aI*mMVua2ItbNVzij_ zW>J;$6nTPlCrt~TMx%>M;kk9$RIvd0OpR-ppl@1bJH<|!`-cb9CY+Hn?S)Ec@jZ{l zuq74pFTqy5iP3%kys&eRfofFb1T$|jHtkX+w4~G&_tBWtX|9mT5BFvfh`yR-C-bQo zwcXhG5P(Tuq;PK@9erxJkY0zpmHWyThXi`NvaSemT87KLYKU4PKs`iZu2)lW%u-yx ztjO(0%l@oB0hU_tzX7HN7NfSr(h|!Ku*4FQzyuM{NL&+GszZ;l#3JJ*gpG2p3d&1W z`-~y04Qy#q~It!&7G>v4mydI+G~80NbAO z94wAgdsR`B&Pqfv6I!xNPleAW5vpCVV)5cdU8(N&%NA*Apr_`Ox!q0#M~WkXTrK5} zY1?3W2=Bl`I(fc7y#q+H-hju`dXUPSozV;C5>p7`pb4^5@)i_(eZ8GQvnLTb zi`BS%?lC}lF+)T=R%TZ_w>Dd=A|n2fzuqv?-bV>*5d13v!HqTF+B^yQy09oY1i9@( z(SIexgMA?DVDh$6l8YHdUSU}!FyRD!P`)~Ki6(+lv?`68Qv2>oc1YjKAfw;G#>*sD zOXDmq7kePQKf5ctW;maQ@Wv1d%pPO0X>=2~Q98tsMT@A>57v-JejE0Eu4c84IY^y9%*MsLI!U5?;gU&)^?olP9 zV>;XZ5P7YAwQ63triH6iRSm1IR4g2; zP_-*lq#{KtQM3X@Do<6#Nvbr}73MW6OL9dSRV8ti0eP<##F>NqwaTINq>7PT!h!Q> zp@vE@Qh9X|7C4$6dWaU(K-k_^AG)9mxU~k1)jQXpq=rJB(^x$XS3k_zY)qG4Zmb@M z>oO+Lk?wM=epj^(@m@q}M_dja0skZZrG{h#_q*S*dLM0v=DFXK9}&-e-%`EdfoH6K zM>-vgw;QC!>b2&H^DH%7#-+9BC^gmqk~*=}K-I7})PzRW?dhG@%H()vcF&x;` z$;PWA6-+S7n7l^BZemwI?#Eimcm?R5+2@j^3S$&tk`# zmgFgqUH-*%H!80__6j|!xm4&5b9B}-*2D&tFzRn=t-QR<4c4&+l01gfTo9gc0$KQz8>CV@ezZ#CMsEc^J@RbA$~;a;-eHj;*ej z+;4O%ICxgg5weQsHa3@%HgCLyjsL*k*IFtBwI;T460h6wPX*y&PrFSOXC8eV0?sin zRa`X~OLW5ZXDt4NtJzrmsj9JK^eR%-$KqFXAu(p3{8htPe2T0Q#^ONRHTWAVDygnW#Cx`Ape-c(PvkAz=AXE^qmy2dYQ`aG71)}AJh z#n;HBcq|?z&wR(?Bj^4l?YQ6 zsU_@hEIw-Mdl|QmdKR+}`|XLr_sWa9^isVj8JT5agtQOE;mz`;cpeL8hj{D zPQvw5uCq1dq&KYow8%u4fA%`tAMI1g8j}po)^a5SvTM8>nY2MBk9WHER`%i_^dU}d@hmId{@K0Q^osO>{Li|`h zDrfH_&>%fp{Gku&vM?UVqX+)03Ot&}q*C4@5qG4>10Z7T4hvJb6MwO&ehx%vZsjj} z7ftsf2_LWMEZO(xGzKQQV6kb5ML5>sxtBLAwl%F0^|+l&N8E;qid$5rFwVf_#w|i= zk6Q*qa?CDVI!XD3hXSzyohiFbO%Yd-4VqM@>P;{Ec%w_R7GxDkDg#pfeu!wy_o z#3dj&fKJ~I-B-wCfU?q;j#V66A*k2X3RR?bFbzm6-8ZNW9GYmC^v&Uue5+@&qfROw z%#u;bxaIk*sL7Y{Fm|Q_Uj>yBPCct4_2e*Yh2Kq*O&OGtWL--%Ut&e#>RgZ=aTZH| zobJ*ew~TAWw2J5E+F$_aFr-^o@%=Ev=s?Z^(Pq&4kX zQZf5zNnp1wRO491tm;_QQHZW)RF!wCFSkMEV^F~MHXomqvG;_A@l2ur9vr@_gU1-P z##?=p%Vi-FR-Aawv3jyE-x&$B#nKYB)&}EG8nlWArbUGeDtoWj;*(;&K`>E-OXTaT z(v%hr4&meDsKa>65U)ZlfaD^iN8~w6N0KKdsx5tzSaK{e9uahrFOe7YD?gB&hZGBV z0(02TOOTpzP9c6Ndy655YY<&Xh7D?(Rg>VH-x-=6@}}i5Y~ha#IX*itco$vS_l@Sy zuZj!~i#7k?L0Pg3QB~OsjI_8UqE>u&hf?2|#SV>N?A27@<7jC-WeC|@69iYP$!>&l zG#oi0FUt;BO6k1Fj~^yUp>HZ3Hbp8V@|xKgOe$X6GbX^Ql=`f>(;lRj9P30zUf(9v zHwKZkNFCDLz?)sl9b}E0%u9CL(ycg@(nr2>sKU^<7tr|9kkuRUP>)f=?W4Jr4_aVq)`YuXd8 zo}Yb|i7N`Z4Kk!*e_?P4?zo2YE`qFc5*=v^U1#uCRQk^0F`8(tBSgy3*z=IiMO5Tv zUr3SSn_8VEs{kaK0nuqKjOaJF+WR8*;>26*Eh=Zyc*~ZP&h~QHCyK+J;lXwhz7e`I zSLuiFw1{X*?`6Si`*JM?O|lr;0Kr$yq+bLvNe+)~Dflp(XCs8{n@O`%N%=IovJg3; z{h{J;>Litl+MxO16K1K5eBiX#_Ya5vMq#I=&l2kwoUww|CtqmcKj&%Gz!-cZE*4qb z23=PizMpSlTYH^_EMBlImhe3|2&|*Wfy}hJ_ZE0d zybkXI_X?D|mg?EHH}8TH22=0StVn&Mf9v)1bp}fucrgvcn?sPUtV%u?H_iFV4zyq-un{nHKhytLz=cXX(zM4Ymyp>le4Z1-L3O;C1BeIqK!b zA(8w=^46!(i>qZ>3O|iKjxD5}pI+mrXJH+J{U%Ji7|Pal3u*b(TGJC;A-qMe7Eog<;Il z^Dzj2H2MG%_^#w?oU__fHsLfn6`w#cFLPho7;5c+6X3~a|7Hbp|*z2h`L@@YKt7~Wb) z^+iaFVd{4F@HK3i;CI;CVwumb%ewnWs?~7Ur*oB5U$Nw_F_rbJ>z0%nb}QioU7QX8 zS@xDuzY6|ZHRbzZG`h9rYt&IGD>tB|mr5l@B5qI5x_pO;kty4)RxKPqHYDOQmSjaN z|5}20r|tTgMd@&in!v*`#1e2gW{Y5q!{Y1Jh+c?p*&Xo30uS*rGqgB*OCzb$Ft5-# z!$Q0y51KOI(vy6V-D-$4s7;@a7_uW{BabzQDxwW5{^*2@c@|(Sr7d#3Np?`yFybB|fbWj;(bE&f$R|9u3T zj#`?19v$$i+$qg>)+0lry22tv?jBh%&JeZ<4WzU-3Ua^?P-7ZPZI~l*FvQ?vp(i*E zhZVD~4jQ@X$3+wBJjM`aAy}L(pVIQ_0OqUdv8odiBCMK(@Qgv-r|soRyZMsxO?a$rRp#CY$9JEz=3QC`sT5B=GY!6>~=N={IEi`pGjm)Hs77xPNm`_ZWfA!Ro9HTN{SMq|Y zxy@$_IlmB{VJV54saOM`N??h|JD=I!6nc|EPAY2JE_KduEe~gh_+p1TQZKEQQn;OS zhbmgPHe|Q8t*){vTj-j&w#q2UxXq=d&Uv~)?-X0URM8j^Il|H7o#TirM>AKvgdEf? zzX)PQCZnz9bdrtBs;V4LV0Dq#tVq~2W}Y&W4&#BPw>AS48e?#^+fOOZYFS%wxw}S9 zVRZZgkH*sV+DN?>lVf+8t%ZW!A?=W~+?_#fq!D2lALML4Fv_-wSr}i1Q@{!|J@~bt zwX3JGRNAe7b(>^YiO-sxSDxPbw@_0OkOrN>%#y<}+f9Tb`%5-C;51yP?^f|ls}p|n z%SLm0;|vkkq2bQ78V4ID?FPPi9ic4OQ50wTSlL^4$>LpeyCOQHVLzgP4`i_yuK30t zU#EPSRLe1>x~3k>#!x0C6gc*;%6PcL`a!wW?l2?{*vb+=d3_CJ2AI+>a0K0x^$0>ohDx!L; z17U01oC-6M!ob8C?l58J#7fHMiApffboW=8-4YLol^sc8|8u=zzf0N7NG9(h=$mj5 zVq~sdHEFSI6-$X)O$!UDwzZ@n!8VuFVY+xH@VjWotit8OxVmCzCXi~GE9+zYoR#yI zC8Zl?uBBj_ZDk{Sszwx@EU3|4p{iu!J0YOMIw6wkvs%(qy!p;ukUrIFP=o0WDV+6S z0nR-v4K_xF3@47j{f#blD({lWm^EBjBM)}SQ|+uui8gXvg4uv@+tUr~?QCj?xwFVn zVT(-m*EAAI7TAi!JP^#bohG~*7k_y>s5^7&zKX^*vu)iW*CY>O*(T4rL^C9TB`JAH zY%Z=r!V{FZSV(#O)HrsO`#z z4RLb$uao!=<57-zq5)=5xY#1rqM;t6f)e9ikii`KJGIvG+!z`o2V1(@U4}UZXDeUEP-4>yA;NDL$vsf&B_O)_9EbPCy2ovGRP8g!W z$mh#s=DLQT)Y9e^Cc@oH@L(wEW_#Mrhw38$3%F44p=QbM{P>5`9wV*E)wypmTv$`Rgq2qP_v6QUK{dU&8}f>nJx7>X=){{E>uaA{6IB6ToB=w zQN#Ib1mIWt1n0?hJAskqA(gteEo*FThM;EF=CL|>7<<&S!`N!2s%f}T+=quhQ`+J0n0kA>-~yz*+jk2AQQ#F>L) zz_4WeZ27)X8nbV(hU$!xg}$A&KK+&^Tbs5%O$Ao_72H>l&u(fbP)+PXqv;NK)S-6Q zDu@<#8KY|7UG26A*~qM$uQ@{}iRwG9vEq}jI5)Nk1x5%V(!%)CBl%+59WD+z({iW5 zK8OrpK>}mdf-{`MvoMYcj{TS=*)bL|tLjK`UKEN0=Els9lplh8JC&)`v}2fn__KSa z&^NU^vNE~JjO$!Ew<-G%#d79i3l~@Zx{ASRD^Yzij?f-fm>_!@7MoaNgGpCXgJrl0 zu0r0&Z2i!J*%~BS=$F%kHu|x&OLJCfS}fl{&~#-tK)gz;z3T9x9NGR?wph4wu9b`L zy%@I~Si!AjRxtWm!|PE3s-s}cUn6r+4v+Sxw~|Bybfu_TX;mz}vc2GIb107c5fY#N z)z-*hXg?^DBsTPiDHbFtI(dlj*mT0I^@H;fe%&I9@GFIp=#dR1)Cx^oEGu9k=}MwA zHrmG=#$Hl%7;B08VXP&lF>6K^wN3LJUmez$l$qbYQS;I_X&(6|%>m6Nf4LkizpMa~ zEV$$k)`iHq1ipBT6PT>v^J%v`p}M7F)OeNT1u3k_MKDE|$`-3QS+1>)=*1div$EH> zF(ZQF{jrI)5UmoHitA+#;+>~<{O7q4jTTC_0C9j)}RyQiyt*#$1-6&(u}b2Z-*juZW&B9n>0_7p`X*BX+QnB7w)6OPF7slZYR1E^|EyjQj4 z#$Fq?aVoNShO90miPh3BAW2ay#pOsXj!uZ{N)daD(v_9{Iqbd;$>X$gm$S7W8>zT0 zyP={-GZ6m7!`Fkeb?~rY77XJc7;gPUSVVlIMbS4hZoZizi<~d^6muE>+R;VjqP$LI zb+`m)*z;RslLcNXt-&Ep?eH9!%w>u-Tubv@UfcTc9;0;qD5DWU@NE#&Lx@lC7*=8x4aUmxtJxEz&dS}+{<>EPKo!-3Ij(zaqsBBL`KSGp7)217AxneA9nb7yNM#k#RU!`XQwz{bW~dh^br6i)t% z!axBpHk*Z}$}&MOZVOdM1zhqjZT$7=->r3ED` z?n9w1z}vcgOl`~x=O-n5cwd?@GmkmPMI zM84Rbu_wNhEz|mRfMhXioxRlU$t40vWlM|HW*XGjUVG?LW+0xi((ZQ7r zcF^hczfY&b%FOGy2v4^hq>FaD2beHQdxr2@1|J$P`n8}<&b~mETtx-_so^~0TJ^~U9>0aZgAjYcKU@8|f?~ecf4v{yIH{yX<}*y$UeP>h6J@8&%PPew%>!tN7NRQlR^3Y7(<9Oyy5UgIqw7E>v8D7hX>6^Uxz&*=?>65(Q$C1rZca+JVAq@3j>pM z?iABOOwfzM8+2T9gKq=e+qN+V7TE~P_lYCqttTTISITG=$dgcY^fGz8G}wuBc-Akt zuR|bl{$(F{g97cB9t8*VD)ivFD=qz=-db7bX%B?E=a^|w>ZzATBBa|YSlb9lIXrN!!E;caB$mFqP z9oic+dKo)iQD}%+tD;%HBoPkkO`1yO zg0$>C6YN2k7M1Bq5?H|nS&GsG;weFGFhP-+AP2=Vq;+D~K%`7q0Tsfc36xB5(gYY* z14#ghpMQKL25lO4DlLOc_$<+joE?b)naM+SF@;Z#LI>YcuTW{s&+tiiaBRdQA=E>j zNvoAbg@?^b!BXB1kj*4VM(#Apnm$chfkS$94gPtWr;(P1!}A_1@DRbBSOfu%yp5c#i_b{wy)x00^VP-T<{m?(Sh_5yG|i#>p>7$LCWBR z$~+JZrEN>Q+oYl8(uL3r8>=V`p?S<-D*0@{?8x#;fd(J9!VZ>h@1ohpEhVIMVI;{S zG|`A#Ga+${#h545w3Mvk7g*By7}vt=YE(%XU;}TBhWzT#HJn5j-}sU)s0;OegX+ow zJ0~ofs!DEkP97BqY!~6~G6vdkKA4Bul5Rj?eCiFjJ7x14J2(NQWjSY2^H--*r(+6G zI8#-<2EG@JvB_5L}71Lf$lkEU8$xa9?q2>8ZLr zn%bgp>1u!yyk zY>oJy&CxT9_OiZBhQ*0wdOLOlbeN_&C{neJl%zV)WkW2)b0oyYSpJmzJ4>>W;68BX z2Yz-unptrKW;~Z8wbEbDOTt&zw8_YPS+_~BmO_4bYl^Zi0!8D8;*y0R3MoiREV|8_ z?bZa$tt({-yZLnSGZH1ud24v_bTpsoX8W>G$7E(0xBS*+}K z5iIiAdHu%)8_w8-aNK)B@P9V46QAERm8^Jl2U%Q}F=w`E@zlZm=9HdUi#DIaoL{#9 zELyk*@fx9oBh)f~j=a-grN}C+w8+j^%j)4iED`3BNr@jXA=zI8_f&8v;?oRlpx%FVchKYuWlLhF@2?~LZ8C|8&JpIiX0R=-BJ zI5r#5v!x4jy*RN9##YN-ZSZ6bQ97`=TZ1O16%s`tn~U0jIn6@1BiZgIUHU+ZGz?s! zC}gfU3&SwFA~9mT(6;62W2QJdMaMrhR4k$W2Azv|wW5-d?^U9MDB+Y?G(~$TVo@G~ z&e`6`sN>SaVLeEcpC^OZZ^gRA200u*uh%LUFfQuNp#WanLOQH0J~wG^6vcZ%yjIf^ z{U)dM9jEJ;>DKA4BSd-oz2!(+2WBkTbB`p1`#Z}qo5A-MB+u=#5gtQdmR^H-S$++6 znJfJ!`inh&Y@jrsemW*TnE&HxC>bg_R{@P5u30L_YGEtPO=Rm$-+Xjk93`$>c`hVJ zHbH^Ffqc7?qo3Eh8U-c2K^P@$d-Yhg%pR9B^p_c=@yrcn@dhKtcf2Eov0l=NNv-t?mPr5OP7w|s zjdhmv*ccnAn3#!&ZUa;F(oVE-go#qXsJMgR21xkQ!Kne@d9N0{e&Epmz?T1+4<78gtQl$)(sJRN3iAVIjMQJO}9mEOgOMw=j_ZR^9M)oTZg{-N2W4RP#Tb){zKiSJB69v>&Aqpaa+Hn;aV_hrBsQ?j^-6f$ zt7W!qTib{d=$pNP(M?oP8GR4V7@d zR!p+vM9#ThYi@?;rX?h;8@OdXfOGL&C1esy>2ZBK-w-PTv{%eMRN!2N+Gk_jn;nd@ zvyjM_2G#8tjWLK{`c+U0b?>?;&7l zD+@hB@QV;FD9Sc>bj5=1JaFgxhK@X-N}yPx2LzuD?LMFiTi@sc#iBdp(D$x+luf_c zC035RWy4Ri1!I&(#t{Q=F-k>jlzrYPql!^0;yCa&GfE#^F1d(l@aWHzy~Ua=Y9s7t z%o$x+XP_&n;Vt&AMzdr*!!k=>y48>|e8WdI`$<2;szbokJ4(+{_hX*T8RcSjj%AD= z=p3sB(U{G#S`aXuJ-V39u^M0HS$dR?Ejt#wtG$wMbF9>TnxA)btmJ(QVLr2YbOD`- zjvD#ryY)Ri^UP6tVA+F(Lmsm^3E7I<2!VH2=pnXI4r*s&L_`Fuy~~a=c9u2r@}k6T zt`)c#{g}pWtkER_$({un1@!{Va8E*gJ)Sc81rzHec)M^HTKx5WZ_v>)JE`g@N6sbfbHy2 z_IqbrzgO+uDEqv#En8$}r{#OLmAIONxLKhGOrz}c&bB@;>e)G??DNjC3|XE<<&zg{ zvDYfOca9Z!nC!>%94q>;ojMt1M|h5Pgkk4_*Q4wY&#|oHJGL6Sl|LzghgJ(hjPpj> z6V9`qu-e0UqwELgStfPyB?O7$JgWqb?P6IDT*&oic>~ZcT z=(JS`NAkT)Ta9pZWgTVTn6|#rISsrVW&fDA46^q|HDD`#BLv=A6$r77vU6N*onw`E zt4G;4uC|N`f?aJzU+tZheu!<99ph^27^}S-Wxu%EGR1bUMaWn3Z?zSBK=ku4W2GP1 z2zzFfePqV^$iQ*n?I`=n3^GZM7Aktel|i|iDewp-A7U6~4~aEXwMV_9>>qoPAy_w; zalsKe(TlP+lOLmAly-<=l$~HNI>Bm>M%nlEA`7sOqR~O&LL0;di%C5hWp~(z?y#0WL13fo8~ds=R@dLeW5U7RZdFQoQ|@CZ9W}6Y&lb>N*)^)Ffh`VpOfX8A1ioBt|_8g*wWfy1BVJ<3+;3 zB2`@_#U>O&b-fH6jbi~FZL9EFX#yW>dn7 zS6+?F9ZKr{V4MWeCP;@n7Yx-IH5fA(pM9+ZF)ve)5a-w;2#8I33QOxow7pTV1oHGU zG*H|gMimHKp3aqGd4NI0C3FtO(o_r%H-B~ivU*dq-ClT;v$S^qGd`8Hoo(PK)Wq&X zUnP=*J}VNhU8Tm_LuU`-dp?KnW#HDIe}f1`s<#)qD2`T0YG4C)xiFqf>dXrJawthH1 z7CAW!52#=c3>ZTFx9uzmQY>okw|(3Y4m~>|_RDdq4KdG)^|1*dgc*=E+Jw9nY|_pQ z!Gu!9&O;&QfZ~Esh%_11;v(5~gzX>ZV92vK1xXAxGxr=LXdBPOjUf(s%u zDY5`)h9dIVf~VGSjt-&-!iyF;5J-q&ng%u%5JP6D&=|6P{@JONNRDD!8#;Z*^uSqQ ztrN1C$Cy#5HFi|hD{%^)L}T)w`1XVpL7(f;M1*5uaS&&cc3BL0g`pW$vR7>UzRT}t zI)^KreR@_HbSCI#LW7EyOUTSqUpc@Hjf&P?N*_`FQv^Y*#~hpJhx0?~mJ?QJ8OV;X zAYCD#AVYV4@FVchdVjjY;t+tUx>d-2xeWUPMo zT2HJsF~T48&B8w?G(FLlUUe#bHm@Y>kR-Jl|2brZUIY-Iq-|F@#-izPF0crwcG0T> z%ebRq+ZLg~qS4Oi^sH4stA^oICes0f&aLBq%Ykn+I)M}GDXggm)C51!zrm00TA6^; z<5-$dbr0`GI>@S=YewEg!wF&~acw?F?(w_^&uS4MZ5LsCkuwO3kb3wx?r6_DYO)74 zwb)DJ+G`#c@q4`!q3`o5(3hYu$>n^gxHs$JdqbdX^v>`$0V|*k!nW+a2c~y`e!9{( zddWR^E!2w~uQoaeoM zNK@@i=m$p{+3mev{DsYAyyT!oAX)F7x&m<;z^~}7hk7Eu57&dg<B-JSc-7r!iE=28v-7sj7 z#`V0J_?8=ZBz9sy41F5DTbOBYHTaNECy8(3?|SeEcM5SRz&FVQshr+PxDJhSmKfmm zDey_0(anHT0)pfC4!9Gyv%M}2$K{3P6W)kWKOqQ<(z*co*@F_j5ZLN1gl@Ul>2(Y3 z^~=2#f|D1*ZmIGu^1SJ;Y$PQ)?@EL#{z-`5 zMrDCTxRx>xVtFF+TKuw-2sm9XxprIx4^nX{gs*`TFT7rW5T&MA$Fg4Awopz)IY>#m zoIR2L2fj-Um3lLzHC^g}H}n18Dc&mY{oebaUhciqJKsB1^{1fZ-l_V_J+Cz>rBeP7 z71xkOEonWK4o+%^%TbofEIibKzag~tcjGUpwbJG!&)(zBLnnAT{=DOc;8ziTjG#93 zLN9d=^<=WpCFK=q1r7ZOU+SNv9j$HLyHPK!x3Ms+(|iv*SLq!r2GV{^2R~;?DT|+y z{`VnfmK*OuUd%%3-vjge5QgZz3Bw2nUrqG9I&U6snQHxT-MQF_Pp&SwnovOvab+j< z$D3CL2n`v3xc+MmU@v!-45EJ^hGifNx4|5NL!N;Fs~FDCq`g4mr`od zYge~1tG&`%h1Y6%PW_NxN9vtqi_oRLOOkC=!Uhny*2iLd3hI&c2QvCdYqqh|dU=O|OC-y*SNOPxRh~ezzNA_A-1t_(Z7A522ihDz*r}PNeTrnA)IQraWy3 zr(I2N1N}s;J_YR~^Dx2h2{PiysOO!O(%4IH+mG5WqmPtO1$wIx-bCS${&fK3oaBg9 z`3;^o&FrP^`1TW|Pmo^L^#S6Gq%y*Fd?sC)FYHZ950j(mlMeCnSp;& zW;VBw(N<#?oc;^dr(dS*6Behb?BowRbVIJRalwNHvOO@n-bjp&_|KHx% z$H;YE_r00f-I@Iw?%X9s(wd=07FAI-MN_uY&<-7IYf7eKu1ra!Lp4;%)$WK~Yq`7L zU0P%!H8XE%R4S-~ZIyxrm{x8XLThltq<>L1};q z=(@k(Irq)n_wF4^3H(oh@Z;V4&N=tobIv{YzH>k3y-y3ZJ61#@eVQiK(&BsF@oh=& zq6O1*H)tiXNt&8=p$#|}L5~!_OjA$``X#W#91S=fqPMAMbfdkIgdL6v6;qA?H>w}L zbhocayu%INXAY&jjj zImUfN`PJc)kt4l6^ra64q<66Wl#soZdA<73V+5*xK`e`nUK+2$I zK;hVwxyE=BcF|~{r82_?VN%=Hyq5g#g7b>L@NV=4)UcgrAI$U4OVzRVt zy&Nm1%d}g3RQq4*Ibml>>{;~86z;Z;Hd$PoCp<8OleR&9S?`QiaD|}bjZu3n%EHt4 zZ7se2?$e1)ow!hE+=#y*5A!;o(wMyyAqH@u_aX|%ULFqZNZ1o{m7e1GdJi)ag_FIi2ITAY0 zfp)um1l^|-9Xn&%4f#TE&TDjL;Ep^Fv^|P;csf|j9I%rtzU|Hy+OW3OJEhyWcArXc zooDPJ*aA^FVqHGL7~{Cl>&O{>gZQ?+63$)t$k@OhmPCx{u_1-=q$ST31$rx94k^+e zk|;S@pG3<$y}c{Vr~KCIO8Z$qmU81KE=h2-=|s+u;g@b)CaFDG7M{}K&mPjbYxfXD zpFXtR7o<;eJ#`5_uIs|l=RTf9>_wT9cxJhECA|q+B2scOiB{byI+(U5h^21Kqpj82 z&TN^j@5I*`9)2xt9(RA-+E_xy-`f+dI{qE#CGBT%Le=SC0cshmoSxu3J5pZW?t2MW zwvJOSGrQ8ZWB-!X>bB(RQW+{w@*7f1Y}}FH)6xgs$hQ;mruhUY1M>w}yFiImeD>&C z6xWNmvVyrW_9z(t;``a~T=qrIE3>e~-`bua&--+_goe-8Y0^!jrKFC8Yo9 z8hBU|a?+WiJgGi)BhDFGj71+uiWGm0yo(qM@E#8+GmFy2$GYK(g}H*)Y6Apj;nJ;~0(Jfvv;edIaq8 z3Rwx2bqCVj7V8W$Tx{f0C5LQQm|hm(JvW!=in_{?uzQ}XSNnf#3^BBi=nVFioQ68y73N48T1%psf@Ewn|WO>?JP*@lCVxl zX{y{;yOr-OEGrK-5v5>N|4|jL~UeR!e z{fXW)0gHCVv*_kzSyJnumhElt)$FD8VYX8z_=#5N;7hq=Nq-e}(+4>%Y@z)OAMsX0 zOgTH#{k9Bi3FG8JdD9-caK!d*FS5XM*fI`Qd`Y)GtW^f7ANvq|Wi%8p(MO!=D7?B8 zgy`mbYLYofjp=dhU8!mMip&GAmkU{J721&gDVwszuj7$~9=6&I>zxI0Y=F>8Pe~nU zM75*=%|cTU6tKvpvX< z-a`v>BtWpUnmV~-X|g4g_JOFtO%V2)8Bj-sZ^C1^-A7KSb-2@-xa*ZkI}V(1tc_MY zA>P?u=)XBR9KbMwT6Z?`cu)iHJeOLcyAuCrFQo11%gLC>t)kRORP(7FkNyQ8OTFEV zDBV~|@w~+^Mcc8*NT9WX+wMmp2}fFPV{xo;mSAs5`?J^QM%kA+3bF57?^>nX_Z)X9 zp+09g>N-odxA-2N96q50Q7wc|f}Ch=x~H;t+f6|n9pD(kTH$XM`X5IVT?U4S-O4`J zIVz(ILzJ`q1nT9;7ZtvN(&WR^x~PPHgF_}RKQ2$D55z<(*!qmQtOR$neV)P{M|zGr zY<0CUc~KgU1Ug=DLeE9Cw58JbT3VlQEX~azmtL*t;8$>Lbu5H_nVdbNA8>q&iu7QN zuxmM1(SG#T&NxP?GWToUHs06vLhu0pIqA=|f^MBht2%v)hn4JjEj=z7E2GtJ4f}+H zjQ`RK?B~=;Mv4BUH%7N=6v{E2aRM!Y-+~~g)`#48a>QW!CswDIb4=AkQ{-s-{~h|2 zcMtE-YMmtvJ1z%$sWVdJXqJ2MN=Gb?7L4;`Ot~%eR8f2DMlPhjwPUZuS{aIAMlI}5 zoZ_jclCSm)j)~l4*8?{x?^>H!OrK)pN-u}E-;!Y57{c+(HeN?~dae38;~9*s;H)Eo z$NA<2lW%Mh9(YS3~CKARD!@Q4wP1&XZB==5sx&rQwvri4t#1 zV_mE8kfn?-H>YXb?cOL;E1z1j73Gz2M#W5-_NcZtT~7i>%dgU>I(v9xK|pWmSUMT) z^_fX8O#2u6j6M%i6c{x)Yh=CRwTM9IO?v1|pTbdvW9?CR!5mVFrJaaar?1>5=ZM)^ zh(PT)F4^f-xF6&=#@G*j+t0C)wM2uCmUwn_HrpeKWZ1eW3v0U5c-K!NSS^h^1W9Gg z^f2w#@i4R`kBdZi_)pSMPmXS5f6_Uz9_3`5M~ihv0X_?AI9&?CP9ufZZLCkh4Jb=kM+xXREnE&#bz*vj&^As4On8Al|&k>Y% z-U)k4za8v&Hjmm`Xsr{QPT{D}Tv{HCVM$y&g;`v%wogBTR;F+BaLR7+q#daJfRsEM zeGN;Aln0+?!&r}&%p4p%fU@{%D@r$TKv6CI>F9Qpx*yLgn-*?^R(zVz2!GC%7{}nL zh*#+x=%i=T8F%mrh&l@V&lqAeYX1y0xhMLC=-=hec?Co9~-rWU&H^$#4c)`y^_bg z9F{^fg)3r9Tp8o;A$~v=aZ`g=l{qSFV)oh4*d8-_OHhhj8Uw zWK-KtYOlS~--~j0ecaMQ{i%;j{go&uqneJAHkKXiEY3y4V;# z(;=IV*mR{$*Vwdb)4EO9+jN6XH`;WwP4BVk7Ms#ktoL42aH$u;~jnJ!#WZHhs~ir)~O@O<%U@ z8JoUh(^qZ!noZxZ>6vQ0m<=@pw^wdpmRUe|Ov zvT2V^OEw*{>4;5N+H{Rgt2V9MbiGYC*mNVhz~^#Rbdg*0qtR$?DCq?DM!NxTiuGt! zn(0ZlkPX;6{MXatY#E^(-3noQ3tv}Bdd<_2&-*wZK2nAL{_q!H|GlJ zYAj*|IzX8;u2dSy1L~AuQ<#mlUMLQ6@5?Ar1u;Nb@F%jwXna&ewPA2uU_I`vED+K% zcYwA)y^Vugutc^ps9vC01$ZZx1ZLsu%R+@Fux@e>=nN(!9r*vyu zdZaF*n%(RQ=25eIomi2)DLkzuT2WL2gdRfx!tVCdi&Y4QQK&Qj-g_Y zM(lX|rFZNv^woMx=#@eOf8UQzg;MD13SuAI-w%Jwi+{5lZm8@*Su<8fH|Ic6d91`r zK9@7Q&<#-sa|x(2NZdrhY&YZ8Awk<43=}1BM`>0jWo)K0$V@`kXEqlhAPFE}qtI7* z4FC6(>pi*39!TNT$M`@+U``Y)^}*)rqOw#%D0wj*K-#H-!{h)*xdE1{JeKbpfPA=# zI5gl|;bmJdtbu!6E4*wYaJ$sAo%h?pAzvkM8W%AWWTcXNdKg>vyEc<^Psxy_MnbU>yDqG{fJ)U?fP!hq41kp9i?3s)M?zt_7%p z1O5cTNuNxkR;TRP(EbeeQti`S7X2P9nT%3+Z(iY0-tZALafFj-1Hc|&+ z`1As?Z3fcbq>r{N*l7cYIMW6WX4JNE*@3NgTG)kqGM_W8b3vJj$jD4kKxTq{nF$Tc zOiWg0!a_0=?#cX)X}uGanTU+c1O;R!*q52mu*}3{WhN{nGvS`h=S}N;P-Y@BG7}V# znP89a1=G3^r#*}5gEP&1^5!|w;iG3 zwj(Cnc7%o6j&M)r%cgZXC^HcmnF$KWOt8oIL(}>&$d`x=UxEUB3HJD2F|8{>zC>jB z5)|M|u*dhRXspX65gEP&1^5!|`vjq3pCBgd6NH6)f^bjf z>!x)*C^HcmnF$KWOt3FAp<$Vc$;wPvNM^#bGRKjLqmaykNXslBUuFe+&+xbh3nSrY zxS;%JxRwY$!v*EoMIZVC&Dh1kcyWl*J5ND8*&TY%HYF36g0>-IrG0jThdj_@p?03$ zDTK#+$izcI-b8r3g*wEW2*)n^w2ukR*u}v(c5$GY_{_n0vX7W}Bq%!(p6o&$lAQ=g zcH0swO}sKAyMu9Lcc2;B9gNR^jfvNU`4i*w7y6*j5aZdVYT|0pHbi)~5$cd_h;U@L ztwCr;b_e6g?m#oPaWHP&?SQj=)CrVtoW~td=cBEIs8m}!aIdW$T&k@dxHrdjaH)E%ud#lw z9tW4I$ANqGI5@Zu7Q%I1Bbk85tf(r8&dNXvxu&j#3}@|jYObY-aHs7qGNqH%b)$(l zdOA6{lui!Z)5*cPeqdGIY~syXKX6d4A2{HwuQ{lcE)Lw&#lfX?ap0aV4$jrZs(6oy z@5$=opj=%Xa8?%w<@fz9Cf*Y6`^5NtU+9BlJTWO-*?PB{c&leC2bZ#y1NUs@;6nA> ziygdf^$-`TN6KW!VOtMz!9GJo*FGbqLVZR`b?Y-khIHCy;%(h@A}*wplMj%S^7L?UDLovx=g$r<=x3~`tDg}W9Gj(7H$NlNi!Jt;cuz34Ai|3+ggO*k5aG86 zq2cxrdM}0)`e1ux_*?4*_&XS+ zGGmjqKT*Do4x0F2SO;Q!9fUrp12Jgd_Wp}1y=0cqzMah!Y%H}AD=DbmJ!%8jWTbB+ zT>B_6o-y%E);1ht5X^4nm^#7p5eAjWS4p%1o! z&}aAXnrBV(Y>>ZTJpM`_;x8EAMgk7oNK1I_tR;dr5|n47=1J2$8POf3D zhu2K=wJtgk<+pQFN`!SF${XvBnD|I=tRuo3>x4Qq))C>^Cnhv#AHjI`QTmX51mns6 zw27Y%%1(qQyHJN@C&HJV(6H=6Pbuvvp=&KdAC#RKzinfJ!)+@lziqWdux$n9*{5mZ zX3#!Fc=i$MkbQ{o?L%nTK0@!=N9cq0AtqoSg1gv9N_hP@mJ(t65asF6JZ+k%gE|Pt z^G~G@=^z+i2LXq5&=Q^wS|X@}pi=R#J|hI~#lH?N75_SLFaC9Ko-Z9U@v)#U5#jlg zP=|bp2(KMtLWAuf7_S|aKGY6^@!LVb;damxUOQ-sU^@uPv(K|8el}XKd^n!_B2(~j3UONkQsGW)MWhXQ&yU=^> zEc8LyiAlAA&UKni{Jy|z0|%FC0|)Mn(+Ti}$5Pi5NO!8ktaK*Q@5;4V5y z310^(k?G$~?SVR8H1UgF>LAK*^H@rR>yQ%8oY_`=+Qg^3)In6B4k;0?gQ$>S5#G(O zqzwHhnVma=b?GB9%V5ax_gRSOx|S!ULTkoSs@qx~k=Ze;dE7LE&n7`+$1J4|j9G$k zeAh;5WS;R|2jlpz1I_rZgUQMszhvT>X7V2__7lkmR;yQ z*@ZqRJ2CE9q^=YboE;||lsis1;Ov;~pgjA$V&YeV_94Qvk5Gr~LxgW1Lc{hEde1&W zAGA+~za6b!HSwz%{tm|Jvko-l_YTIh&1)upEod7eJlhC$$TmdywjnelyKN_-_iQ8d zLE8`$@EwA?_>Poto|R6;U3`Zn938CH2+io=V0`-veOd>H-qpbYXLWE;uKzpWtPTz; z^qizr-JX-gh2k$M(&HT$?gLhKVgmLdxQl(Hgx`;)L?%{r>TqyOf9Tz(XdK|bHS35Ykryp0d zqONf@k-_?BuX(2Q?67{|99XvVi3jO$wt zIO|&u%JnS=ob@dS<>;Uu7t+DOI664cj1CUQ)xiO0b#PFw4h}f0gM$k657EN&Teplq zAJj78{vo)mFU99fd@eZF5|Q;Kr4IO#Ae?s4))8pXmz3TcYguQe9UM+>J2>EMJ2)t} z9UO4B9UPRSgIYSIgM;yWN$Jzi3y0p-!2xG=a8Rxe4mhiWg9`YPNY%xc1eY2E9bVoT z=-@nGddI}?1bvAJ&zFQc+9o7SO@L_`Vd-!J&6`aKKp|9F(hr1J3H;phCVxsk-?RaUoxlGU0J4CeHJv^Ck}d zeljM)^Ch7U`4SOMJJ{ACH0(=4@A;C@2YrbcPxcEYz7XsOM0m0bbx3w1eAx*N%P#bu z>_Q)uofy}LtZ@j=`jCTieaHc4eaJz1_PJ={i$VJk;n_#1L-rxUw-2FV`v|>fAE6K0 zhZs-xOD4V)l${7qcA*Z*PJ}Nzp<&sD-jiMEgR&D7Xj_82w5^oz=O$7jJU1aKH9puj zC)^t!99(LAaNypv#=!-2xoqOgU34KT;HOd|tP4>gT?p@{i({m zYlHPTxRlKtxMwp52RHTSD6FXK9EHf>97RfXo1+lv^^*@x{9&-45aIO`p$_#EB0~1M zV&W@ayI9?c3)xG`WZT6lv4PY9dqmT`&&DZ{vUt4!x^`1J3H;pj;gsa8?Hg z73#~Bs#{+sF4UK$Oqae)oaal|O?*Armx=IvNvK1;Pwv4aZqHIb@IUlUxQ zuW6ZZU(+(~nyalJ@7L?;Ru6HZdZbL3dWZ|ytYnr;U2H~Fz-Ce+)9zMgDdC*`(C)H4 zWR{1rbvP)u4hNiV7YF6|mW7U(<&lhUIT**c9B6QzY?+)~JJ|v&&GO1FIuI4mK}uxo zq1m!W%z?Iy8O|;oFDMuziHy8$X0T-S@2Q#Dw}q)ht)L`73cDf0Z&_ z{FOM*Ms>4X588+b&qhKWvJnx!jR+0fNa#Hq34PE;!~}eZ;4VHSCHyf~N`!rgC`Sj| z1J|47^%)%;jMEPsXr>=H7*_`eoYlcWx&6QaXZx~)^4gdx1lyPhuZ@K|)W$?O_Oaee zXvRJc#<7nB&Dh7mr22t{Z!pXLZ~YxysvkITZyxI4U=D8{y3C5Y%|itlnultsF7r?= z6{>5aS>D*SE+T_@$lOsBTiwiJ48q|Jx7E@TSUh)GxKuw9eV%|TQ>?HuHqlztAP>S^d8 zYZ(>N3W^1e=V9#RWtwJ2TB&)$G*7_T0C&`PP&Y;GpE{*V5bWyRVYYgt{ew#ws{_AT z;7%nDZgtfD*=4#6;chif8BytEK2+T)(>&F!I^sgrNtrIy5hvB1&f{ICmDX|Gl|#R-#C~+zj3f)>oa_%H}?5q(}3H)Vw$gXaa*DSZYw3iZc9|C-3ag2Zc--Two;}` zyAc;`HzK;Wo0Lk83D#6n${Q0LWJ)JHRk7q65D*OGOog8G^7afG} ziw-j5iw-8>iw-v9iw-8>iw;(N@iq0u*Win3U9GX-FwHl7T^(dvR|nzi>L5o)_@4Ab z`E|K0kpGtF~dMI$mOnw0A1T12K?%Zg06=UNUfNeVtA^`M8`CK(WSnn~1@y2d)m6v88?ynd4rvAgJ zS`KTi2@BjEEte~dsYD9gkDF)8<&3OSY8@+1o_*s+VC~nnoAI?o%PZ9nJ5W})25%E5 zxuP8;KMT<6#rw}on=C|ZU-OtH8yqnMG_%`s!EN>J0EX(`C zL5$a#TVlj;&FAE0-b#%7QJU}9x2OX;z<0GPkW!!Ld)03RE7OYjs&%p={GUJ^l!o!g@}MH< zx8OZh{I7$K`aecFR+@S*JG)N{R_O#{U)OIXD*Uj zaM=mowy%rC>-Z}7QOWAnY%8ICS!V_Pgqf1D!7GeQa2YNuAHG2a0xA(=Dy#Utj}#2p z3RJ@X(Fo}_h;A#{n!FKzto@SwPOdUQ|3g(<%lur%R{O&HF`HJBSLBbafJr|GO`E@6 zD6@OQ0a&gK|A1R=P?y=T!gAv`D==lkYwC05Doozmz!%u#8sWNqFyaf}rSYmz9L@6W zDlCEYcSZm}v*N2eB6agSIZQ%ei|>L{71=!ap)R~wemg#{1aZD&zr&;b;5)FAXepoR z5mvY313utg9^ni6@ht&UH-iQ@NcfGGR~ z3BCuEq}6;M0enjd1~eH;z_085FcR3X()@uKuK7bG z1tUq1CcT=VXAoD^q@+o|CIgxbYBHqBFcO4)mFDZnU}S(q!l5kieAP_zeuEl9k`lgc zKs!OF3aSETr+EIDsbG++JT{DL*$nsNDqU9Y@kNOUAC#bB(I$iFSkj;ICYTEHc#70u zQhD-5`GFC9FGe9NkWFx;D6$|5VZ1>ns-l50xOAAomwuGT7gG9B3kEp+LmNSp=gMUa zP|fGmT{*(SdjaJ@^7b%#Me~p38!Gd;D#s??nd$zhK<%e%RWL!WRvi{;TJw;=G~cBo zSJ%J-qfrgsh~{{&RyED{;r-Ij-y66aU+dZ||2bVb!pqaVG<)#a!-r!ktz*1A%gYH~ zUf|^@o%m)Gc4ts`tmB%A=W-qL$ybn^AIBA-r>ya%!@)2}0PRnS@a&`#?tzZO*E!b7fB zhA~X*Yz+fbjf)TjqrRrHYzoVBdT(0iwEQ_ObPlwf;E~p}-cj5;ihHMqu?5ic3HrRE z&nx;o>y;r0eNjEAs$UPPN}sRgs>1Ywmb##&F4VNEUz7l^bt&O}NvSR=)g?=HS)rE| zdf7rhROp8a{m??MDD;X#uUP0+gDbmr1!`u&5)KD;zvv1kxKe(Li(&U#4))Nhc_*2u@Nn{Qt#H- zM1dGiNvXqVT-UqxV%vB1b|%K5%w3^2p=n|Om&WP@_tpoKS}u$0-L z(w@K#ocDxC3*-rrQ*Sp~Uye5_i;cYTUF(IZK9m-1rO2fUhNz4Hml<{EwoLkx2as)61ns#6z^aV zhxh*3GCP!NN22_$MC_9)_DK;NP~Mw(msYV$r3YATuuHk%UM;7@d(@Zq*sAvESa3=i zpAyD;mNA&(ka{sj6 zKb_n+wOCV)cTBOz66~{j|7>!9Tz%S_i3+?*>QS$|*KB;w`)Mh=I z5S>!&DJ^>{0l%o!FDmx5O_b<#LiCc}ztp~0vX>S7asqx?Tjq>y8C|xC&m=wi6(xTq zA%8`=ysC*#tYc2BMVr@@*;|&`TT1noihEW&<=Fx8I*j5{?nQBhbI6D* z5Q@XK>IxX9^;VPfHqmZ-TFal7^5-k9(^8&LoCekUFKU5{%FT|v@g-I85)>A>?ARM$ zR_e=&zMN=yS=}4=+QqLa*)=7*hW;oLAah*UVZcoQFUlD3k_!4#0_8o+%IE96=N^!_`HnqnY;)Wb1nBs@#P-Tdby-`IwUXa5WBomfop7{lsdL9 z>qxs?SDX&9%j=U$*DH8~7;)JSsmmKw1Ppw9_G4>7sdRi?23W?1WgQ=Rj{wCqKfwHA zx-a6in_tsITGnV7pO`~b%y|_*F@}i%zHnDr-l51^FFpt-5gooqhR@hN1R{LROhZ8P zr~(+QW14|NGLhx9Oy@eyAM^8r_Upde+@{;{UNO3y?i7_Qu-ixU4C&T!37qaFq{B8aOOzmCsCm?2w zDk&+!5T60VX9V|hrbT%XV=wO|WWPZ6a|#12ulxHjVS)Ncs)$kT{26M_bFz19-b{-w zX8GVM_nz}38e^uXug1@fAttBqFVCB4>?b8fKw)p%^k%vjO<{%+&T)3b_!!M%ntyJZ zKV`@)SpbWO_K8H)kBX=w?`V2RiMgZ944UuS(nvv_fLmajOd(Ygfd@Fb+~NidHn9Ad|@`GI?Q= zljRXK3Tcp+IWF^9VbfVIZ?KxynJx=JC$L~>GdaxEINQzTdVYpKJ#Qi2N0qr+ekh0T zAb;=~xxrk-83@+iqG$l$oV3~e7b9w2Y2DX+F~3<&;qUGL z^_HwYR?h&!7MLwg3GG|KQ18g~Io~TD|3w z+yCRk|DjhFqPFLvFFi7OurYObrZH7tnyWwFs4p}Q&3zMh)3f!@Y}&l3Uf;dgsQ=xG z#p%hh!%GJnvrE&H6HC)`vm5RN$>LIDVhUe^#(0JHmsVKDCG+Sxl(Tt9^AyZgZ^QrE3F3o z0UZ$FX^>$xsH}@Z_%f%iNR4xJ%42Z}xBP-+&j2pC!G3SW?k?)o*_l9t##D6b{5eqT z1e&wzl4kqGGqIXh!9=`GFjVB1M)9S@3f8PxE9UnQtcFh^V#Q=y7H3+AfVQ=ldj}vx z8ETb>iUm-xFec@F#RBK%7#*i;%ZD$#eNtO7;}<`Fw)JGUNs_*ju*LX0JF7I|Xn> z&|)oacZbv3qAnfNY+whP{gyAagILeg>S2pgTSj;iT&cgMmtfV7^7 zc?x&j%5@whE0cO$;ZPpmWxc)KAi$|GE|D-2>D%8`mC^M+a9^R`(ncV7+0eyaW}G6O zup*s+NNH0sYzdeO-_{gAWdXDZzo%NF4VXdgVhnhk+;cg0Jt`Qe!>h;*pIc2VL%4uM zj2CbRVp7;La1;fMTlS+7{7m_?TT%EIP$xd^tR~{8TC3$lT1w&oq zct+!+v7Pdkr|8kPp*biTOCt|SK~-{ml)3<%IH9OY#;P?XJP9OHA!17ZEzy3YRRXTE zBP>3;DiK6&CxzBU=qSo>U34p@1}Ag{bixEGmB1shBfuWQKvODUW|%d#^(Yi`CAhr3 zH{+iymTVtoPi}*iwbWB)jSrzsBtHEPzO5@6Y}-5v$J#9;%A=MiW^D96DCiEQ)L=3aRjx;i?9o5>B}_Fi_iilpm1zBeC%2qi(QZaAzc@3 zE5afPQ8I=ga!y8`POnZ1THYNy!mlASyy3oF2{k642Zq78SP!V#-CnwvJL^NcZQnDy zVUlq!xq$)QL%s_QPfNH$CX8oWEz$oa>F!v%g)*(@pz&}WYufK&mjbKU?^mI0 z>v?`|Snhzp0|nXlpei1PNKpxjl|Hq(AhpsBQGmO)>wtfsL7pY$SVm|SpXnt-Xw?x9 zeP(wN`yxc}Nm4?*gUuz#*#KXDN0=?Rt1rSs4nZ>v!kJ33Sg3Mf{?%Oc@NYcaSe&1m zU2Hr&@l^fRFVtrb&&<@nSbyXwVvR$ab~TPHZMtuEa&BsR_Q0myyYAnz>C26!N0t_F zyTK`WXZ`b1a^vhbo{6Hb=AvH#-)|glEH3?}c}l4?zg~Vz*amywE-{|tA8NM0h;CxL z58ArCqG)GBh;Mj5z@bAAo2lt>>TE|Y`tpsVu#JeyW+x75jJB;Y(^zVZ%}h@$T9tNA zEC9LGSXhjrMlRa_QOph_qC+TGN120ji2DvsEY+7Lo@^}EC+hbfo}H}EJyE}LEq#bx zj+mtZjtS5PZ>WDD7j65fdL1Qp9$xCE!Q;8;v5(^PaWuF=6(xwzb9BuitAM=i@+-OM z{*S8IQDN87`Nn-mrWcn&&2TUmO@0)wkE6uHjY&k~3r8PWnpip? ze@T~;rs%56fn4b(@PG{QHpTW&kF536=Q2&MwDw@Ax zny4}v-p8b?%tN?@E?Ia=CO#3uoecg z?{kfh%K`6UN@ot2Fs;SRLkhefNW|3~qpWgzCvxt;-4rS(A)Dk2oX^Rim4 z-d4mDvmIRFAOxN&QdUC`$tI@&B&>Rrbw0|a$4iJP4l|T!7f<3=KKc<%wB85BGuUIa z0o55%>QDOX3=bFq;5m;FNJ9axc8voL50LP|jIWcQ;plv(O=hv{BAo>PxEx^_>Ca8; z$ENjX)e`3S62LXz`&)=Q7~=U62Lrt3d-Ns*99;Eny^njuR9bE8{a!>It@mLTQK1ZJ zlTfkJ`spxcjyOPKjU;i>D?^x9@Byt)X>g47d_~-g)-rLwEHcD7t~iw|aRqB`SncFI z+n(>?vet8)8;p@34ixc;F1U|=e%RHNM;c2XwV=W|F9gFvfGD^|gC`s-#o;Bcx51Jq!3deT(i&N+iB};Y z*5wYur90!HImX$76d2Q{XUR{F6cFSfkYgjI%h`GR!Mx!qjM_Bp2NguI=%`O~EAzWKXO`v5v=D^&MqrEg? zl*h6Z+YHNql5KvA;~B&f_?lwL;)j_wztu(|K5q9$$=Lu}oPa)q7A@IE&yUEO0N3%v zG+6j>0Jbr(^bkQRHimyvttJ+0H=KAae^;T@Xe7(TB7kvPB10{qycRT!@{z@2%?_JU zcd|vK4{yh6nQ2}&``2Tx+`?jETJOwlGWO#rTNL536q)$;nqBJRK{t&3wQ8qK2?GV) zyk`I%0B708a6*lXeml%IK1;BGh^{58i}@NBP(u^b3XI53}Z06yV>T_bvbNAwTZpiv5c68-nrU6Lg(PbWU9*JJ-?F z6F|1?J@`Vc&2BOA7Uc~-TP={;g!k4IZ(#3V&K1>|dKR@tXb{ItzBP298`IVZQ!V}OVGdBB*iC?kVS55q?&Ax^=Rom;ClR-9n-o)o^_5#lP*z85T|IB7DnfQ{;UN-S%oBa?kXR_HVc;}MMUN!Mm zo4v-9IohwUoA|nB<(&~W+k@9S*eu_^V6#JJdB|q@J_DQO8wqTdzv8!9{?OiL>-bH% z&GLuRHp?Fx+bn;y+mEgH2e9@VanA-Z9byr#q+*_3U5OwdW*`%Pp~u8yn5P*W5I^(9 zeZN_Gci{5~MNNEPC4Qh>!6B6Rp-Q})=Q$7v$M=l}3Jx)D1UrOR@k6M^Wr`yYqxiW8 z)^U>W3M1JXWn@ret%gVT$;nG*)Us%oR6ec^$$ra>LFI&d%^W zdL{nGNaZn3{o;0vU}0rFL76P z1c&gG41b4%vn1e5emt%soH_fR2AM?sKR^JAQh78R*IP!$eYgbx!w%tJ>I4JYrTJWiWS+GEpRoA%kXXw#BS`)xX4(?OdK z*>spGT!{4|2VE;@C8+}EoQQ(`a4M(y!+|!pRxs!=` zIe%hgB)0OtTW zoq->KkQisl8O)#SheYb*c2`RLJ-!R+eYK6+yO9SRhG2XpKy zCM%s^CvX9&`Lt`+bnraEqn@SDd9| z=X)KF(&~pY-$gT<_y>QxI7H2GPtuZ<<^})2Ab#DJWr6-WWPTf~S3krGY%bbW?)}=t z%;831ZniP%0{Xsjcy8hFp)}FN%uK~4>RCKGJ84`~Gc)&8TCIh~R9daM`E0StnYqQr z)GAlD()27Oo1K_RL$L`d(6uh@Py*d|V5yOo@rk*G$wpe9u?M%Ua7*XE`f$1o4A3}| z)@yR1fqjIuC{vB4iD{hPN-MVnS!yo(5$s|v9NotQT>GAAEKMG)y4V$potT|c6Ii<1+xX_HLOA5N1zH8H)E=JWW>+~kvKM>#aT zxQNZ2G;n@y{_xDiLfU*2Gfzz%T})T85AL3(k}4L{M#e_z#MH#nL|T~Hxv9qDCtO1e zFU%cYf-w7*CLW(@tZ`9;hbHLc`&cL~E4KF*ah`6qOFb|-cW55lynv_Wotm3myve2P ze}X$)6fW(IPfX9Sy2%L~?@NpQ1iIV7wB-*pmeLAOPie^vlr9PN()?+_mRvfBemJ#ner|3iU3|8&^wiwKlWAKlElkYf zK*K`D{SPiJ&8JJx&m2C06P0P;jnY8aI6oAtJR2pYS;QjmO0Yd|Y6!j^~VV z61mtrSmklW`p^=5GE(e#_AONdXZM?r>TX=YD=tD3uBl z7|MBnuqq)KU*4H7RpoRJ&_kRRRN_BF06WrOF5=g%KY>yE`_Vr5tx}%hCnh=tmu%R* z8IZQDmWKxrnU)H@#X_OPvqPw`JX-AI4?>{&28Z92hM1BkCR+#>pBvTODCGhy&tq%;kAzpVsUO3zaHxM4$IWCHFW4 zC#B?`_9lZFLfcerC}vhXi3Be28t$xdOPhNolHs0Pg24%S#WX*-jZLFC&`AjRK~gHA zfly@ZRFnv!25KYjw9MLot}HR1!)&Q$r*vi9E%&x>IU_1pmizhJ38o{-{u+&k(~Q_@ zQv-GCp~AfD2#MJ-bWg(s+abZ68xkMcY(0sL!W>asGO zAx-n$+qqE$B7ndIa|_NJzJr_=P)G^8fS5|;IFd8h`~W!_MBdKx#K5~U;9TMre9*>+ zFqPr#BR_&cZb2JU7UYW#iX02>rr0@7c7OGscx|)VArx`I(8M4}x-p zW$JBA{T`fy#L-7Q6D#-4AiSNP)L?GYgN>yqLO^R$;QD7a-+fOMeK8k(J_RRv{Vp6j zoSvMXn5kpxR-b8nvoTX|xJ>JlGt-C(u@Rb!hEwISFqn&q593(m#9~8!k%R8^*-dvx z5gs7?X@7*Z49vn@BZ%O-iOA%eR0c=o;+0>0_$k<^Lud$wXruP_bx6>?oA0u z1^3Q9{`I|9MjyLre(G^n{@3hJb(XJB&_BP-d_B2Kr<)zR4rbq%<`%Zi%#2S=&qjw9 zClTB?HcidU2*J;82QR*E;cx!@wX^`9agcjW6gAW0%YcEmdiZeCZO8vT&0@5qKd+Ob zO9hM>(bu9!qJ6mD7d?#J1JPHb2XX%ZuJHp(z>k1r_ob-!=<*!+_Z`)f* zw&9us*NJEWe5RwBr~#g{(G$^};MYs3UBFHNx(NJ4v;?|2-07b)J?~(^$U&whP)!4V zAi(L2&}@d@`uCpbaoQj{5&aU%ehK^z;co+_mrzRtEm_l|)HR8;ArekT2k|zP2XVKA z&T$w1&q31ZXcGS?P@<0ibJ0_hHllBWjxb)syy_@9gR)vL_1TK0$3&ial$wo>qP_`{ zjri_zMbVDPplo8rZQ!~H{PQB)EZJ-rtQMSxHY(Omz!1{Rl+`tC)=rd^5 zyCeE*6zvkZzG}-GPp|1&jk^uo}JW9Nh}3Yt1}@3CW*LmP93 zLMtu|9Sf!l4w&;NggNB?7+EUX#3^xZP&R1RA9$`b^I&N+50jqtpC{rA7=|8x!fR{IzJU;F=` zZu8WIi;9nqiHPYDnV1wCl^7G55Y@FrTuf3#VnWoZb4vzuWBMk=#3jbY$0bH2_3IUL z@@>he#84@pDb+c)M@(X=sHzdY6Jrt*Bf9jAOt?Mb@1~KMln@)&LYv6zF|KHhe z;mY-2?VO`xdIddXVnol#z6mi&3H@UFo|qNJeL!@4&&b%gh=iELUXnU({}kO%j~yG8 z+-0A|G*2WG9hWv>BqXJt8^(11a4k$(H^Z3T$;vxfw6hX@ zulV>L5s7iJojW_cI+-||NnB72J=h!a2^$~ja;N6K$`;_@%O#0W|Mq;YOew}%C5;~>Z zb$-$(CgE(Pc(U>$x+W#{I{7w?r8>E~2gmwJu{~o_=7cekKkNWc)L%kEd^k6?Uz1Gk z=X*saI5|rSw(3ri5 z%FO7P#HfVWUP)nX;P_67@jW!DLk5RdF^MsKW9`o)d&EYDvvPk;CFMmJ8!jcvQ%ewx zhn$T>diIJ*Ffd^wKO3>1XoM~?Nu6V3dPMh(?A6O^eilhTg|qIxI9CiM$?+1RMa-br2K6Jl>q zJ`{*bh>3Q35*yj$H!ATj4eaT^#d0Frh{RYcLQJ>B__%*u3Cl}ZE`92ZZ@gR(G#l|G`jE@Uv?!*`!pJe>^40Cy6-yRd! zyJup_KR6-%OKoy;DD|HXN&nq=|M@WV-;Mb%4n6t7jG z`b$y&dO-Qthmy`Hoj);r^q1m4rDOZOA)_;nF> zm6MI}Pse%wQoJc^WMcA8_K(MQ{!+xhedhW*=M{f1=9DDPaBE75=FgmC|GkX<(RuaX zi}BB%OP^8f|Lpwvj3WPM=gemm`R|`6pHZ}bcy9ccV*YhsfBMkliKC2E!;axPO#0m< zJG&euF6DczR0;pXWj24QgsJ-6Q@X|Agg-dPk4iq{|8=P|+=hQG+;1IupXiByd-V7( z73$YyPH(n9Ib!^m5=+(P|4YV9Ql)pwvF<+`ApX0BIwg@mGZKA<33ZK(i|!E&@1IEc z#QVs^esNJ}xcdEL)%{Ll|EhF?^)Y;DDPF4Y>rPbPDKk$UzVGUSk!f7O)-~51JGN+f zwWaSa9)F%R4a+wamX=Ow;W*{-r%ss}|1)wXbi@F5?rEi5FRn}mB*UMu0<1w)}& zVNi#`&vS0~6OLxWD@AsVFrB{#>%dIqxJ>w-$}1)OQNHU6m#g>c!p;g4EnFZHO_uyq zkmkY|@mwp+tK5;oyXEhCVLFki;?QgfcNBi2J*o(=vK|x{DrWLJS6zIH7_MD`jup;vGt~~aEipb2oG5aatpsw4-JH``CNTr z5AEh<=yv&1G}a>&-v)QQ0QYm;Zr{2bH3n9R@2{d~;<4)P6$ILxF9^sr0e`yx)+OD_M&<(cAOMfnZkg(P+AME4V*V2gf_3tL&Q2X1wxS2y!rR}TA9_Cs3)#-Cj7P15 z`FWHv4AVG|25oHJ?r6IYmJK}Ub#8(%T6TegOLr17~LKJ%!*Pq|2X z;tRHkpdMQJdtcjBY0HKzSJ`rv&F`q6E$(mCy-q`r=2440sk5FVUqQVDX*?(!Fm{2;r%-Kx@gMreaEn)=N$hHVsPR4 zzhDa1!+Fx5Pq6=6$RZZAgcn%KGM4iqFYz)fc!gJajn{bt%@9)Ep`e+)O+I$93MC&) zSdEg8u{3M)zT--v-DC3pJ~;NVYf9cnStXK>fierNuF3m1Sq*Jfr`y=h4tBDO-Rxm6 z``FLd9N-||aEQZ%tNrIcRpic}>!vNc>CyYoU(n;=otGrl%y1;DMMMxQJxA^q!N{>LRG2}9IITz zwOmIHuBRros7)Pi;700FkNVui%`~7PjcCj*G@&WYXif`S(u&r!p)C=#qdgtyNF<$z zBAOUF(}k|Y(v9x)peJ#}(~Db4Adw_`(}!@i|BM1FwzPZs@gw8YMT6$5mWSKFj5& z00k*TVY<)kNb-YOHh*Fc)T>h@o{iY5}ePJrvleglUmfK4mWTkb*V>vZsKNo z(35z2aSsh?L}P+u;3kBt{V$zf`<%t==T4v7?25Jz)EUv@ZgJnseLTnWjA1O}7|#SI zGKtAdVJg#@&J5P^DMC?-QJfN#q!gtoLs`mEo(fc?62ZPWTC9jzvzW~s<}#1@EMOsvSj-Z_ z)&6N8yz7ofYW&o)YN=dfidLF)=p%7|%qM)xXMD~Ve91~yv6?lkWgYAJiVbXJ6Pww> zR<^O79qeQmyV=8D_OYL@Ilw`_;Sh)UmhU*iQNHH~e&i>9<`<3;I@k6}a2$R<7jPjL zaWR(=jFVl)<)q~bt|T2-aW(15Kt?i=nJi=_8`;T0PI8f(Jme)G!8u(43Q~yRT%!m@ zDMoQhP?Ayv=Qm|2OF7C@fr?ZjIM1j;Rl?Q&|EcHyuiG&O``+MOIXEW?>he*7I{2gW z<6v7aeBSYG{%xNR&aZ-bE4&U4(u47#pJ;Z4_C5dj@j;KQ$Io*!n?J?!!DoUrgU_6P zE}UIl!Fk|=m)XwK96vWZTj#^Ux!~`e6Njt)myNq||H^^WN7syddhU__4?Vn7*~VOO zy!;<4|7FVfd*{T#c~{CgagBo3U-cR6bAywoJJnOrR)6NaIN0w-TRuo{l+Oh17Hs3C z362qh^WorpIcS$)AD5b2zmK_GzbafMkJ0ko%jYX=@5aKQ zjVqI#j@}3RgJ2&LeEw#F_H8Atl=I?dxlW!J2gj$uIdX7b9DF8N*8=M~U?P*4%oL_Fjp@u_CbO8$9Og2Q`7B@|i&)GO zUSKK9Sk8;Q#LKMU6~fj2r=S0?68CD>u$FbK=PNd_kxgu73*i{c_*OjMafG9M&ky{_ zPyEa;93vQvIgd1)&jnn_MO@4!T*_r!PFk+uO44x^R}(}vlQTV6oh6Rh{MPx;mFC;! z{KL3VU-SBr5krf~-z#Mi+6^UtcadF~gPiDULb=I9UaC@!aJB#G=l{2fJC1v~kNbIm z2YHBxd4xxKjK_I`CwYped4~QBU?77S%n+VsC?grgX#UE1=3L9qV?GO5$})m}_(fjg zWmfPCuksqN^9FD77H{(o@A4k+^8p|75y8IY6F%iX^4v8{-~XI`{-5@o-yR!DZ+-?c zl8MY@AuHJk_LVuvNiK4ehrHw?KLsdAAqrE3q7~U?P*4%oL_Fjp@u_CbO8$ z9Og2Q`7B@|i&)GOUSKK9Sk8;Q#LKMU6<*~vUgr(o|rna*w5D-;2_^{h{Jr#cN`&H z?SK0D|9{gta5cxl!S`*~a4pwSgX^hDEoxJT8@Q3W)T2H(aWf5QNFy3^3r%QBGn&(a zmb9WZZD>mb?PyO2Iuc1IqKGDj&UB$Gv2>$5J?Kds@$}+W5=bP8-t^%%`qGbZwST=& zYfYLwqe|?j4=?+q{)&TF^cVL41~Q1j4B=UZGK}GjU?jo$+Gw8RdB!l7ag1jI6Pd(h zrZAOhOlJl&nZ<18Fqe7EX8{XY#A2540!vxOa$e*mUSu#rt{W(!-{#&&kFlU?j)4}00ie!k`a z2l<9W9OhfT;|NFjJ_y6K|L;*_afY(5e?IoYZN0Di`r5dHS31{C$5mWSdNPoaOk^et zS;@0trU*qTMsZ3|l2VkW3}q=tc`8tmN>ru_RjEdBZhj5d zave3eo|@F6Hg&jx8>ve@>T?q}(}0FFqA|D7gr+p3IW1^OD_YZrwnWg5_H>{lk#r)8 zXkzG07rGKlH@ee zEMhTBc!8xXV>vJK5-+oYS9q1zc%3(Rlec)AcX*fgc%KjWkdOG7PxzG2_?$2Jl9jAt zHEUSQI@a?Q8`#JuHnWATY-2k+*vT$-vxmLxV?SSWfP;L)ArA8`-*JSad>@2i+Wzlo z`sRwKYh73G@T_y!q`mz9h^vf$T}^s2kdaJeCJR}~Ms{+LlU(E`4|&N)ehN^KLKLP5 z!F7?vC{77VQi{@)p)BPHuJ@@xMJf@D0al?Z)u_%jT+4OT;CgCOi`vxT25zJ-^{CHH z+)M)+(uiOj@D`fTl;B#M=Cq(Ct!Paf+7dxK+S7rKMAC^UqKTn1UFb?I-RMpadJ;!G z!Fc4YB#=lFz3Ibk^rauSa|hvS{{hcjlX+XE__!}u6!#zoGlXXu$}omA zf{~13G|%xoV;IXg#xsG5Oky%qn94M!GlQATVm5P_%RJ_@fQ2k#F-v%Xr7UAPFY*#E zvw~N6mDhNkH+Yk`c$;^4m-l#|5BQLe_?S=ll+XB_FZhy`tYS55Sj#%r^A#J|$R;+k zg{^F3J3H9PE_Snrz3gK@Uvq$ie8V9Q^DW6dL6K9p%`|2?1H zcuRqY^7OgNIQG>9W8xXeNG39qg{)*F7%R^~PI8f(Jme)G`6)m_3Q?FM6r~u&DM3j} z5qx)0hO(5SJQb)&C4%w!DpaK!)wzaixsDoKPfcnOjK|mE25uzy9;F`jxrv);KtmeQ zm|JK98CY(33dg>BX%ikVq1} z>BDXGr60F*2jOb}X&EaXsdjYb#@AZiRPeoxIUgD*?m-M@2+uN z@Fs8ZHt+B*@9{n#@F5@ZF`w`$F~76<6rwOiC`vJkQ-a{PA*Coy8OlHNAm8eV= zs#1;WT*I|oM-8s0Cbg(d9d6)8>QayT+{Dc^pdpQD%q=vbDZzEi&1pePTG5&|v?YRe zw5J0diKG)z1m7#h(3vj8(v@y>rw2WWBc5K|N&<-_(VITpMqm1IJ9ls=cX2o2YX8eG z85GL4ykOzplZPyObkgc#L&W_oLm9?!Mlh05jOIC>XAEN*$9N_%kx5Ku3R9WJbY?J< zS-EM^HWu#{yi=S5!PWmfPCuksqN^9FD77H{(o@A4k+^8p|75g+pj zpYj=>^95hBl2xo`4QpA)dcI-<8`;EWwy>3LY-a~M*~M=5u$O)8=W7mdkZ(A|VZP-% zj&PLk`GFt#iJ$p}aJB!-lMh!NaP76<6rwOiC`vJkQ-YF|qBLbFOF4q?*DFwwN>ru_RjEdGuHjm)qXySglUmfK z4mWTkb*V>vZsKMd(2zzn<`$aJlx8%i1ubbsYueD32-?w}4t%B`{+z$thyU!ezi^C@ zHa(9toX-VZ$VFVtC0xp7Tu!*!zrnPK=t~}1x9Ht8?TeKjQgvm1aTlN%j})7W>o+W++N-~WcO z?;o_)kNm{X{K7Fp#>LLzT+Sm6=W_uUauFAE372vimy?z&xRP{S#nq%I0~yIgX0ni# zY-A?~ImtzC@{pH&aJB#G|!^2*vmfl^EC%J$Tu9~FyHbW zM>xv&{J@X=#LxV~F+#@0&La)ya{(7}5f^g_mvR}Gla?#El5||f)ubl_8OcOuvXGT* zWG4qX$whARke7VqrvL>hL}7|hlwuU81SKg&Y06NRa+Ie66{$pJs!)|`R3}{RfBN`u zQ*k$=IW1^OD_YZrwnWg5_H>{lk#r)8XkzG07rGKlH@eeC9jzvzW~s<}#1@EMOsvSj-Y$U@6O3PPp3t^zq-% z#Qiy6@Fgo*#cI~DmUXP>D>kr^O>AZhTiM2TcCeFO>}C&p*~fmq<^TuzhC>|YTfXB6 zNBN!~_>rIZnO`_Y$obPboXdHn;e0OOLN4NBF5yxx<8sn+1y_=etGJrg4bR?2aL=jC4o#{eXV(CVAdeD5D)VRkMbCg^8`=w6i@RE{TaYO1~Hf+Jj+mqF`N-J zu(~}j9K%?~F`fxbWD=8^!c?X)of*tz7PFbdT;?&K1uSF{i&?@8EM*zXd6AcRnQ*oL z>Epj&ihCuiSj`&NvX1q9#RfLAiOpKXbofPoBRFhh8jp$ua}a>$Rs8+g{e$q zIy0EbEM_x@xy)le3s}e^7PEvGSjsY%^CBR<^N&?d)V1yV=8D_OYL@Ilw`_;Sh)UmhU*iQNHH~e&i>9<`<3;GVXc~=W-rt zIG+o+kc+sOOSqKFxSX_H!Ih-rDy}9y|BYkb;cEX*zhrD$I7^H4^Il)yDej49(*LtD z?~dv#l1@YsO$?psLRVtxMt6G9lQ`n(#jPZeND{s2!)^4XAGdP{cXAhZa}W1&ANTVB z5AqNX^9Yaf7?1M=Px2H`^9=nNz(58um?1pNP=+y_5sYLMqj`?!8N*n{F`fxbWD=8^ z!c?X)of*tz7PFbdT;?&K1uSF{i&?@8EM*zXd6AcRnH9W3xZ3}!wq1TcROzBDA9sFy z^P7c!J~++~0LL?diA-WLQ<%y$rZa00k*TVTw?cViczYB`HN|%21Yal&1m}sYGR}P?c&_=Nhi%I%;q| zHK|2y>Tm-$QkQzv=O%8Z0S#$HV{V}dO=(7RTF{bKw5APhiJ%?r=|D$&TaKVRMR{+H6#t-gHxz2d%)2Y8T&c$i0cl*f3SCwP*lc$#PE&j1E8 zh`|iuS%xx<;f!D;qZrL|JkJ=$GLG>~U?P*4%oL_Fjp@u_CbO8$9Og2Q`7B@|i&)GO zUSKK9Sk8;Q#LKMU6<*~vUgr(oTwNFfSSgrXFq zI3*}aaIeYIl%Xu;C{G0{Qi;k`p(@p=&NW=ib=2T`YEp~Z)Zqqhq%QTS&rRG+0~*qZ z;C^$r(1fNmqd6^TNh?~@hPFh|j`nn*Baw6>ifCf!Oc%NmOEYOS7{eLCNJcT5 z=XjnmjAb0-nZQIQF_|e$Wg63&!Axc`n>oy79`jkiLKd-@CA`2=ma&`{d5M=R<^O7 z9qeQmyV*my+W*bEPrTo?@2<-0TfF+fibrb>IM^$tANeUjK?+frA{3<<#VJ8aN>Q3Jl%*Wy zsX#?4QJE@Kr5e?_hHJTw8eC6JYEhdy+`x_0r5^RUiJNIaLmJVTTWCU4n$esVw4@cS zX+v8gXh(ZG(2+~U?P*4%oL_Fjp@u_ zCbO8$9Og2Q`7B@|i&)Gumh&Pn@iHrTg;#lv*Lj0Cd5gDshj)38_xXSi`G}ACgira5 z&-sEcS;;C^vySzA#RfLAiOpP)TRzMa3gi8M}2PM zW*X3tMg;e;zJ(?K}%ZEnl`j0f_Aj0109K^6H!DHLub0sl~}sbogVZgj(B=; zD+wf$M7Y|2z-JS_-tzde3%`G0_WnlawCwzZxS!-Hp5__)Gk}2%VlYE^mZ1z|I3pOz zC`R)f&ohRxjAJ|#n8+k1Gli*4V>&aK$t-3whq=sSJ_}gLA{MiR7g)+Nmh&Pn@iHrT zg;#lv*Lj0Cd5gDshj)38_xXSi`G}ACgira5&-sEcS;;C^vxc>-V?AH7fsJfpGh5io zHny{ao$O*ad)Ui9_VYCdILJ2~;xOTA|4%+SXJ_f!OD^8?O5F#BJydYRrD<*ZTuxf9 z;7ZbQ6<3p<3}hq|naM&{vXPw}Tm-$QkQzv=O%*tNH?G%jcCj*G@&WYXif`S z(u&r!p)C=#qdgtyNF<$zBAOUF(}k|Y(v9x)peJ#}(~Db4Adw`()&3P0y;|w~t7mWh zC{N3F(V=FEPl)?Tp5keqp+5r{$RGwYgl8GbForXNk&I$A&+$BC7|S@uGl7XrVlq>h z$~2}kgPF`_9`jkiLKd-@CA`2=ma&`{d5M=R<^O79qeQmyV=8D_OYL@Ilw`_;Sh)U zmhU)1xY~bfwx`~1o4>|O=Tv#C@wE}x)JW&Pc)>Fut|mPh$VetKlZC8gBRe_BNiK4e zhrHw?KLsdAAqrE3q7hfil%qTqs7NI$QTm-$ zQkQzv=O%8Z0S#$HV{V}dO$qJ~*qj!$q!q1cLt7$fM|(QZkw`ibMGT$kLRVtxMt6G9 zlQ`n(#jPZeND{s2!)^4XAGdP{cM`7l-<;)|&ac&JQoK&n+pns!Yv8~^;vUQphBJbZ zjAAs;@jPP~%Q(g}fr(6FGEEMhTBc!8xXV>vJK5-+oY zS9q1zc%3(Rlec)AcX*fgc%KjWkdOG7PxzG2_?$2Jl9jAtHEUSQI@a?Q8`#JuHnWAT zY-2k+*vT$-vxmLxV?SSWfP;L)ArA8`-*JSae9sU3$WQ#tFB~IW?f=TRd&XUs;fm|8 z9REY5Lmy4F`or2WD$#5!V4^A887k@FSCMIc$L?9oi})sw|JX(c$fEhpAYzu zkNB8R_>|B1oG>(8$u4%YhrR4$KVNfzgM7mw z4)ZPFafG9M&ky{_PyEa;93!});5me={V!fpVbyE<#?GA`+vH%w3rp6_BJQkYBRe_B zNiK4ehrHw?KLsdAAqrE3q7U0GU5jLe6&1pePTG5&|v?YSiEq{&sZME~dJ&n9> zOb4$!($eclVJGhM`hKFkjwXiAbfGJ;bfY^DSnff3c-@mY;_1b$B#=lFz3Ibk^rau+ zYX93ZG<;%b+U0{=_THRfWWs0Pz3zM3H+Yk`c$;^4m-l#|5BQLe_?S=ll+XB_FZhy` ztYS55Sj#%r^A#J|$R;+kg{^F3J3H9PE_Snrz3gK@Uvq$id_(YTvBP}JcN`&jhSK-^ zz>oaI&-}tMLcU8ohjTfPG@Q=`T*yUS%q3jPWn4~LuHZ`2aTQmSp1wSwjUMDKuOAXV z%>7;;W{~l_!3<#uFR+v~tmQiA_p==1&t?uk@iV_r#lAl}jQjtHXYTA;X2t{K1`T-U zfxJC$zGIkt4rc`CGm=q^<~g2c3}YF`cqTBBNla!6Q<=teW-yak6z6}_nb$zLw*Pr$ z7S(<{W5uGem39rB)2dW(3)TNk{{=M=uJ+IKMxLS9J$E#sS^cM9di8_57p-z_(Q4MP zmUXP>D>kr^O>AZhBVCI-iqSkr%C*r+5grvB>lx*@CqJAxA~CjSuO2bo66527XQ@V2 zjcD%gi4k3TMkd_u!S&HG5vM%bxI|ox7!sl)>hy?A^n~NYn8<{vt|c3q+w_!pPx*W8 zn9h;CdnBbS5tDEtt=@kwty6MPGC2pQq;<;QqmQR0=HycTn%3VgSL5CZv7P%xG*5`F z7uPxdOmp7rcx?WUJsI1X=IwYE!<4n-IXu&~;Y6(^2eB~;4dUa%Rdvbv6J^hnQHG`d zL|HpN$(kI_dK77Ne3Di6OzX3De9y?(xQHe($&cl39GMW=GbSn6QvYF2$s1$hViF>g zVxrHqAiw)4@DqN4WoEX^;0>f4e97-7@~cBjdwRzB+Ne zdnSgxrDBp}4O?5(>6;W2mlzu#ml)BkU$2;xZ_jkaia8l^l88^fJ=3k^WELZuCMCqi zbvZdBjCoE>j{2|Ev@tPC9*pbfSJu=d6_HtYrSI?Q9pryf7n?q_|BjY?ke&$JM~cIYP(I`!c2ctXi*{+aeQrK0SfI-6p3Tqu1&Y8xxmunDV!Gr>E3*RO%?hn#-^q;`~;A!?ypd6(1LOybq74 z7uO)BXM94xle5lr?T9)Vd2C$IbYlHveUQPQ?`L7F~>WNGcC~{_CX1!Ci1tpi&Sm&YqOkb#!s$6 z5x>^{nb!Epd^V1c?-9{7F1B-LM`owa4qwK51&Jh{NaSRBg4y9NiM2E~>g<*yIf?L= zqH#iepV;W&)G@g!ejOnB+kJkoUn5Me_Fp3m!g?8aax!s}32%L$ zn(2r-anZfvW8;#-+;t|e_Aw{oPVPU$x3)(pLg&~ny$vcj@C@Fa*sYy1KYW|8amUo@ zd3PecQ|6y(`F=fYPE1vzUuT|aX?{I$P7F$OBLBb63}fC;*?}2h?Gux5HVSddfs(;h z$%L&mwSKLjh`LEhy-vP8(?&R1^ATM|eDdv?*8j;qG&pT+7TYr>WzLyq`DAAroHr(k zIc3h7=J^kgd`_%52?_CMJU0J_2R|p)oK)%j?Y+dW3|RR1M~3s$@@;?v$C)F^N$L zvAvRxZ_!Wq?(|&`GA*CYwHm%3Z01?3DbrpLJgwt_r){osT>z=4cdvFGQF_-nco6FS z!fy!fK~&N`Kca&NqyE9v*>xPtrISwha&S$@iRmY4M2R<;E^$po@LQW;%Ii9+;99%j zcOZFOQ;}1?9wPYt_6qkAz1qD5tN4v&Fb#IS!Vy{@e|yURcl&H`?e^(YE7xZP*Q)-R zDY)NnaDSD*I)$tK|5Km;9z1XR|C+<~T_dMl!87gO55hvOAF_=E&veUAaDU=41lL~% z_bLspUFzr>v0&LiaJ^XW6W5J}tNlNiQ(ypN}*IsZ>(&|Cp%nR;CT~`=9OE*P&`Ddc>Z5Al^WF7 z&9=oLY^9HBEY0Bc3h~@4FTuSUg5OYfJW+<=IecT}udpyEOAv2x-?!g;)_t%p2KCTN zKKmAx7t4mkUs>Fh&HppcxewBK)bc^ugL@)YCdlKR=Iu2v2!ng32J;ViA1oi_ExG*i z+RXf67pZ^Cg{%EffBt)rUU}N)p8IfG{`*H-Qz4C*vk9|J4A51w~_(G=Hr zc|GiC_?~rt?4L}*Iyg_-^I5<`7O|KmyuebH5$q#gpb0{%Iutaq zx526zTqYO_b_rIYP_P>by8WPwzmnjRwqSP_>}u?`LK(0-`G;qF%WBx3mmaS6KmGad zzxTZK^eQ3)8OcOuvXGT*WG4qX$whARke7VqrvL>hL}7|hlwuU81SKg&Y06NRa+Ie6 z6{$pJs!)|`ROcG5mb?PyO2Iuc1IqKGDj&UB$Gv2>$5J?Kds@$}+W5=bP8-t^%%!qxsW3ar@D?&Zgi zj87kt^vjUS6P_0LGxTQw0~y3%hVU#y8OCr%FcMuxXbH_|P77KR^qax4Qybb6K|9*h zfsPDgI3sw0rG)dD?icE#F5+S?A=pP{AS0Q`Og?GmrvL@9YYr8r8{H{_Za-9vppPp- zNlH*`=$)>O+i>zWV~8SQ+qWV6V`?uqJH9H)#u1s4IzQp#9Y@bcst zihSozXBQUKY0xd3(u8U?&0jiyX_I#ulYhmK`tP=@gdWP1JDt@a)#q$`sV;&_^tW?E z7lf`2rAhP7b-Ul3-}=jX%L`n5?y~6%I{H(nfff$hKaIqLeaDpq`;lPFNOSI_!yQ@nu2v9WpaPl3tp(?n)G1C^__eLRx>6ps;kQ+yI-H!FD@#WoiTJ? zx^T7svO;MZojWbtw`Jyi@=$E!8g~To2h(qrz2rYDyG*A!XJB$!-K#datQC`g4RZWA zCy2K}@ZX8aeQYl{r}A%>HMxva)K4>&7JW0@D4W>uJv+}yIbZt zbW^jVmwg!YJ7=@*gZqI7Q^n&!^8c@^`*KxI^aH_qldA56`{h>lnPB;pW&WLY9~?IZ zQ|dnZ4f&5voqvB1)|=p7r|B&pESvK8Kia1M%Kj-_?SDc1;H;S&KK4ZPc|Gs^d35~; zPcPe>$~HH3*;2JlaLj!8MEO#d30L`oe1vPePuXsQ-*yF4>i+pH<@-K$`TRX-yW&pz zg5S0U%clJOKdEftYX5hBthzRBnxk7Utn%jDpFXfSc>GhUW1#RJJN=z~Yf9S%_vZ_y z;G7|4dPmz0s+y|b@Q0x7g8O6!_a_XNP5JwOQro2*8>Q@z#$0y1M5)X6uCjfTx@@Vo zyWrl0;cEXGz0*uxeI#AQPTN-uY_zXK@}?2)?e5OYkC!j{c#!=6d&+l9wSR28;2v;w zEgvkK^7sGbwu=Y`f=sE)_P(+$OkK8AZFjG-75156`IKe;PWi&s{y%RlH(*`Mrw8=u zHf_jvSImFx^mQ|PFvw*}eXR6>@@1)>s_h#0PCkzdw!MzZ7Tnt=SUzQ$f5-kh<-8-f zPe(AN&i{wg}Yi@*O@=#+2p4S;lbfhf=nqi_#x2S@KTqL?J&@#@kLSWALZs zV?YD?pA#&fvdn)<`NGxymrk#J&f@iRr_XJ6McW7JjA+qRStEIbM|q6Ld4eZ-il=#o z{tRFsgBZ*Zo@FQ_8O3O3GK<;FWghccz=wRq$9%%4Y-AIg*}_(~v7H_4WEZ>H!(R5W zpRYNh#gCg` z>KWYIeTG5&|v?YRew5J0diKG)zL=!`2y3mzay3w5;^dydWdT}cW zB$7mL`fwY4>BsHdLGYdFUEIw*+)K)RSRU{?_}a>$Rs8+g{e$qIy0EbEM_x@xy)le3s}e^ z7PEvG2v_^3eekY39;xwD%c`YvjVW4b&Y_RR{RyA)8K3h7U$T-_tY!^sS;u<5Vgno5 z#Addzm2GTi2RqrtZuYR3eeCCJ4seifIK*MT|!^22(G2s$9}%% z00;SoLmcK?zT*f-`JNy6k)Qbg_1WLmd{-2%_CNjk-%Z5bl;C@}=Cq(Ct!Paf+7etB z){gdcpd*oV;(yQnw*9Mzv-RxnW#SH3`=9>&@Bcmf+kQWd{XUtb3JYyKkIL0%9iA-WLQ<%y$rZaD+A9M0uD(r`W(a3L3QF_&;DmvK31xq>T6$5mWSaP4yjGLnhR zWFafr$W9J&l8fBrAusvJPXP*2h{6=1D8(pF2})9m;5v#jl%*WOwFVWaNF^#$g{oAe zI@b`c_CNjk-_69`oEEgC6|HGQTOw#jdpgjONIDTkG%<9h3tfq&8{O$aPvVHD7q^l? zB1!b754X{me%#I-+{sl%p(NXkw3=cJi(JZ#nU`Pe+Dp+K@4UH z&oY!@3}*zvINr$7IDrMOqInl-Ft9qaju4Qyl+o7uuvwy~WZ>|__a*~4D;v7fIw zz(Ky@5Qq7e?>NFyzUK#iLDKH5gz3+9_I;y-v&Iz(>z1)dzAkR&;EW@Il|Tcr$7Ju zf6xB5uXo*6HnNk0oa7=mdB{sX@>76<6rwOiC`vJkQ-YF|qBLbFOF4qy*;Jq+l?bkL zt3p+(QJrhJmg}g&_0%L>?SK07zgvsD4Q+{_9qs8rMfvAc?C)2l z7q0gICi9Y&c}KlHwf%XCU&M?Uyd|UEYbG+2g{)*FJ2~*vyHGB2lZU+IBR>TwNFfSS zgrXFqI3*}aDN0j@vXrAd!EYvl@B3Z;9&#ye$YpsUmq3MFN)z%md&t+cuD`b}P=o8K zNiAwqha0$&;Ct+P)aNE{COCd;NF#2c2~BB6b6U`nR3t`nh$e>4 zbfGJ;bfY^x_JTUr0o<^)D6hKf(W1OCYTG z=c@<(mAXr)cesp`AQ9mwjie;wQZD0iuHZ_p;%aQtfBHW2Bw~m2cj`8u_}r&_#*d6( zB%>J37{)S=@l0SMlbFmDrZSD`%wQ(7n9XGunLn=JO0ME+uHjm);~sJMk`lYQlXc2S zo$5jFrNZv-PuDH;i2W<|#Ynv^QfCWwuSor|wAYb3Wb8U$sN!MID;<3Xk`T8RGW;^w00L z&QTLPMY41 zZmRp_KiBF1yX$=w)cq>PWBqU0z{EhtfH?249~wpQ-fGmrn9(z?+4-%HB>WnSS`UgN)^{x^UAMVr#*AD(RM z_`;n&dGWs0RpslS`rlvgkFSp9R+sSm-@l{&*H*gih+GGbukAl`-=`-nOt9|Nwrlzf zX;f!m^ttMP(dr$|Xif`S(u&r!p)KwBPqokdzfkXsw9kyM^6%Zb!9A7V|EN~7c|BU~ zd_H5^f7)mMcmCcNsrNmp?ibo;##i~Txg|%fi3Q3$T%c^5YaiYG-h2Pl|Nd{)|Hl8e zwd>_KT$ShQZiln%o!hJS|E4-ye9p^XssEj=uJ^iQ_Zz&)TfEJGL;bJGz_eo;OnIlw zr|bJ|OZ;iMZdK*$pZec_U;Qs`+raqR|0f%sY1zc>U4Hn!ZkgRBlcdgjuKM5qRNLl! zNn9(V00k*TVTw?cViczYB`HN|9;XatDMxvppaK>7-_*7_zRJJl4JBXSbmgcIDl}hn z!{<#G?(b?jb)!2y_)oNLp6GigF_|e$Wg63&!Axc`n>oy79`jkiLKd-@B`jqbf2D2f zI`Qk-z(zK)nJsK(8{65zPIj@IJ?v#4zp%BcY3E34T`t@r~dbUtNu4I-O&86-IzI5-7K5m8&EOL z==iKN{clR^U)BHqY+dgioA|rD$NPN1h1CC!KbqjQXCLH0?LllcvQ_@uPulf-x5xv< zy*%}Fg~${8PJ8q8=fC;dzx@QiQq`jy)sOP{?;;I7d_F3=K&!gZ&7$+vuUqYcA3@kC zl62kUNk_#bT`gA97oO`#_Am5ti6`?Kd2yjnpab%j#*1wb`kZFMO$% zXdKnFMx**3QW|fWZ4fuf3(w_=HMUSxvx0S_>enn$t#RY<43p!J=WOoDozazRdxl3F zk5;T1Rr$1s+&&VXxES5E#_8|IJclu|0#rV+cxy*Bs}+)Oa9Z;5miuy14H}09eSEu% z@63CuOib#>H@y?7$6MaZc$&6n1-A~5yKWxuyNjkLQV$QjKAC#F~>h7{mFI z5sYLMqZvbZX6rb{Gl7XrVlq>h$~2}kgPF`?HglLucvi!F7O;>-EM^HyS;lgHVg*05 zl2xqc7k*_8Ygxy7Hn5RRY-S5v*~WHuu#;WvW)FMW$8YTC0O47lhd9jd9N`a+a*S}} z$3-OMV#2d3E+H{VNJ=s;O&ZdYj`U<8 zBbmrd7P9gv*?5fXeQenQPiR~b*M`{o~1qwXhGyvR$u%qzUgYrIZ;m4Dp!-(98MjqdcIC%x#+xAdVe{rHale9r)WU?77S z%n*h$jN$yq2u3oB(Trg%;~38bCNhc1Okpb1n9dAlGK<;FVJ`ES&jJ>*h{Y^nDa%;S zPpsf)RxsBVogFCs4iSA5MkbfGKV=uQuM z(u>}FOCS2ukMHQu_YB|%1~Q1j3}Gn47|xH3U?ig$%^1cqj`2)jB9oZR6s9tb>C9jz zvzW~s<}#1@EMOsvSj-ZZvW(^Y#0q|9C97D?FZ{|H*0PTEY+xgs*vuBTvW@NRU?;oS z%^vo$kKfqO0S{@^Ib2sZ;?L_#hmzREvt`|n$&eH*uP2X}H8$+?>p+{3-3 zKt?i=nJi@GQL^zE*~vjpa*>-nQawqsZRqM z(ul@1p()Wcqd6^TNh?~@hPH%fW<5uHp63NR(2-8WSNX?n|NWV?Kj#a+Bo2U=X(b50|ObvV1_W1VGQR-Mlh05jAjgD8OL}gFp)`2W(rf8 z#&l*dlUdAW4s)5ud={{fMJ#3sOIgNpeqsebvyxS;<`;ft4QpA)dN#0;O>AZhTiM2T zcCeFO>}C&p*~dW+ahTsZ!XF&v7~$ssi%7`DB;pbh6JO;&y!@Z>BKJF(xyX-+y@emL52&qX!TGEl83}hq|naM&{9wi%(k)0gmBp12K zLtY9{kU|uu2t_GIaY|5s7?)P5=AX) zQ-`|L<5}v{fQB@pF->SnG|gyE3tG~O*0iB5?Rbv%JkJYspd+2=%!|Cl%e=y?yvFOq zSNX?n|J_yE-RMpadeV#D^r0{P_>TU3&j5a4AcGjp5QZ|0;rz%5Mly=gjA1O}7|#SI zGKtAdVJg#@&J1QUi`mR!F7uer0v57}#Vlbd%UI4&tl(!>vWnIG!mq4hE$dj%1~#&Z z&1_*S+t|(ycCw4z>|rna_>KJ>;2?)M%kHEBpoI?|JYjASA+S;)$xWaBZilY^Y(A~$)+ zOFr^bfPxgFFhwXzF^W@yl9Zw}k5h)Sl%qUPP=Sg(NhO}5GEegiRj5ies#AlSL{W>{ z)S)i*c$WG!pdpQDOcR z5MSjVxBYiFX?LdwJ?TYnzNHU+>Bo2U=X(b50|ObvV1_W1VGQR-Mlh05jAjgD8OL}g zFp)`2W(qTy$t-3whq=sSJ_}gLA{MiRr7UAPKe2+JS;;C^^9#SShPA9?Jsa4_CN{H$ zt!!gEJJ`uCcC&}Q?Bh4~bAW>!;xNB+gg-dSF+ztv7m<*QNyH^2CJ9MN#-&`wKt?i=nJi@GQL^zE*~vjpa*>-nL9qLk#XQ@vE z8q$cyG@&WcG^05!X+>+=(3W;QM|+;<1v=1?PITr)UgBk5;Z84j-r{ZE;a%S2 zeLf(*%0F)V@BY&Mo&o&8Kn5|GAq-_0!}*aBjARs}8N*n{F`fxbWD=8^!c?X)of*tz z7PFbdT;?&K1uSF{i&?@_ma&|lSi#S%WEHFVg|__a z*~4D;@f-U&z(EdinBO_V9~|Wvp|h@wNXW$`;t~>*grp?nQZD0iuHZ_p;%ctpTCU@I zZs104BEHH$Zu{@l(oREo_G&uPlYxw6A~RXY%A;iCF|w0`oa7=mdB{sX@>76<6rwOi zC`vJkQ-YF|qBM_FhO(5SJWo)8iabdro}w~O^9)s}N;RregPKH9i`s84j-r{ZE;a%S2 zeLmnrKH_6OA->8#Zu{@=r9FTj7|0+7GlZcGV>mxDf{~13G-DXcIL0%9iA-WLQ<%y$ zrZa6r~u&DM3j}QJTjoLs`mEo+qe4MV_P*Pf?ktd4?)fr5e?#K~3r?jws_=)b+X^ zwZr>7>vdh@df_$oX+T37(U>MQC7Nb5rv)u(MQhs7mUcWxd!FY7I?$1BzN?dQXI|tb zUgi~E>ypFH(|FlZ62l9=5uziKQ_ZBO6@bWoP z)tc6*bB-oyQLSo3HEve7QNw6W*&?k(Preyib*0gkElsVu^`oNGXbk$7+Pj@hC;Ifp zaN5sl+jVm41%At^d{?g1tXbnz|6X9ajhi-VQMYDj>Q_@Ex@L77L`B}Yz=Y#A0}L(b z;;Z}dd-U)wEN@BqMa|S0MC}wX3>%Mpck-aoJ{!iwwv*h;=gWN8IP%- z+4%7S6OXU*uQVyisvGxaeErQtcdnj&Th+0ZPcG>b%cXJiW+$6TUtpeN+IF8vwq{iL zFFsPP*{DIax(y>u(;HW7TCIVUZG|TuAAjnd)U~4;Mm4o<*1W(C@?U;st@_QQ8a6xg zi!W@eI=SPEwOfp@@{fD}&u!Wn+|C``$z3GpZc=a$_mYzPxSt1jkW@Ux!#qN2(vX&P zq$dLz$wX$dkd;Tt#$#kB2RX?_Zt{?qeB`G91t~;ficpkd6sH6wDMe`>rwnB&M|qy0 z0u_0ZN<2knp5_^1f-aWNL&oojD`gz|bCi_?H<{_&#;Gg^vy>pe;L64? z`fz^Z`+ZL_%g}AT3EJH0_+)&w#Bvy4V|rKzzB3=88BqAGG>vh5 zmH)d5x7;`T`=XmJef_e}uKXrmVP=C`SI#_!5^1>*(gGp})0 z|36_|;a10B<7D!;!Z;lFE$WzdHxC&1R-UzuL)-Y|#;Yuc62=pKuBdT+<>qBf`!};3 z(|$^kCiq(U6f!PrJ$&4_hUIKkOK_F-CyVjD(zD1CY)J0dZ5;0VmUMztmUlkmJ4`HV z90ngvpg0oiEAge?wp3A^*3nNqf<h&F3fN^#8&iPhz-+X$JR8nk=O@5dgp-g(+qsqTpmp$GUf~-)u?@X)vG=Xp zRc-enHt6hia>6*i%0KS?U*G!fKH>XqC|}qXzT_*u<{P@um2PyW2R-SfSdV&fed0WLm0|1hVvsM7|AF`GlsE@V>}a>$Ru*13TI!C{2Gfe?32Q# zZb+0MU)g)p-ka9ozZ*>t@1B~jF5a}hV_5R=_>t4zKT&ln9Zo5uO-pExm@`45MALI^ znKJ0fB}GQ1OqOtD-@#Q)vM$zXY+*GRe1YGSCrzb{NvvL719sG z+2%d<`Q}}w6J1m+W?sKCA7NfICpbQ@VSNrm*yl%vZ^Yb{@2vA0GmpJ3pK?AIJ`;)i zcbD(qna7+b=CN5Qcth-Y>|!44pM4%rE6+E~XKtSlpN+(yYhI7;Ji0TiBi|JC=R$6} zFB{d=3D1c$pvq zez(paRjXR_`pqJ<6cuxh8h`U}+HKo4kAGKWE>C{f-@YrjwA0dBtt*#rTDM5UT8+Zu zKUdDrcAj>wpYASXiI<9Wo>1g?=Lz{^e!Kh2w=DmeEXVm-@IrE(@8so)%4H+x{CUGU zf1cRq{P|8l=RemXKi{R1SZA(({znF1c#caXr>)(oOX?^fvTn!xU=e3?J$G8Ct-Ueb z3q;o4<7u6-g`Dg3g%SC=_HfpBNjq@jTW{&b7zt&KoVerquIk7(}6LsQR z%V`n$TU&SP)`(d#&!702OY)o-a%vt=JZ8;2f8wX*E9Q6^H|HlZo4;<%)>Ex%>+>gi z{v4mkq|U&?Ci$llJu|1Ly_2tgT~~PiPTo$-ZH+&f%xT{pv)oR5=R|HU=s4kx6Ys7X-h0-8J@~c5yi(Iige)+ChKb>>sr*xx6^(&WcShrR!HH=fM zMtJ-D37;#2jYGoGClWrD@9_5d6Fz^At+I7%#D9KclD+WUmOj~-EoRZ4{CVTAod=vu zBxW)GnMBT9Zl`i`d}pL88C9)8pK$)9&&=%UMOisICh3NfK7GRZlRj^*3pA|RxKZ7P&0=<@=TGmvS&cf8 z-rwF!o?3X7y^M9){M3Zg-oLOshxV+ozQcbf`anJH{qujvnalZPl`}fb$B9%=zIpx> z&s@?cE1mzc74Ba@i#%DgJ#7a3-lXYmd}a2uIq~yT+*ZARHP@#WXXV10@}Bzl?<`d1 z9O?D;%yz+lHD{6iQ*`BUN>ol`;K)0FCu@;?)7hIA|JA(3{XO@1f1j~`&;3h#`M5tj zAMfDvWYf;Sox4aj|IPwCnWxB$^CxoJY9CYQiDckk_M00Iiz(7J`fo3#Gy2E}v1+IPzN^cz=H$e(k2x8P{LH2r>-00yyZYbF z{)uHCb6ObLDaC3L|5w+bf0gHwjT$vRF%$oWd^eQ(i5ZF4ycdqNtUrX!erA>?KN%Sw(+lq(8oczzdj6!A9Sx3 zXB#?d3%!Tf!wwDBGd<$|=rr1%bLkb@niCmr)u6l@cWP7rB4KEDw>Gtuxmi0?COzst zfo$?+m z6yaX~(1v)F`AmAR@6xdU1~((*mFM>vDD+N=m(Jr}5z98_IRetSS;PL&|N7n5g)4Kp z_l_ZA!f20K(^aoSMG7f!9-YwsuoquTKKjS+0I$Gy?m=<^FeV_g! z2t&;*@w-D8n`V*xrp+y{%J_LAL+Il? z+$VXqAv}++oOLV=V{AJ~Ea%8jGQZ_WWaw?Zy*!gP%8ATZLiZ%n+3UDNi*)+sAftxU z?Ly;e!;x#XPq)5={*Obyy<5GmVfn-zj#zIhB|r7<^_i6~e`aVbZxa}vTwCY6&-_Gg z>sYw2BHU9kLz*{P=KYmvxRK}$)6OD9{3bA2Y?AWkR zj>O(kI^~uS8}`v5HcX2h8;&QD*!U{{+n@WPeu`&1k9@yn)S#b>mF_*XYTJ1s4`DwZ z@(}jrvGWj)U6DL|@WxATgxGLQ3$bBZ?AWmHj>MMDGr4z&4g2&E8}~k|a14yZmiuVa z`yn6A{os=o&KC5s%46$Ka?AWl6io{0BBJ8_DY?u~1Htd%pv5~R} z`|A)Jrp1m8$M{HW`Q6dILVm-sKg5PMTiZ@{tz3c#f}YifJp3( z(K|j4v7v4dV#Bo9v7ufTiGBN~ru#x{sIP_CFfDd$sKZ2J6KA=~`x-;NCz6MTlXvV5c?k8S z5F4h&&Tpu~v*_4fXjD8>YpM4fVfBY?B|{x9#D;0HV?%u_l5S+b6Y60hHcX2h8&hZVez+GjlHX9L3$bBZ z?ATDBjiejNZ>Z;n*f1@2Y&h?T#FqIaMa(h_=OZCDOp6^G>Tw}9zRJJ$#GaFCb(yp0 ztqI*n&MfYpM4fW(m zY^01sJvzjOX|ZENJw6f}*@i;>KE#G;AvV6sKkoCtRI3uGX2jgXX3fSv&uf}dH*DpvCgzp{q4tYbYJ*vKX}vxTi}V>>(8$u4%YhrR6M zH}-RYgB;>8zjK5?ILa}?4=5Lrkc&w~e3gIP{@-qs_U+t3_-*Abl5;mHxQBa5$$i|< z13XA79^zphAvI}8OFGh%fsAA#Gg-*WqlDiHA0sTwNFfSSgrXFq zI3*}aDN6G=WhhHILcbtSP=Sg(NhO}5GEegiRj5ies#AlSL{W>{)S)i*c$WG!pdpQD zOcR&aK z$t-3whq=sSJ_}gLA{MiRr7UAPKe2+JS;;C^^9#SShPA9?Jsa4_CN{H$t!!gEJJ`uC zcC&}Q?Bh4~bAW>!;xNB+gg-dSG5lbZ;35)oF`f2u3Gdw+E3RA}ZEKINAS0z4P?{aBBML{XfKh|HPGzn1&hQnEm(r ze@J!FO ze}%F?*_Vk-C%WkL@=SfAuZy&ogvjG{_~Wna)68rA$h_ulUjJDWLSH4V64|Gb&i|3= zH=gK+Ma(sk&&TeECHDLAwJxSVk@sC^$@_kJ|1x&oPxQ_a@}E)sC_?@tG5?ADN0xoR z#PPTPkK6xOSWo|*%Rcn;6^6{mM=^g7TK0*Gp4djhdJ}8e4=}G;eI~?5V*ZoMzHrjx z8MoUyIUJJzY_aoiN?30i%lGx-Lu_RFxwh%FF`ql$KhgR2U-7m5$G!d&W-9i)9X4+r zW6xWxvMFxf_MMo&NKAaqU&u#%ZTFGwCefuK)#JYd9Dk+0W&UQwo<9>p**%<0y^#|B zk4*n>nz#5W|G3wGR4qe4`6u?t|M_EUr0m9BcD%%@93RE}{X^N+EEa3O;oVSn;aS~p zh!3%m>Hke-7pWUXjz`~w%Aq0lyd5=f6JyU?tnF@+d5f>|Kil=6_}=c?U2%N=Y91fO z{5@v=QWQV4?7CYPg~f;1$n^i_va5XMne(R0x5O{Sp0`+K7oOu9`c@6|7m4{h^A}&` z-?r?~8<+1pQf$cD{g*!Xdye*T*Uj6nIzE4)?h_dt zNX&oYcpd3?El#>~QLb)!qn!|*us5Te356rL}2wa|+#Po6Na1qldqg_veu)7MIL@57IEMc~;<9cr3MsDI} zZsAsL<96=gPVOQ(caws9xR;dN$NfCOgIN7y`bmD+_z_Z*hP0$3JsHSICPH~1~YhtdCa*MB;jrx$sNmwAO(d5zb3gEx7Lw|R$m zd5`z`fDieIkNJd8`Hau`f-m`sula^9bfr5z=t(bn^DTYoOFzD&Ki@Ne9~j6W1~Y`A z3}ZMyGJ=teVl-nI%Q(g}fr(6FGEEMhTBSjsY%^Ajuh znU$$!m&xrv*(gy~Js#1;W)SxC&)S@b5JG{$# zyw3-G$VYt4Cw$6he9jkq$ya>MH*}#Z-RMpadeV#Dd`lnt(vR=x&-V=A2L>{T!3<$2 z!x+wwj9?_A7|j^QGLG>~U?P*4%oL_Fjp@u_CbO8$9Og2Q`7B@|i&)GOma>fH{KN`= zW+kgw%`g1Q8rHIo^=x1xo7l`2wz7@w>|iIm*v%gHvX9@`&jAi{h{OEO5&qyP#|Q`c zxYvI!@tzKr6C@!i$+(ouxST7vlB>9y&?)w{T*vj?z>VC*&D_GR+{W$P!JXVia_%Mt z_i!&M32n#k=K&rh6%X++kC2))q$M5c$v{Rjk(n%H^4&7kP=7d4*Sbjn{dDH+hS< zd53p-kN5e25BZ3X`GimTjL-RkFZqhE`GziZr5oMpK~H+on{VkuU;6PK{rR2&{J=m4 zF_<9?Wf;Txkr9k!6r&l#SjI7)2~1=XlbOO)rZJrv%w!g`nZsP>F`or2WD$#5!cvy8 zoS#_1&#Yt>tNDdrS;Jb^v7QZVWD}d&!dAAiogM6C7rWWRUiR@D`#Hct4sn>@Il>-QWL(N+T+S6-$yHp@%3R8rl6r(sLC`lGyvR$u%qzUgYrM`I zyvbX<%{#oyd%VvFe8@+9%qM)xXMD~Ve92dQ%{O$RE8XZ$4|>vz-h4|R`qGc@=+E~I z;0FdWh`|hDD8m@ekBnd>qZrK?#xjoaOkg6Dn9LNWGL7lXU?#Je%^c=3kNGTMA&Xed z5|*-z<^047er6@BSj{i|${NW(;E)$9N_%kx5Ku3R9WJbY?J-EM^HyS;lgHVg*05l2xqc7k*_8Ygxy7Hn5RRY-S5v*~WHuu#;WvW)FMW$8YTC z00%k5VSeWbe{hszB)G)(PeLvx5topdBqSvnmvR}Ga|Ks&6<2c&*K!@#a|1VW6E|}U zw{jb|a|d^F7s+=(3W;QM|+;<1v=1?PITr) zUgBk5;Z84j-r{ZE;a%S2eLmnrKH_6O;Zr{2bH3n9zT#`Xp$lEag1jI6Pd(hrZAOhOlJl&nZ<18 zFqe7EX8{XY#A24Plw~aECsyz?D_O;Ae&JWvu$FbKX9FAA#Addzm2GTi2RqrtZuYR3 zef-9L4seh|{LT^n;3&sPkl40QLM|o|mynnwBqbS_av7I%1y^zvS91;5avj%m12=LL zH**WOavQgE2X}H8$+?>p+{3-3;I&U-*?ZtYsbR*}z6Nv6(GwWgFYs!A^Fun?3AhAHT7m103WK zhxwf&{J~L4cBrV*K-3m zauYXm3%7C`w{r(~au>BozB&GwG7;{N%tC0x z_bAzTjO^qfC%MQ?9`cfp{1l)dg(yrBic*Z?l%OP~D9z)Pp)BPn&l6OjB2Q9@r>M-+ zJVO<#QjO}=pe9k&qBeD?OFfv&uf}dH*DpvCgzp{q4tYbYJ*vKX}vxTi}V>>(8 z$u4%YhrR6MH}-RYgB;>8zjK5?ILa}?!+$R#As3T~OGr!-l9G%|xs1!Xf-AX-tGR}2 zxsK58^agI^CT`{yZsj&^=ML`VE|POMDY%DwNy&ZO&jUP2Djwot9w9YpNJ~1>lYxw6 zA~RXY%A;iCF~W0&bC8o<@1|cDF?+N-;v)(-M@V6s38bGL)qp<#~b% zROCr2@f4MLnrEm&RjN^)8q_3;TGXZvb*aa*)TaRrX+&e1(3EJJ(VP~vq!q1cLtEPM z9PN3Y7wAAoI?Kg;#lv*Lj0Cd5gDshj)38_xXSi`G}ACgira5&-sEc`HHXk zhAwoa8{O$aPkPatZ|Or{`tcq8`JMs%z(58um>~>h7{mFI5sYLMqZz|k#xb4=Ok@(1 znZi`2F`XIAWEQiT!(8Sup9L&r5sO*EQkJotpIE`qtYj6d`GsFu!&=s{o(*hd6Pww> zR<^O79qeQmyV=8D_VFA0Ilw^854Iy~Js#1;W)SxC&)S@b5JG{$#yw3-G$VYt4Cw$6he9jkq z$ya>MH*}#Z-RMpadeV#Dd`lnt(vR=x&-V=A2L>{T!3<$2!x+wwj9?_A7|j^QGLG>~ zU?P*4%oL_Fjp@u_CbO8$9Og2Q`7B@|i&)GOma>fH{KN`=W+kgw%`g1Q8rHIo^=x1x zo7l`2wz7@w>|iIm*v%gHvX9@`&jAi{h{OEO5&qyP#|RDeE+Qcp6Yf>Ggv2BvDap8$ z%eb5?xRR^5nrpb0>$sj9xRIL(ed681t=z`#+`*mPMRM*Y1@~|-DY=jPd4LB=#X~&I zBcvt`X-P+VGLVr>WF`w)d6aBCMs{+LlU(E`4|&N)ehN^KLKLP5MJYycN>Gwgl;&~D zP?mC(=LsrMkteCdQ&i?@o}mg=sYZ2bP?IQXQJXr{r5?{xp9VCf5shg=Q=$p|4>qR- zEont-+R&DEJV$$;=LI^@kxq2xMPA}%Ug1?<<8|KPP2S>d-r-%|<9$BhLq6hTKH*b7 z<8!{?OTOZ3zM%_U=|*>Y(34*D=3DyEmwtRlf4*k`KQNF%3}y&J8OCsaWCSA_#c0Mb zmT`<{0u!0UWTr5cX-sDZGnvI~<}jCe%x3`$S;S(Nu#{yi=OreYJTBY*07d! ztY-ro*~DhHu$66WX9qjk#cuYnmwo)kehzSuLmcLJj_?OZIYxrZZ2u(WViIu)iAh3I zl5r`QaXB66NGCe;A}{eWukb3b@jBstm^XQgw|R$md5`z`fDieIkNJd8`Hau`f-m`s zula^9bfp{J=|N9=(VK7SLtpyw9sT*90sO!~1~Hf+3}qO@`H>NfWE7(r!&t)oK;xOf zL?$trDNJP=)0x3cW-*&N%w-<)S-?UTv6v++Wf{x)i52|JN>;I&U-*?ZtYtkL*vKZf zu$66WXD7SZ%^vo$kKfqO0S{@^Ib2#vVI&D9ABeFG-q5)zYyq$J}~F5_~p z;7YFIYOdj0uH$-c;6`rZW^UnDZsT_D;7;x$Id_wSd$^aB+{gVqz=NdXAs*%tQj>@%3R8rl6r(sLC`lmyC7z-(PxA~_s7f`eQ-hjBQH$Etp)U1!mijcHA&qEE6PglDGn&(amb9WZZD>n7 zo})d_^8y{{NGCe;A}{eWukb3b@j7qtCU5aJ@9-|~@jf5$As_KEpYSQ4@i|}cC13G1 z-_V7wbfY^x=t(bn^DTYoOFzD&Ki@Ne9~j6W1~Y`A3}ZMyGJ=teVl-nI%Q(g}fr(6F zGEEMhTBSjsY%^AjuhnU$VC*&D_GR+{W$P!JXVia_%Mt_i!&MxsUsKfCov%Lp;nQq$Uk% zNk@7zkdaJeCJR}4lx#dkc5;xDT;wJXdC5n93Q&+jgnI^yP?Ta6rvxP_MQI+V3}q=t zd7hvG6?u|MJVj-m<{7F`m1+= z(3Wt|KU7KI9`l<`X{UGd|}F zzT_*u<{P@um2PyW2R-RUZ@#4ued)({^yhm9@B;%G#9)Rnlwl0#M@BG`QH*8`V;RSI zCNPmnOlAsGnZ|TxFq2u#W)5?i$9xvBkVPzJ2}@bVa(-e3KeLimtmYSfWesat$9guf zkxgu73tQR7c6P9nUF>ELd)dc94sn>@Il>dr8TC+)uc7^+8hc5D)VRsYydx(vhAF zWF!-r$wF2hB^!^CogCyO7rDtpUJ6iGwgl;&~DP?mC(=LsrMkteCd zQ-u3=pXM2=P?c&_rv^2Nq87EOLtX0eEcIzXLmJVTCNw3QW;CY-Eont-+R&DEJV)pw z|9M`Z10Cr^XI|tbUgi~EreYJTBY*07d!tY-ro*~DhHu$66W zX9qjk#cuYnmwo)keh%>e*n1!Ny5>9nKP4iF3aYA#sHh++t!PuL3XKYis2~WEHfd9$ zjW#8%j-co)D1we6C^CW~$fhi#tRv{Gv&=fOEwj!t>*&a=_&(p~bKbe1bI-j=zOnne z=hv_Ec)W7kd*1JJKF`nV^Y5JduN(abeTn{ywxF-j*XSE0AIKbpwn5vXM6?}BLffNc zv;*1^?SxX$&S)^&1*M{0(QasWGz9H|hN3;uFtisMj`l|KneKhizGy!rpLgCLjYJ2a zbaWsZg$_a)=wNgRIuvE1!_a7SILbm}&{%W?%0@?`acDfsK@-qX=zC})IvPzv$Dmwv zEIJNNMtSIXGzFc2^3jRtBy=*GicUeNqSH_TIvq_zXP`oKCOQk9jpVli&Ozs*^H4E5 zA6k(KYB=v;Ptl8LHF^oXjDCh%(a+H<=vA}^y@p;#Z=g3(8+r@9jov})(67+D z=+|gH`VD#y{T8*O-=X)>@6iVI2lN5@5OttGqCcTOqfYb}^bz_i+KB#!K1P2>UFaX^ z6ZB8C3H=LwiatY|(ZA8>=nK@1{)4_m|3zESSLkc>4U!LF4?^3ZZBZiH4ke-OQ8L;A z?TB_lDQIUj80~^m(XMDWv^yGt_CQ0?o@j400_}tLMf;&Nv_F#HggF4EqXW?>bP&ow z2ctvKp(qm_hDM{qQ5G75#-bxoHaZfGL*r2nnt+Z%-$N78(P$Dn2IZn-(Q#-p%0tJa zDd+^0k4{76bP75ZorVg~>1Y}{0~MmP(AlU6orBIr=b>VBKDq#1h)Pf?nvQ0m zGE|OcqFJZ{%|;iYi%})I1kFKnQ5Cur%|r81HCli!M>S|6T7<4Zi_!PdmFOx|i>^l3 zpli_*bRD`L-GG*&AD|o24^bVu3EhltLCess=r(jasz-OAJJDTeIg&4QxEtMrR-k*) zedvDFfF3{(qKD8*^e}n^J&GPjP3Q^qBzg+1LQkV-(6gu+J%^r0FQ69m6ZBK`B3g}J zLNBAAp;q*B^a^?vtwFD$*U>M~TJ%fw26_{Kp&tFQ3v`X`V;yy>O_A*AECdZjp%RaWAt~_h5ms)LH|UX(7({9=rgn# z{TqFbzChjRKj=&JU$g~%g}z4LAo+5IL1-JaElNb&p(M0DN=7@N9nnrG1?`Lmqg_xc z+7<1Fc1J_d9%v}q6AeRqq2Xw6Gy?5|_C@<4`4+ML(MWUvN=FBxQRpC)feuE8phHn6 zIt-0Q@_RP&-5X=jSabx+Mn|G?Xgtb66VOrUduSp$8cjmSpj>n;Iu1=ndFXgF1)YHM z(TV6JbTXQXPC=)l(@+6A9Zf@Lph9#eIt!hRiqJXeTy!2PM(3jo(1oZ3m7?ir1}a14 zXeOG4s`bS1h9)uOA> zHRxKj1YL)&M>n7!pc~N-Q60Jo-HdKQ%h0XpHgr3xM|Yq*(Oqac`VqPt-Gf%3d(nO9 ze$;>-Ko6pa&`R_$dIUX+8qtr@W9V_zgq}c8qNmU*^fY<~J&T&rbLe^W0%}1&K|e(= zqSfdn^fLMxYDGUsub@}a8uS`^9sL5WMZZLEpf^z)dJDac)}ddachRrWdh{Fg9{Me6 zN54bwqu-+q=nv=v^dag%e?)&me@30?FX$umSF{oR4SkIMj=Io4&?o4hXcPJu`V@VJ zHlu%|&(RmC8~q1;iT;bWps&!^=o=(os4@s`gSJJ9XgidIwnxcm2ec#F38kQ&(O|R- zlJAV!743$0M?=saXeinf?S+P;z0nA?584;)htkmgXe2rSrK1DUD0C3YKnJ5k(4i<3 z9fn4u!%-F*gT|sGP&PUejYH#64w`_DLf=CZ(a~rU%0)s(P^jvosOoVGf*Kq6P<<5Mn&ixB)=bY9x6uXqYKc5s05Xw>1YNjLlxLj z&f`opn}1(~X36vDV*Wjw$BX3Os1jX*=AgN#3SElkq4}s9EkKu{%TWzlh!&wM&|>s` zbS1h9)uOA>HRvJEbuEue&~@l~bOTz7et>R7KSXutCUi5p1%1i;|EqX!@G|~=E4qe% zUyE+z-?yV1`FA~!cc2FT{V=+df8T|6=Jle%Xcv@4egIcq61JmIuMOQ2cZmfFggSsiZan*Xf!$;WuY->EII;Zqa)EcG#=%k z3Fs*FJv0#=jV7UEP%b(a9fu~PJajyof=)pB=tOi9IvGtxr=U~OX{Z35j;5hAP$4=K zorTUuMd%!KE;O{-&^+)J${QGVm??IpN@6&mG;NRRY{2YCO z_TiqwzGy!*8RelLqhD~{u@?Oj4P%Y67aESvM3{3 zR->2D%jjpQ75yB&f?h>y&@t$I&VK>A5S5@(G#$-AWvCp@M6*x@nvE_(7o$pa37UiE zqAGMLnuq42YP0}dhAu}nXdzmJu0V^?_tBN;DpZTEM%SQg(GqkWx*pwtet>R7KSXut zCUi5p1ua9jqTA5zs2<&c?nHN? zk0GXvgd2Xk-#3$g^Uai++JdjY`~64e0_x=VhcjOAs9W`M%yaxlejh6czyEmHqi?-e zM0w#{t4d}8w*(jIQ)If<2hcI;>de)YKhnP2=)V&!wt5-a=c*zbP-kxF5c&(~?4 z#ryXkWge3Gzi{!Rb3bMN&oV{q_h0chDD(eU&mfEJ;rHjwQ|fU+e7u&%git-Tcoz71k+I z5Ar<@_I&aG!tX!J{D0Y`ITy;jd1{`ihsSxe>p|YDq-}l1s##Y`?3Fwxbte1lSow`- zjs5QTpUqejKr@4WrZ;_+af6OUz|?eXm6L$MD{zGIWbCi9%c%04^x z-u*(c`kU{QcurzvpB*dT*{E%2Lfbu0$#G}$oW#mLJ9c*~cI79f84}ydEli1(eRk}> zM){B1$a4}a`|Q|V`3$9&q4D!k7s+wuGv*R2`|Q}P+)(W1Z)ROCvFoWTiIshJ?4NT& zvHCmX_wk&>%04?*KF6wM_{+jE2g`A1@|?uVK09__zSmh}r?q6vmDp#H#L7N9c0To^ zvB!VC@e+w0<<^<(vt#9bRT_K6uaEdrVvBfAjw}1@*mKiDvA66wZ?nX1aXprOcI=T; zLa}R#TN@!CUIVpqevt!GKhhp`<+ShxTSlMUCw(b#%J+%6x z_oWQec}|Wi`|McxPH(M;Lr-nGLSp6n(Ir;)*|DGGhGKQ>tK&I|m3?-syiTIWZC?A2 z6Xdufc}`+wpB;NzPAK-$7Y_WH#L5p_NUZF$W92&?^|)vLYyP7Wo62(%EBowN`N0g0 z9kFp6=f2OAV@<5=vtvu?CmO5$Z8*=#ab=$!`-F8|z3(%P=OkA4*|9_S4;}Z`NoO7? z%GP?x>P9)P zyq`#7WuG0Ja%3p>pL>+0OKhWC2H9uFwpnb22Yyv6vDG{$$CZ6{th{ciWvH*azD{E0 zv#1g)`|Q}+c%-ps9Q&G6-gMVD*=NUIH#8J`*n@X$BgfsB=j6Du&yJltIuxt-srKbL ziIshJ>{TN}v3jpJo#!N0_SvzoSaqiTt%~O)R`%Jk`|tvUvZ)tqvP`V(vtzUO4#n!d z$T#Tga$MPG$G&w~C|0j=7W16M%04@G?zm9wPjCPAX;NoHcurzvpB=kD_xH8D+m6}u zPKj-G>rD39v3pu=^7`RB%$L|V+~dkVJN7NB9-jRDOZQ3aWjyDUH>@6Be7w1Y-3iAh zoSHD1$7RU;#_%D#%JWkf$zORcv`yYEA?c}0&HCiK^`EH+otKZ>$JF!fJldX2+Bf8N z$?^Nm6HhwbSlMUCemW!+yEU)>Hs3$@8>xry)_>ov|KwWoyY-(LOTJtGnR?io*MFPZ ze^4)D-*@Z3E7nOpe7F9K&-$-?esw|VywXeNcQUw`(T_fA}W;11j9 z`tX#5yaX-}5)ucA{+S?O2f!sEzm;g#i7h-YTfTX4{__n-w#4_8eBN^7iP^aSO|9s^z)i_Hz~U%1g^;&zUv4 zuyp>#^QjZ!kFPA9Up;%q{PNOyGb%=(T3$_&=FBlgl7G&eJ!`?dQYj$iPTN)1%NKFm zM~*EuHTjJ6tn@54{x{V5WQ4t+_w~)IgePrRsjE;P@BJ&kbV0aBllt{KNg(kW6OZz1-OG2c%f>B; zo{jGqPkP%fKYOI^<+lcEh?iL1ACIzY-B-$Y9kbbG=eyC95>Imbh_oB4?pIOv9C9RH zW8zVMt^53Br}&;Ro9}f`I?66TAyW5MlzRyAGDhqEAogkXCSwOb8{b!-bdAksc{3F@ z`JP+h)0iOgsdtGx8a{h`=DYZl-mv)y5$`go3;9k_iPil>}m+x$pc#R1npL*B2lY^IVp?Prr^7{!%Wi}trig)r|jdjFJtnLpYn|deTttOkz z#_vKTy=t>r{ca6xmE=gg#sra1y<5DqgO^Zd9-P1Y=0(!TsaD(MS@BN3S1zA;iPil< zWK-{o2OB7xjU|85^){R3oqUg1200S1F+t`V!E45{*=wai@O^Ca6)bSB88Oe06W<3w^aE*=cp#v0^elFeQ- zZ41NHFb0Vc59GT{D#?*}jfqG3)q}EKrDWdnCsO`v!pd)ZAm34uMV>HdTs#=mgS_1w z1kbu}I~ZER7$izOkk1#Uk|S#)jR|5uSC2Aw_wyye$4iq@`$;~0n_WhY3nHU>n9OT? zvSC@zwmppbVT`g}}0hg}i)lHt1}jL+_8Dde;uVbr)FGOCAddx$&U zwbBkS{wa)6V#LEuuq`J?)=C-^L_YO!)lez9mv2Y-jy)}UKU@djV)BGh1sd!3yw zqk9Y60Z!(LI&Yyqc9IjK?C%3ol zeG@0my70o;b7oghojaqnGVA~1^&Rj1bG^4*#QURUv+H{Y>iZ+*x9Zy&-=)%z=x?2W zcwP#})_eBq@ey+ZueKBRtBv@t_)~Ve+vhER#2Vf{*U$do^+x-{Fy6l;+fC-d`MV3=%+&LRym36~ zrhKgHoQ?0W zF%Qn)UGZj#o-gE$(`Pa%-;gvDuQ4(wOFO%yXAX({`f_N$_jN7%`Dk;D9TPss*!#S5 zOleF!liSL6pX#7KWV8F!&Ukj<8Gg@t`V@$Fd0jx^`AecKJ+4$^ameDn0F z&NQyy_BZ}%Y;gUX5flGpUbp+)3b!t8{|4jVTCGcKOq6+QCiw&LPUoqP1B`dimN!KcdHP%tWt~c{oQ6|8_SAkAY-BSv(<;2^V%K`$HRZ>c|9J6 z`dJm_EhAU*G&ZeA zht_AaTc5U%d{1>!x7MflIC<`ZIn{D$HddCD{p^F@Ycstsvcb8s@xHdQ5B`0r=hM@1 z9$D|VP`)MP$a-I6be&SwGY@*_Is5r&^PC+MKF`_vyz|`Hn5`$}a!7p9@v*>Z0rFgE z+Y4VVJJ;%8jxSCdcg&ei=(idl>6^0I*UkIlO^u#Yy)oU&@u!e-rjsW*8W%@@N~Qd< z82{u_$nG~?Ze7{_49B0%T36nF!=2!Pd87Sih|}`CudnQfH=pbI)Emy@y#IsptsZaU zH71U}aFr7qUt~FN_nW0|J=wnOjW5@p7q#CUk;O5-O}}Y&Mn$hTX?Sy;o>RTC`b{0> zEGAE`zcen6{>UXxO!|#1o9%v+ew3U^o(pXw@MpK;aDQY-JHnZr`sa=J+DrRQ<@d~a z>~;J8cr!%Lr``}I{U(F*4IxM3HAdG7m-fszk*~W#`@Qp#{d~0f$c_o0kL-Qk`RIt4 zt@q@>cE9Ry>(TaYAAEaG>#=9N>zR*^kSVNx-bG%oXCBP~*lh1c;@t~+PW8^}SDln| z{X~@3h}_PLd;d*Xak~-MM-`^^O?n zcMX)UjvQH^YfONBb7p_3-~P4l{$D4{f$e@*bPP{8&zVR0yC1%#ToCSCsNcyVsDI^( z-0xQA%2~YLrQ_XTJ*RqS^}AxqIW^bhXk38(b7t&V_$LRp{Tp_y)TBHY+S2f^RqIm5 z%_+0XE6d7Ct4p0Z@Bd=0=)K0$`;B?WnR6`;oigD-{Ch>uX`hl9>3<_AXBUzjjnnnW zyqA*A7!5)XZ3oNfk&s5xaYM!viean<=ue9CykAx zPtJ8tEaoE_X5_d!?yPj{%O3C2@#%f7FX>15<)xL?6*3uR%R+D<{^&ZeEuRCh+2h>7 z__LuT=|7E>ubLc**BJF>ew2C0em>efWXFWhL-s!JJd_=?b)Iw=dwk11ktdwz z%%l805MPQ|%ng$Ngna3lgtA#|48$8?;rsK%?mPa{0}eHF>&;TQkwefUmf&+-Vqz@epBPtlkLkv_)?AmgQO54UqbzcRZIWM<(+f1 z->f`E4(#K?sz#2hb(MOm)Ra6I z+A{EGv(}aIr?N_V&5>jJSst%1+Glc3Gv~19n#1trb3K>iOC>Mwm_9RvvUMPd*BJGr zI?7yQKOb$bv17vL8hf92t~oMhYqbLS>^{@v)|2hY!FV!{t1he0R95x$m?MvnI_qCs z@p_}}pj`^VW_vRlZ>sg2t~aK~7=Kn#&RX&$N8{q?&sZscEc(ne_qbYDd8f;nynW^n z{Mn>+<>@m=4#*enGnI03HW`<6I~-p=)pLdQnS9DNgdB<2m^gZpEoF{{Cxz~D_4U{e zx1Q`ib10r%#Yh^Z&p2z7Z_{T|q!4VjH(7XdwVpFVpXsEW&1aY#jfm{_%oQfzQ>;v=akK!VLq38By++*ywQHM@=S9+dpsM1H>r9)ym3$G z+!v^&d{fDhc#TnC7DSnA?B}D+HFiw+Tx0JGn`=r?~7Hwl9a_ zOP$t}jAd>`g{GUb0ePcsAzvB?o9)e5yt!G=8FosEb?$*u)=fzAG&YVNF#^YCY%6w; ztM%35)|c(kXgu0+W|Y3e^WUcLbQB4hcU(IHe^T^(A%7fSR#U#E&;TRumgw zxIORbJB8=SndG_9b~wKLNb4z5-x>GqKL4~tIxw3(=Var}J$lZNH@Z}FJSw8BndC~I z#>UU1an8NpSj;;zaN6^Zyx&JQ+oLQz%9s_o?~FULzkMh2`xz!m=Vg1qJUD-k#Gga- zd?9}vU%Dw@=XoYxWAt^o%X;RW$nR$e?f1U!V?Q5lUb17t=OufecU~HoEkLpGO)hxl zxH>Pba_iCdZ4AD>sr4AKZ;c<&xToW6f^={;+q-di_m-YBZfa z`?qHFzNbO^-VkRs>|N7Oz`u4qU(e~xT7DDdTTN{&=DZrC>ygWQ<~{GcWg5&AFgI%;}7?)9N)Fy z6w4yQdCok_-yHneq;)0!oI1D6+}#_`N^fA^Xuny)yds;7Pr4nAH=pYH^mOc$@vMaM zWs)QD8l%3{M44~w=cCOxc1-wuWAF3MH{)}p%(3Vb$h+>uUAy!cg1 zxr@jbpEW*?e#Pvb>k|0vK9w$uZs$4kD1Rs6R}yVEdY}4s_go9-n{(M?-ei1A)^mpW zB+=qg24&rXBu``G=uyn>sa_AC-KW;M^=0>|WANw>t*_{P%30HVn?98&i+(oSt315A zOV1tVl{-zDF_3aMRhwLmkE34`ghT4JfA!J-_t*WvJ+96f)oz{He&ymu-q8`UcaFrRNim%;_9oYA9bGITEii>I-YtU7dsR z$NpYD`}t^dlN}R2H`)8b=BAjf@9JQ%$GTK*2FhmpaxA_)sP*LZBU4eKX=&zwywSFh zD;H;Mwl`DoW~H7pYfSunnUE!AkHwg_%ssBIt)|j}WwU*m zj4w}VJw@s}6SBWm-&uTxIj8MSKHfa7=L~t{={p6KHJx0^)7UtAB)5xW;?eEyakcMs zx%Fjx#BW6o~o39rk@8^NwvN;!m!g4}bJ@5+`f8 zO_Z^fK~2UrjZ<&fwX4L*X3stL^U>xWJ0^VYvG;lBo(VBq!`%sk^h^CL-ZHnYY;TUo zo7GxZ(totFdM2L<&YEQ)YXfZ)tyenL>6w2{!lReYYeQ5fC#yIUm#kJ-<_850E{!G;KS^h|*c#};T z6Kl=*rg3rfrj%mE#GAX_<7yvT53_7`A36bVeyMd8xeqyOmv7UD60b4mwLO}OM{nwR zEst~}5}(>@x&FD@_@uFM^vSu89E(15uj5H*4Oi{fm+ce3&zDrhwP3_PRNCLq7!x zO!z!y@AJ-6r7>IQHNbDrQ#o>j$a&5@%HI?5?!Q`>5&Kx_5fb-p`q zTc5U%Q}Hp0`#L>7o>5Ucugtj(SUR2j{`nXA{dg;H6f*Di*y;F}tmnf&b2`)iYAN4T za+r4#G)C7aEdL{3i`mado8#=5@Hx)j7dFS0O4(!K%VX|w^_0&Iay!U8(#z(ms$tHEJ+cdnnUeD=0r87Q`pqyPuax^ZE{>1D)Z4-Rr zyY`!Ax2|k|PQ{;XY9jX=c>#JL-st`F4er9;Uf-XAH;H<_9&b#)X`y^e2$pz_iK8#& z6eA}6=1KRs+HVTvX07v_d6d7W;mfUBPZ9dfbXGhA@kaa2;#hOZfm==Pd=vSaE41Hx&1F9yZ9cMN!sjD< zpLaf*9<%jcGyKvXv|ly4^=SKcI=;QC^%$vNjqk5_k>{h$w~2FJ@6N)z*Yun{-i7*A z6Xje%p7^J60roFu_jaF$-=43^ZkL*r=R(^w{F}+^5Rv-b1j72)@4Vh=ziX;D=dsu6 zXX9Okp0CF{)9)%MUm-aXuQ37kEl22LF)RRlHk=m>!hGvl2To@d zG!XA}KC8UboYVHM2=7MdIeWYd^}BS+IfOjP(YOHnH{I0f|NeazFFIa@#?215F719- zh<|TuUCOvwSTV1>w5(w6+)8=HYkL3Jir#B1^)F?)@y}kzpM!tv^qihkn*P^GIh*e? z>v)aR^$54}-FeSDui4K>o7e1^@OjPN7dEfOY`yrh>yO^YSmM@|?a!I`GnLBg>0cp# zdivOmF$3#kx(;gok>8_p@#s`Nug9ZMKU+$9i^&ylH8y@e&4}4O-&WTr9S1Yyg%;;I z^C*AM!lyU1zWn`YhTQP|HsfI7J?32Yy8b*oYSVLiJTm<#lX7lBlB02P^k=LP#A2R$ z#XYX}qc*p$?0$4M{+z?jlwSMMxPf`3{bkZ&HGzvok58++=jvb=QO88hb1t*n%ta;=&`P7{(G zjgz@uyyl}Z?%WXhnkcm2J9pU6htC}YX|MKLckO*raxdcrFlKQf<+R1gAx6_8+&K`& zdUAzRV}r=4UN+tDU?!Ym9-O}y!dVl6Q+A4%ZSd8QCpj7yL`Lo3^$k*TQ(p5gz8e9? z*CH_5Uao?%q`~BAY!Ers%c2Ji9m|TItrX7PSR{qFSqTs?mp5<^i9E^CI32_Ic$C{O zz5UL9{(s%?(jJtOnev!_B_vFTVR8fp+pA(2x?B#8jR%K%(dlw9HT7&W;HZwkApzn= zIytM5>W)qJXIzT?L#7;?##JdKS9hpvzE9yS0r$4oeqYJ2*3IEUKe@YKMP$}uEg zbK=3H?JMOG!*i&4aQ@DMC$lyxkHe7bN9XYPl1hFf5+2Qo z2ak?j4e|mn+bHwk{GAQYHML$}?C;L+p!}8ONsh+FgF)L?MWZRalt;IVU}&t3#9-`@ zF?b~m+2l%|#>Rs~y~zBrDZSlCE{5anh#Y1fsigefNOCkT9t`Tm<_HXxF#IPXL&%FP z@>-E_Xly(<)Qk4VC|);-~8tb%dSHIdqD z$je3;i^vsDjSV8F-q$OV7x3BavHnsxPYvU=KaMT>twPGo5_N)%bXfF}jw>cuGp< zWtj(yyw`Y;?3i5Xtnq9X5QExW8JTivsHXok5d*P8d@g|epRwTI^ z9}gDwX3Z)?V6#-i@>(w}wm03dEaMoGuQ~DH=@}oMHazzIf(7tw3g=niy)Ie{LlL=> zr?K(iP+yAO7a47i%i!4m+OR$o;!s=67ywHK$B=x@i3gARlK!mm#lG&o9G+>>c^r-s z7&alv)7W@$s4tr%aMZxDG&+aJmkjb-k??3vJa}}?&?0YWVYA!WLU>*dtWy%D;p>$|a3e@15T_^}#}0`i4L%FsK)qKlL-z!m#ai-u~^hC(DZp7`j~!jg1F~ zdXf5~;jpi%uZClEBo5b$EZ8?7$9gW8JQW^W{jK1W3Qy0$(F}lB01!WK=KLyky91#w9TBbbasrt^>wpzcajSC{9db#Xp2F_-@9>(V)F^vL9TFWY!Ers%d}Sv-6)0R@dt3e7lCs=`^3u<__~nfXk0wzeD!K$1cn=7*b<4s z@+zIYW+WUM8xIckqUlu%!e-y|`XL-6m-_padeKGsYsixvjf)3^dQrW`LGUot!Ej0> z2Fr_8FyxXe92y%B4)vnwHNzomCEad5r+z)+344{qY!6^fOjVe`!3j z%YGYW|Fx&=#vB<>+9-P=ITEii@hHF6ecl_U{Bl1}x7#Uy;*HvmLUmt9xl@UkSlu6w zvTNNZzG+Hqm%W~{ALS`~sP6MA`#QJ$8WWH5Yu$Ia<P>5#fwI}|gssKH7V@SOwmNboUSopDr{1l2%kbIr&t32({LtTT*1%Okyc6s0 z41t`@Fz;w4u1 z2a!#^%US1VyBoIuc-TVT6~mTDj__$r5c$-*A-^(wW#+;8dk=g?b^d-g5v~p-vAREq zZ0gg4{Kiziy*7FPhF8KFTn`e6 zZ$uKWF+uF->QU=^e!d6c+wtbGer|cx0bd6);w{npVFi3c$P-453nHU>nDKkVINdxre;ea_7;qumdG4C6%}#)9&B zGv-$E&L?MqC|;(L*NP-hV}r=4?^WyggYnYld<@QCMCCMttFU&%*+jnNYJ3n`)zh^f z7*@O8J`QX8t#-Thd)f(OJ-L#nu|eciPn$pVb2hq z)t?OOLi6DKeG1lfQCW?rbudmOSMoGAh@9$a@t^&itKdBG_P#x>hBJeFVb%B`vg(>4 zx6`o7Jw4r?hV_-mtj@Zq1ilpVBuC?d$f$m1{>6~ljL*Qhe|o>PLpPOwHu+Sy*c$vpRleQ9m1y^fNvW<4chlJ$`n=xtx4q)%YN? zs-LU=W>^=Q2j}k#u#UYmx}WRdTTGthXj~8()z1|l`x#qcY>Le2@v|Au3i5?joWDhUkKU-eTt6q~l~kXn zPT~%K&VPPFy=LgS%&D9)Acb;e6ECs4U+OWD|JU|>*Od1=;AH=HQTC7FdD)*7W&c>7 z*ZbtPJ;(QcmzDi|_;*c`p-j_=K#KQYG+~cYjn_Vw#@6W~i&(#aN zud~4D-*=gMeb>HTvq`9UU$S{{{=SIs-FhyouXj_fG~y*z_ix31&ydQ9h2L%NarJt4 zqw9g~_j&le`A1RudRf+hJlFPB{i%?7JztIIpX>P|^z|;vID$O!UgNf6?`KN=#KL>t z+Tt8ny(s!j&SYL=H2-3Ki5H*V?Rsy#IBwzT3;5w%bFEl|59#FPlb~_pg|wfGdges$ zoU3zYXuo&Pw4V>3GY3)+lB4ZAce5dr^6K_7j7QxQiP20ka(}rP#uRcTPh*3~sa~f4 z+tAssPyP(fYa(*G*ZuHqLXx9#L1a`fQ$F`Iw!-*MM8=Sp8PrWX5>AZ`BBy$}$>p@~ z<@_AZ5i26KS>t6YIjfQ6Xj~8()ywuTjF&d!D==OWkul`uW*AqJD|s3lL{9Z`b+_SU zsnoN*3g`O~IgOVa;9E+b;nIv6LC zD|s3lL{9axP!^MH)6IkP_ZM&$-{)zw9xtomOCwKmG%kpY>gB|*44lol7RHw&F})EG)mIO5QKwwAWntx{%~(To4)ceq+ive#SRo ztcc9$x@pFsbn2%a39H5jkyZWNZ`#s!g4{oG(k zobn2iY;7=p6`9fF=Vmw?$ro0Q4ia z^!J|9J5Sp867`-^+cxH0_PxZnsMo1_E^{hp446u}s)?6a-7oc+$p5d7axE+S<^FM` z{r3IiNc-*k$D#e+YhnBO@M~ece{9Eu-#@nZdG8;W$?0QqU*TQ%xIOdEwu9tU9>34W z@39Yf{dO9)+&?bs?{BDk?;~paTAOIjXM6rOo@eX%jOU&{luH?_$deq6+lsx>N})YnVD)&1kq>RPniT4_}6?;D+R^I>4^mI# z%5p8-f(Iq!IM>E*jQAkyg3vwS;M_Z2yrZA*UHESF^Lgf$lM0>5uuaZ9)>SF+t?hwMFt^Ki_-sl|SP3QB4%a4C-V(5=M;+BBOe^ z(PdmDCb`>hVSGP~QFaMm3h~WI;x#6SeClD_F2+NfuN}U^N27b#1>bV=BuC?d$fzD> zry554dbfl%(c8*6kr~lh0GIW1Efo2^QZ2ih^VrutzoRbK>3PgY$DMYPLzzm5mss5| zb(qNiuj%7jH`0FlS~t>u`&u`&-+QfVKOgN{*NzFl*0uMAUF*i|{SzCgFZ=c7jNSZR zm*VyFjc$7uuS1L9nWXpAbMG~ewyjmW`#paj&s+3-dOFS{<3lFpD*2hyR z-$Zi6ca7PKedi8wZ2I`0-Q%hc)x(Sr=gSG*?GN~H_v5bb_@FNk%2>M`4|2(oc#RPs zw&DLly1v!5SkYd7z7OF0!pCP;)WTQ;UpjfhsBuALR1b588^-CbfAa7ljD<~+JuHST zksOKFm>}}0ha>j(^L4=YypJ#B;Y9d0x{MkZL`L;+i_2)=XZjrJQx8|}>*wo)Z=sJbl;YjSDj4()|phypKS)zrgsZ z#n|(rJOR=d8{sP?PjWOah>W_{t4i}TegxxDPlej4G8!ihXB~_a$rVnG4I-zu*TVe` zr@V(ix4*)9O$1KaFJ4x|mqwoCXj~8()ys(^{frx7d?x~+$>a*B#s-m7uMvkG zU^p)nqulLpaE@5zw%HTsl$F;Q4|Cz_L=vm}gUF`yMt20Zk72vQ!xkD-M-aaT37^IU zkx#u_pKiP>Q{#C2JAChZ_>6a3;A$XVVs(EI+0?t{1O04WuuXc}ZkHkN+F`3DNBA@* zhi!_IsdrTe`Pn{!ZO>;Sdsh$JL~?{rV}i)1 z-c8LgeD>=Q|Aep3!{^R>a1A3~Vs(EI+0?ttgZ*rqU`u*7vUdfrb-R2T6J)-WLkyoi z-~9`|S`S~r0=YJlbxRiY(T*fuV}i)1YqL!e_&$a2!*D)#(ISkgmVM`}R;x#6SeCpxEEI(g2d>1_*)ZHX=qY0i z<0#6j+kar}v>0d4D4&1qoYKmLi{$%4r_7yqY-Odyil@1-wj;^c9R1Ap#Xav0@V<6$ zKOg?u{XkxSm7FQ=dx$$C@O%l+jxU5fi^Stv=rE;nj3y*Znimfy^=Q>tF)Ml zn6mm{l2Gxe6PCpsL-I8z9z5#Nk|X>)Ti`jb4<6g2W_SuXjxcFnJec%;QDwGavhQzx z1=ICWnT$6}VaOp@@-#Mx1TV)zi%Je$IsCgrpf!IYXZ2!P)JyYJ8AcyIod!51MX+ zU|kiNwP&)E_M1iS8YH!1Bl5 zSlmHWc(%Y&&oLxlbK=3H?XZ4=;c-5IB9+RvEj+vZBw~N_c+&<)3Hg$%@$q0$Z_1AH zvn0Zj-y4hN&2m_>IEL_OPCR&YEu8;7!(-2H+re{XWFBYTQ9=2KkS94B7v!-ad!nB) z3C7nWGrDe>F@LJm5Bb8X@j+x&KZhM{SnauOdsqkmG-6+K{LF!`6G@K71(8w5lf+4W z#$*`Ji_GZpa|HFX4hgHq2a#3BoAoZMeI2(0tc_u;lPk+h=S?o1QBmGAd^+AHliz?O zUvuIy-sm+#<1xlNn`cLO-tL1(O_ceq9iD2ABgfFZcrd9)HMxdKu32>338u|`FiEWN zG{KU`F(hAe;=!XHO+D7nlLF6vFM7w2@HS_Av>2XY97mWmFCI*~=FdLPFxm6m&M=)6 zmC1NhAay~mqJ?5INP;%@H_L;XG({wEh_KG=Qi36pJxa>fA5>e<5Lw(sT@nVG&dexI(B58Xt?Zo zZx6VJz7%cjpg&P|=}Y-=Y(bK%@j)It(oXWT4u$oC-dJ7tgg2YI>O#V+IYH!AZ&OY- zy!QOJC%ljJ#_M{UPF=Ml$<_EEvg&xVB?9X(SU>BH)$%r#{Iy7UH7AI?dL7>})!&x) zf;ac&@P0dYzI?z@+HV3mO-S0W#s!g4*Kcc2@iPvGacLw*%gas}>&X>PjSV8Fdf9ZU zzn|_6=ekIou9t1_)sQFcRpWxls9x5e=4TuM<32x&&|WPsSHW09u5fB>5INP$ngV~D z-3QK#!a3)a%hyUe{c<^cdE`lZ)wm!ss+T3F`x*Cz@tKH>#!MN17Q>iHu5fB>5INP$ zylMV6yC0liM&vYJmcf@wp0rnu3nHU>nR$kvF%8BOTEqIK(_TYf=EK1TVbrk`^poExHYhCCfc9kn50)%YN? zYTMoDvPxgm?EqNQf8M*NiR3jS$%a;m56&oZ9coau008kIBTX&0Og{B8Mgc+*~s)Rw*8Zh>676GUEpZ^hc_hF8{jx{ZOiGa|2ktAzJGJ?-$;a~wH_<^_>iUt4RP z;b$HTbLQ)j+OwBgCtvBuZ7|nyEaBGNAabkM&1Ht$ULPL;cXdCwrELiF8hC3tjvPbt zg2=31HFx{Zf-Z7;kM zC*IbRM?P3+enZ0f_SW&l_3yhpOC$cadD+FLj`=u8&o+TNzFE)dIi+bw8z^TAd6J`X zQm={p|Jt60vUSbWq+Q*C4IyzS_Y?_qaL^ zbhv)l?O-PDAmNRO?Z9aQGRF0xbPADrg4{Z$=ykj+Gn4=IUIAgqhAq zHv2awc-w=v!@BwYdEsc0_M`X}`Trh_v5c zCxrHU*9rFX(bfreO!zv%-sfE>%#7Lhy>D{c#i{Q5xKpc*FLt|_O}jX^t*>^`vt*bl zUsB$`w&9&G^nOCq0)N|>MB6CVGDK?|X4r7r#}GIQIgYds&D)CGhcwTa%pae+$JKEo z^D=+?xQO;Ka%meM zX&Ium4Qt$(3P&Bsk@lf^TXFl4OZ=F$k1yQgYQHUBUD=6=}Yt6N%#%|5+ zKrS+3(GC*bcA(=!qw9y=4lbn~ysv&lSVLOlgR|ECHseF?_5SuSh4!#P&+l&!p7EiH z@^8G(vfIJ-@#_c*ch|%Ad?Jq&;cQ*4!?p$EaQGk6+qp#fx!)Mx+35AS@^v%b06-$qWNjcn3#^wLIj zAdz;G0#5ynrH#nBo!3C%sNy(s49(k`+lP!}v1lK=x$Q&8k%C+O?c;LVN6l~h z(LStkMApsy8%MlzjgBLmZu7U1skD(rT8>`Yh&_%J!n2%XNjuTpt+|~X8KZWxhucnc zomg?Zzn#?3PV(C$x08ic<<2T(OuyfY7x}f2?s|W_IE8j`lAhPwE;y}w-<$F_kSpy# zW3?Sz-^aQm(tdm05oy1@?g;Jot~>1KqpdsanDBLny)SItF(xNQ?O>SO4sIJ(EAvvKQe8>ejVgA+QP?rUSC@< z^90M!4-j$AvoA54#;)K|6T+{eFxKW3#^1xR7>_zbzEd z7S`#xeQhB$E-a(mYwtGgLF2dP_AoO>?O{K+J!t>j=z21W^XYavo;3g7Z4a&|Qz{qC zuW&y?DdTiHdCf@jG*&5(eWYq5yNB8XXnE+@`DKD zgZWx>r_ZEQ59^WSX>5?khs_Z6wK{m|P_ z>7v%>>5Q*!aF&oSxf&mjF-OPHvd8=^(_xv{D@$k$T@FhY#}FRPi3g9i!>q>*k3GN5 zfMnXr!Q=xvM$dAAAHMvfu*niE7`^>*!(hS#3wX2E-9 zue`?F4mj({mt2hxBCC4a@|2&o0@gQsWes`T2I~@zA-tLsL|$FPG^{eb=TlzYX2Uz| zkCEH5#K^VJY8WfYl{}3NBB!?Dx~Kh|7s0t83a4?@u&#u&hXr`69G*6CuF zyIlbFjnf<58ZP)g+2F^_Kg;nE&$f};^Hyc)a z&bb8EJEO3wr)4k>Ay@J=Hi(?+Y4&q|&N*;?5QWqBbgI-5`NFF4L1a}=M?7y>?Rj-B ztfT%Mx&5lAIWTTSlBcmjQTW@{XEt1jPHZT_NW$~5gbRDG%p@Z zIyUCKXqfEzZUIcwqcWK_Od$-3f%BNZL>pg1o~Dw!1_`Ui2a#1h z?ReREYF|GtgtaaztMPOTj7{W9p2h}|Q$20_nV)kJoPUeT8S=Cf&gJ9_tHuYBRXuHP zHLP-Nq}vs+PWdQW`!$}fgRz!e$%a;m2dKlgJkhO;p$XUNkQI4j8)R*erLtFC#L zy<%AH`Skm+?)cYeo_fE>eW95(H_9^L|uBg~o? zL}vB4dW~VW=hv%XzPk@*@SOWUOJU9B7?Q6!LF84BD_-;S*24SOK6q`9Yv9f1IKr%X zL1r#~-QTXShBUHif{me^X-t}+& zXy2CCQ(;cwSi-HjLFCr8Nah=c+g?Xs2loZNb2}dA!P$)@SL1`os_i=MO+V}Pu)f$k zs}9=^a~Ad0g@jr2g2=4?rnDJmdrf@<%)>tJwOu=`>C{&{l3a}sBCGnF@Rpx-DXfcn zXZ84-N`18dJNv^8qs+^j;BDeK(!Mn>h|KDB`#L`}MgMO5 zt_HrVf&WKqppG%GyFX)|HP&}B=B;Ebk#SFRgE;Q#x^2y`%(z!=d3+Px=XUiv$2nvC z1~`|IFS!~YL{^>GTHf`u-VE#8y|a4OZEN9O!f}LI^Mc5%{;vGBVP0tYdkf6R{iAPx zSHoFFzT|3r5LwmVd%V2%6cUF(TjqsLn9AVbHATsMc(Td*~X8ZjMx5AwLiO=8g zTV+lkUIA-1$B=x@iO1{W>fyxq{5-e8b8a6zYNB)h51wR>BTSkX4<_{}<+p}O-g}_i z?J(8$!6dQ5lM72bl6=jH2akHx5rL;3p2z#(u{}!V7)?l+G%p@Z`kLU{cH@!UJJszD znBI%ZWW4Ewp`KjH)7T)67djs_|IW{OC!G8KGun7zT$6U#24^k#!m9B>WK~aByl+_L z9;t43!8$W4tMRl2#tL#JPh*3~sh%$Vy`OVAoXf@gTMX$ z2-XCCB+S_pdT(3A`K}JuJdWY?b2lf5ygJra{=v_CH@x|M@Y-YTVt8{njxcLp5Si8E z;t%}o`5u^;^}#HCT*j#?STi_=v}w%=BCmQ}@S&e~1-yUggV*-B1l|!GN0>D)h|D@R z=X4lm`+oAhFdy=-X#LoDTL@z!xss=`LFCl2IsK1*&imlJAu4BRY@P_`CYM#?gUG6$ zru@mU%DoTW?uWHADy#7{gF0$QlBcmjO4 z`)A{+eSP@=tc`xwGs>&0XU~}xdc(hr#am#l=NOW&Iq_KM>sY&@)6erDJa6~K;|{jY zIvAb`jw4K(7Y`=&sPZp{$-cgP2&T<_F;RZuX@Dh%V@ST{#DhmY%KgaCvl5>DKJ)c2 zZ=16`s)8ql;|P=H#e+%5#*DujCTHDAnPhtyrjw#GIo{;Kuo+37#s+!37`D;R`3Ri1 zMdx%~Gi@=Gdg?^Nt2sgBRbLbSW_V@YrQ4(Mz8{^}@pT0C)P^KaV}r=4W6Y)qoQ-fE zv^i>@^!S=c{%Rz=niE7`^|k$D676GUG1byb()wb!VR!#n!lQQNWOYa5J<$(1~f4I-!d+VBrQXA_*u zqH}tDZHBdyV+gP21etf)Cx+LaU!Q>Y)9AdO_a?1`wU}c_zUBmxSJy~O{^{p^65gXe zkJ^rX?@OwOw}9gav*rbnS=)5=Cc|vcwNJr(O<&CL$vSr_thpRR@--)jyy|hqzx=$b z;C-hrUbiO;a}B)N97mWnFNn|gjw@~$gCbO`NA;U^Wh6HpV}9*>+y0}3pj@4Yfcb( z)#I9OKW_`X_w>bUdAtGgiY7QBkp zEq!M-43*?cp2h}woT&TC&-pT(??&Ua#>ACy7LhNk8XrVf^|bnH!)niaKZAAnmr=$M z*VAP%=8`LU8XH7T9a~Di@pHDqIV&2cBi`7gmiABCC2jVjIIco$~7TDy(y& zu@WSn=D@fSNuI_AkyAZQ-qz2#2F`WSI4w`psH62rST#P#teag{dp>;)*0Ecnv|npI znnG?Xl3a}sBCD>4HYOThZPwReUDP|P>#k|b-S9SZ965&O1(8|X^7`!zvpu)|0_InG zXLkB+7n}{`ORmNTkyZU&o8)I*3+pal_1cy_{WK~a>>|j_Is-Zl- z32WZhQQ9&4#nT2D3&@o`jSV8FdRn!kpR*0lm!ff6o-T!RBKg9q@j+zO-;^ud$*|gU z&s(sL`^M|(X;tNOKyv)7hA)jg$nBr%A8^$XmFzTQy?Y0QUWO9X5V}r=4 zUZ(AAIPE$09XMZ)z^Pv5!qzfRu-KLP+fFxJr<8g0HUq4v6i}B26c^8)J zdu1{12~RsLRUAX|H76cC>P=Ou;j!;u{u-X9UU|&e*$Br(@+DW}-dZGi8XH7T9alCE zF`n9-?Qnh=h12#lf!t;!xf<RvmX*_AspWobWqXGq;J{PpzN8b^2=;tV=kCeet*^${4g7o+6GTOqv%DCiSRzPs3!-4Znw}rY|PSFFea&$>120 zuQ~DHQIE2Q`FS?L^H5(rmPaMgy(#*PaVLg!h8zybfmyd8?7+X>1TV zb&ToQ+xTj8cEI^~bWV@2n_+F@7?Q6!LF83m*N!l}7gAo`{s?b(7;nJ>^SihbBV%bN zjP>M7p2h}|Q`a)h`}jHk1n1d_-u|kbYO1id!C6bbuxfk|S=G}O`x@3VG0WZl4D0hz zSS3U_TVSjpSMoGAh@9%_(*69Lop27{u5V8p;4CCxST#P#tkr3T)t*=X0_&AgSnc~S zb#UgAFS!~YL{=Sx%l7xPegy05y|S7fEA6-j)+~-8yqXh4UTwz(BMq-T=lm7k!AX(Z zvF&XIoFmAWT#XMRt9qMzfS+|EtmpO08uGRf))bB*yqXh4UiCIJ-SFD;>)+sQjKW(m zcfRuyrL^NbIJ=SLYJ3n`)!PvV`dL4Qb^Gljw_{D)h|Joi+YUC&_PqN~ zm|yOb+4SKKSeJ7Q$=949@~X$JhxmCn!MoEAeYNS3$Lrv&<2b^sc|l~>YoW$N4YNJ} z{tMIoCEyp0@3j-h!$WY*ulT0h>;{58z)^@G_SqdQ=3;8?<~ zxk2Psuh-@nZhId72JU?a_tv((Ubn+r&vE1!nioW7^}2O}pE+TNgrtl6!EAfo26G+9 z5^l{6BDaoX%Z@VKV<@j~gWzuQb9=v2lwg^Y*T7oLF(hAe;_?0xZM$XP^Yd&2&)@pu zaZMDadU&!pjxcFnJebs@?1_eHoEpUAwlEFf#n&GrdQ>5G!Z9RYbK=3H9wi^`=ShU8 zpf4WFqa1kFyG)uF4<^0mu*qez=f~|}x;{FS(|=OPTa6@7V}m?ibWAed*_=smz8#%Y zhewBZGptP%a_Shk!mBw!=50LI-;Q^Hca@(v;`iyThP9ewNITY?AoA*%yW%)M?~d?x_r+_C zxlQm^a2#RQydW}bo35MeZ__)$oV%;9??&{v0oEdpA#GZ7g2<~L*XH?oQ{cU+FJ8;z zW$;erIKr%XL1wN#-rufwhWY*I%yL7i=VC?HdrRQWbIThv? z`onB_T?TVH#}aPM4I;PROUygb-^O=^J8^ek8@Im`&+)hz&Q$WHU2A+0S+!l~oaATS z4c4i>v%2n@cAXDzBF7PC%?l#4`kQ{Tzg_PRbA9j3j=vM(+=QepYkUw{)!$)L{j5V^ z{bTQ}9)B~auTCV)nioW7y>3c4#W35i^Xvih=pj-1FI+M{kD#vFkmPA>5IMCScSYbF z3g=DHIIS@`k=zy}tQsFgR`qoKsm4?LHIF@E?TW_gdb$b52681&V}r=4p0=Lm=NtxS z!5&fCuH|VvoOR?2tHuYBRXuGiFsutGuWoz6+8m9QAnB)TV5}xr@-#Mxoa$-)>3+`P za2`CgZ%>=xEFoW5H9m-}>gnQXhINq|%H!U!-WQFP{o?6z81u=MJdF(^r+Qj(hM#i; zoWu6)+tXS&v&k1$jSnKL-peQ|G_10|(`_GEZ;Qqny5e)Zt%Nn5V@ST{1d&&-dkW6< z^X?1p`+f6z)=kAQkKkCst+_$uR-bdvGTgGx(``SvM-Ge9ro((Lgf)d@NWSI-kym}r zIor>h2JhUyc|AVo!JNpkgj;ii$gN{ndXeF_*T?(Ay}CDU*kqiZ2OjJ)IYH!AZxhZny!JZz0C*Sm#_M`JjJj$=lB@ASWL0lB zMPN;b^@HA6EpHRaUyX!UbArgL-flS0cx$hh4}|x);k~qF*W1l-Hj*#78XrVf^|r0p z&pHa$7kXp0yzPK>ImZxQ%?To}dfRfo;kDPz2f>@Uci-NwgL4V_lB@ASWL0k)FYvQw z!1_pUtd_T{VXfvE!mBw!tWNaounICIID zT#b*%drj24yb?dlA+Sv8mBpARJTstD$Nt`?L*c3HmB*}w^5NKk zBv<3(!J^)DL}1B;<*r^?Lf#A^zX=JC=EQ?X?$A{(_e$LTw?zm6n@xdJm9o9BDYsnW@jSnKLdb*;_u-ey{hr>E83afhB0%HZa zlBcmj3(otaaN3?Wz*$JXuxfmeSqo_VC`4u|7IqkO& z&NT8RSL5R`=I9ujKFiNC_Wv+mMJCgh3HPmyskSNeE#igd`da!lZ^ue@0D& zkR&1QAcPRYAcPP?2qA$H ze6Uz=X7+Wx30d01(mNMR(3|D3jH8C~Ehis5_B+TY_j5eq^=%J$u8!wP^<);~uOv@7 z7Poalabs2L&z~Sd*a`~{>d~TYi?(b$Gsg7S3krq}8BoxiJpCT<@c)NYoHeXsXjS)K zLwXGy%GcH`Xi(6mps?_@1HO6Xu@gQxY{vHMuKCOZ)5`f0>r>}~b|}BPi+zhVig^4( z1Ac!nIX3^Q`$rk~gz*`}#xrL0b2yx>$rr1|Cy~|Go3;ZTYj|DT8`kOZtl_WSP4%`9 ztSi}-Z#i}@p1JB=%{&*w|Ns9w7wxkkg@d9z`@r*Q9X!@VT@%`KOy;tS$@22SWIdYa znZj$rzAzOQ$DVVM9yKI?61(y(Cm%f4qng34MW?mwo$(34!{S!@#53tJmUoE7EVAI>|oa=NbRyc#b~^2KWLNo2L2 z_8H<>!)x6Euzr)3)%A2FjBUwPp2a4S(|X!{Xq2-A&b_wHw!Wl$+854dE!DI7q`Y_j<@VamiJacpMxN~kP9HYrsuEpnr#d

    • 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