1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 package org.codelibs.fess.opensearch.config.cbean.ca.bs;
17
18 import org.codelibs.fess.opensearch.config.allcommon.EsAbstractConditionAggregation;
19 import org.codelibs.fess.opensearch.config.allcommon.EsAbstractConditionQuery;
20 import org.codelibs.fess.opensearch.config.cbean.ca.LabelTypeCA;
21 import org.codelibs.fess.opensearch.config.cbean.cq.LabelTypeCQ;
22 import org.codelibs.fess.opensearch.config.cbean.cq.bs.BsLabelTypeCQ;
23 import org.opensearch.search.aggregations.bucket.filter.FilterAggregationBuilder;
24 import org.opensearch.search.aggregations.bucket.global.GlobalAggregationBuilder;
25 import org.opensearch.search.aggregations.bucket.histogram.HistogramAggregationBuilder;
26 import org.opensearch.search.aggregations.bucket.missing.MissingAggregationBuilder;
27 import org.opensearch.search.aggregations.bucket.range.IpRangeAggregationBuilder;
28 import org.opensearch.search.aggregations.bucket.range.RangeAggregationBuilder;
29 import org.opensearch.search.aggregations.bucket.sampler.SamplerAggregationBuilder;
30 import org.opensearch.search.aggregations.bucket.terms.SignificantTermsAggregationBuilder;
31 import org.opensearch.search.aggregations.bucket.terms.TermsAggregationBuilder;
32 import org.opensearch.search.aggregations.metrics.AvgAggregationBuilder;
33 import org.opensearch.search.aggregations.metrics.CardinalityAggregationBuilder;
34 import org.opensearch.search.aggregations.metrics.ExtendedStatsAggregationBuilder;
35 import org.opensearch.search.aggregations.metrics.MaxAggregationBuilder;
36 import org.opensearch.search.aggregations.metrics.MinAggregationBuilder;
37 import org.opensearch.search.aggregations.metrics.PercentileRanksAggregationBuilder;
38 import org.opensearch.search.aggregations.metrics.PercentilesAggregationBuilder;
39 import org.opensearch.search.aggregations.metrics.ScriptedMetricAggregationBuilder;
40 import org.opensearch.search.aggregations.metrics.StatsAggregationBuilder;
41 import org.opensearch.search.aggregations.metrics.SumAggregationBuilder;
42 import org.opensearch.search.aggregations.metrics.TopHitsAggregationBuilder;
43 import org.opensearch.search.aggregations.metrics.ValueCountAggregationBuilder;
44
45
46
47
48 public abstract class BsLabelTypeCA extends EsAbstractConditionAggregation {
49
50
51
52
53
54 public void filter(String name, EsAbstractConditionQuery.OperatorCall<BsLabelTypeCQ> queryLambda,
55 ConditionOptionCall<FilterAggregationBuilder> opLambda, OperatorCall<BsLabelTypeCA> aggsLambda) {
56 LabelTypeCQ cq = new LabelTypeCQ();
57 if (queryLambda != null) {
58 queryLambda.callback(cq);
59 }
60 FilterAggregationBuilder builder = regFilterA(name, cq.getQuery());
61 if (opLambda != null) {
62 opLambda.callback(builder);
63 }
64 if (aggsLambda != null) {
65 LabelTypeCA ca = new LabelTypeCA();
66 aggsLambda.callback(ca);
67 ca.getAggregationBuilderList().forEach(builder::subAggregation);
68 }
69 }
70
71 public void global(String name, ConditionOptionCall<GlobalAggregationBuilder> opLambda, OperatorCall<BsLabelTypeCA> aggsLambda) {
72 GlobalAggregationBuilder builder = regGlobalA(name);
73 if (opLambda != null) {
74 opLambda.callback(builder);
75 }
76 if (aggsLambda != null) {
77 LabelTypeCA ca = new LabelTypeCA();
78 aggsLambda.callback(ca);
79 ca.getAggregationBuilderList().forEach(builder::subAggregation);
80 }
81 }
82
83 public void sampler(String name, ConditionOptionCall<SamplerAggregationBuilder> opLambda, OperatorCall<BsLabelTypeCA> aggsLambda) {
84 SamplerAggregationBuilder builder = regSamplerA(name);
85 if (opLambda != null) {
86 opLambda.callback(builder);
87 }
88 if (aggsLambda != null) {
89 LabelTypeCA ca = new LabelTypeCA();
90 aggsLambda.callback(ca);
91 ca.getAggregationBuilderList().forEach(builder::subAggregation);
92 }
93 }
94
95 public void scriptedMetric(String name, ConditionOptionCall<ScriptedMetricAggregationBuilder> opLambda) {
96 ScriptedMetricAggregationBuilder builder = regScriptedMetricA(name);
97 if (opLambda != null) {
98 opLambda.callback(builder);
99 }
100 }
101
102 public void topHits(String name, ConditionOptionCall<TopHitsAggregationBuilder> opLambda) {
103 TopHitsAggregationBuilder builder = regTopHitsA(name);
104 if (opLambda != null) {
105 opLambda.callback(builder);
106 }
107 }
108
109 public void setCreatedBy_Terms() {
110 setCreatedBy_Terms(null);
111 }
112
113 public void setCreatedBy_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda) {
114 setCreatedBy_Terms("createdBy", opLambda, null);
115 }
116
117 public void setCreatedBy_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda, OperatorCall<BsLabelTypeCA> aggsLambda) {
118 setCreatedBy_Terms("createdBy", opLambda, aggsLambda);
119 }
120
121 public void setCreatedBy_Terms(String name, ConditionOptionCall<TermsAggregationBuilder> opLambda,
122 OperatorCall<BsLabelTypeCA> aggsLambda) {
123 TermsAggregationBuilder builder = regTermsA(name, "createdBy");
124 if (opLambda != null) {
125 opLambda.callback(builder);
126 }
127 if (aggsLambda != null) {
128 LabelTypeCA ca = new LabelTypeCA();
129 aggsLambda.callback(ca);
130 ca.getAggregationBuilderList().forEach(builder::subAggregation);
131 }
132 }
133
134 public void setCreatedBy_SignificantTerms() {
135 setCreatedBy_SignificantTerms(null);
136 }
137
138 public void setCreatedBy_SignificantTerms(ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda) {
139 setCreatedBy_SignificantTerms("createdBy", opLambda, null);
140 }
141
142 public void setCreatedBy_SignificantTerms(ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda,
143 OperatorCall<BsLabelTypeCA> aggsLambda) {
144 setCreatedBy_SignificantTerms("createdBy", opLambda, aggsLambda);
145 }
146
147 public void setCreatedBy_SignificantTerms(String name, ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda,
148 OperatorCall<BsLabelTypeCA> aggsLambda) {
149 SignificantTermsAggregationBuilder builder = regSignificantTermsA(name, "createdBy");
150 if (opLambda != null) {
151 opLambda.callback(builder);
152 }
153 if (aggsLambda != null) {
154 LabelTypeCA ca = new LabelTypeCA();
155 aggsLambda.callback(ca);
156 ca.getAggregationBuilderList().forEach(builder::subAggregation);
157 }
158 }
159
160 public void setCreatedBy_IpRange() {
161 setCreatedBy_IpRange(null);
162 }
163
164 public void setCreatedBy_IpRange(ConditionOptionCall<IpRangeAggregationBuilder> opLambda) {
165 setCreatedBy_IpRange("createdBy", opLambda, null);
166 }
167
168 public void setCreatedBy_IpRange(ConditionOptionCall<IpRangeAggregationBuilder> opLambda, OperatorCall<BsLabelTypeCA> aggsLambda) {
169 setCreatedBy_IpRange("createdBy", opLambda, aggsLambda);
170 }
171
172 public void setCreatedBy_IpRange(String name, ConditionOptionCall<IpRangeAggregationBuilder> opLambda,
173 OperatorCall<BsLabelTypeCA> aggsLambda) {
174 IpRangeAggregationBuilder builder = regIpRangeA(name, "createdBy");
175 if (opLambda != null) {
176 opLambda.callback(builder);
177 }
178 if (aggsLambda != null) {
179 LabelTypeCA ca = new LabelTypeCA();
180 aggsLambda.callback(ca);
181 ca.getAggregationBuilderList().forEach(builder::subAggregation);
182 }
183 }
184
185 public void setCreatedBy_Count() {
186 setCreatedBy_Count(null);
187 }
188
189 public void setCreatedBy_Count(ConditionOptionCall<ValueCountAggregationBuilder> opLambda) {
190 setCreatedBy_Count("createdBy", opLambda);
191 }
192
193 public void setCreatedBy_Count(String name, ConditionOptionCall<ValueCountAggregationBuilder> opLambda) {
194 ValueCountAggregationBuilder builder = regCountA(name, "createdBy");
195 if (opLambda != null) {
196 opLambda.callback(builder);
197 }
198 }
199
200 public void setCreatedBy_Cardinality() {
201 setCreatedBy_Cardinality(null);
202 }
203
204 public void setCreatedBy_Cardinality(ConditionOptionCall<CardinalityAggregationBuilder> opLambda) {
205 setCreatedBy_Cardinality("createdBy", opLambda);
206 }
207
208 public void setCreatedBy_Cardinality(String name, ConditionOptionCall<CardinalityAggregationBuilder> opLambda) {
209 CardinalityAggregationBuilder builder = regCardinalityA(name, "createdBy");
210 if (opLambda != null) {
211 opLambda.callback(builder);
212 }
213 }
214
215 public void setCreatedBy_Missing() {
216 setCreatedBy_Missing(null);
217 }
218
219 public void setCreatedBy_Missing(ConditionOptionCall<MissingAggregationBuilder> opLambda) {
220 setCreatedBy_Missing("createdBy", opLambda, null);
221 }
222
223 public void setCreatedBy_Missing(ConditionOptionCall<MissingAggregationBuilder> opLambda, OperatorCall<BsLabelTypeCA> aggsLambda) {
224 setCreatedBy_Missing("createdBy", opLambda, aggsLambda);
225 }
226
227 public void setCreatedBy_Missing(String name, ConditionOptionCall<MissingAggregationBuilder> opLambda,
228 OperatorCall<BsLabelTypeCA> aggsLambda) {
229 MissingAggregationBuilder builder = regMissingA(name, "createdBy");
230 if (opLambda != null) {
231 opLambda.callback(builder);
232 }
233 if (aggsLambda != null) {
234 LabelTypeCA ca = new LabelTypeCA();
235 aggsLambda.callback(ca);
236 ca.getAggregationBuilderList().forEach(builder::subAggregation);
237 }
238 }
239
240 public void setCreatedTime_Avg() {
241 setCreatedTime_Avg(null);
242 }
243
244 public void setCreatedTime_Avg(ConditionOptionCall<AvgAggregationBuilder> opLambda) {
245 setCreatedTime_Avg("createdTime", opLambda);
246 }
247
248 public void setCreatedTime_Avg(String name, ConditionOptionCall<AvgAggregationBuilder> opLambda) {
249 AvgAggregationBuilder builder = regAvgA(name, "createdTime");
250 if (opLambda != null) {
251 opLambda.callback(builder);
252 }
253 }
254
255 public void setCreatedTime_Max() {
256 setCreatedTime_Max(null);
257 }
258
259 public void setCreatedTime_Max(ConditionOptionCall<MaxAggregationBuilder> opLambda) {
260 setCreatedTime_Max("createdTime", opLambda);
261 }
262
263 public void setCreatedTime_Max(String name, ConditionOptionCall<MaxAggregationBuilder> opLambda) {
264 MaxAggregationBuilder builder = regMaxA(name, "createdTime");
265 if (opLambda != null) {
266 opLambda.callback(builder);
267 }
268 }
269
270 public void setCreatedTime_Min() {
271 setCreatedTime_Min(null);
272 }
273
274 public void setCreatedTime_Min(ConditionOptionCall<MinAggregationBuilder> opLambda) {
275 setCreatedTime_Min("createdTime", opLambda);
276 }
277
278 public void setCreatedTime_Min(String name, ConditionOptionCall<MinAggregationBuilder> opLambda) {
279 MinAggregationBuilder builder = regMinA(name, "createdTime");
280 if (opLambda != null) {
281 opLambda.callback(builder);
282 }
283 }
284
285 public void setCreatedTime_Sum() {
286 setCreatedTime_Sum(null);
287 }
288
289 public void setCreatedTime_Sum(ConditionOptionCall<SumAggregationBuilder> opLambda) {
290 setCreatedTime_Sum("createdTime", opLambda);
291 }
292
293 public void setCreatedTime_Sum(String name, ConditionOptionCall<SumAggregationBuilder> opLambda) {
294 SumAggregationBuilder builder = regSumA(name, "createdTime");
295 if (opLambda != null) {
296 opLambda.callback(builder);
297 }
298 }
299
300 public void setCreatedTime_ExtendedStats() {
301 setCreatedTime_ExtendedStats(null);
302 }
303
304 public void setCreatedTime_ExtendedStats(ConditionOptionCall<ExtendedStatsAggregationBuilder> opLambda) {
305 setCreatedTime_ExtendedStats("createdTime", opLambda);
306 }
307
308 public void setCreatedTime_ExtendedStats(String name, ConditionOptionCall<ExtendedStatsAggregationBuilder> opLambda) {
309 ExtendedStatsAggregationBuilder builder = regExtendedStatsA(name, "createdTime");
310 if (opLambda != null) {
311 opLambda.callback(builder);
312 }
313 }
314
315 public void setCreatedTime_Stats() {
316 setCreatedTime_Stats(null);
317 }
318
319 public void setCreatedTime_Stats(ConditionOptionCall<StatsAggregationBuilder> opLambda) {
320 setCreatedTime_Stats("createdTime", opLambda);
321 }
322
323 public void setCreatedTime_Stats(String name, ConditionOptionCall<StatsAggregationBuilder> opLambda) {
324 StatsAggregationBuilder builder = regStatsA(name, "createdTime");
325 if (opLambda != null) {
326 opLambda.callback(builder);
327 }
328 }
329
330 public void setCreatedTime_Percentiles() {
331 setCreatedTime_Percentiles(null);
332 }
333
334 public void setCreatedTime_Percentiles(ConditionOptionCall<PercentilesAggregationBuilder> opLambda) {
335 setCreatedTime_Percentiles("createdTime", opLambda);
336 }
337
338 public void setCreatedTime_Percentiles(String name, ConditionOptionCall<PercentilesAggregationBuilder> opLambda) {
339 PercentilesAggregationBuilder builder = regPercentilesA(name, "createdTime");
340 if (opLambda != null) {
341 opLambda.callback(builder);
342 }
343 }
344
345 public void setCreatedTime_PercentileRanks(double[] values) {
346 setCreatedTime_PercentileRanks(values, null);
347 }
348
349 public void setCreatedTime_PercentileRanks(double[] values, ConditionOptionCall<PercentileRanksAggregationBuilder> opLambda) {
350 setCreatedTime_PercentileRanks("createdTime", values, opLambda);
351 }
352
353 public void setCreatedTime_PercentileRanks(String name, double[] values,
354 ConditionOptionCall<PercentileRanksAggregationBuilder> opLambda) {
355 PercentileRanksAggregationBuilder builder = regPercentileRanksA(name, "createdTime", values);
356 if (opLambda != null) {
357 opLambda.callback(builder);
358 }
359 }
360
361 public void setCreatedTime_Histogram() {
362 setCreatedTime_Histogram(null);
363 }
364
365 public void setCreatedTime_Histogram(ConditionOptionCall<HistogramAggregationBuilder> opLambda) {
366 setCreatedTime_Histogram("createdTime", opLambda, null);
367 }
368
369 public void setCreatedTime_Histogram(ConditionOptionCall<HistogramAggregationBuilder> opLambda,
370 OperatorCall<BsLabelTypeCA> aggsLambda) {
371 setCreatedTime_Histogram("createdTime", opLambda, aggsLambda);
372 }
373
374 public void setCreatedTime_Histogram(String name, ConditionOptionCall<HistogramAggregationBuilder> opLambda,
375 OperatorCall<BsLabelTypeCA> aggsLambda) {
376 HistogramAggregationBuilder builder = regHistogramA(name, "createdTime");
377 if (opLambda != null) {
378 opLambda.callback(builder);
379 }
380 if (aggsLambda != null) {
381 LabelTypeCA ca = new LabelTypeCA();
382 aggsLambda.callback(ca);
383 ca.getAggregationBuilderList().forEach(builder::subAggregation);
384 }
385 }
386
387 public void setCreatedTime_Range() {
388 setCreatedTime_Range(null);
389 }
390
391 public void setCreatedTime_Range(ConditionOptionCall<RangeAggregationBuilder> opLambda) {
392 setCreatedTime_Range("createdTime", opLambda, null);
393 }
394
395 public void setCreatedTime_Range(ConditionOptionCall<RangeAggregationBuilder> opLambda, OperatorCall<BsLabelTypeCA> aggsLambda) {
396 setCreatedTime_Range("createdTime", opLambda, aggsLambda);
397 }
398
399 public void setCreatedTime_Range(String name, ConditionOptionCall<RangeAggregationBuilder> opLambda,
400 OperatorCall<BsLabelTypeCA> aggsLambda) {
401 RangeAggregationBuilder builder = regRangeA(name, "createdTime");
402 if (opLambda != null) {
403 opLambda.callback(builder);
404 }
405 if (aggsLambda != null) {
406 LabelTypeCA ca = new LabelTypeCA();
407 aggsLambda.callback(ca);
408 ca.getAggregationBuilderList().forEach(builder::subAggregation);
409 }
410 }
411
412 public void setCreatedTime_Count() {
413 setCreatedTime_Count(null);
414 }
415
416 public void setCreatedTime_Count(ConditionOptionCall<ValueCountAggregationBuilder> opLambda) {
417 setCreatedTime_Count("createdTime", opLambda);
418 }
419
420 public void setCreatedTime_Count(String name, ConditionOptionCall<ValueCountAggregationBuilder> opLambda) {
421 ValueCountAggregationBuilder builder = regCountA(name, "createdTime");
422 if (opLambda != null) {
423 opLambda.callback(builder);
424 }
425 }
426
427 public void setCreatedTime_Cardinality() {
428 setCreatedTime_Cardinality(null);
429 }
430
431 public void setCreatedTime_Cardinality(ConditionOptionCall<CardinalityAggregationBuilder> opLambda) {
432 setCreatedTime_Cardinality("createdTime", opLambda);
433 }
434
435 public void setCreatedTime_Cardinality(String name, ConditionOptionCall<CardinalityAggregationBuilder> opLambda) {
436 CardinalityAggregationBuilder builder = regCardinalityA(name, "createdTime");
437 if (opLambda != null) {
438 opLambda.callback(builder);
439 }
440 }
441
442 public void setCreatedTime_Missing() {
443 setCreatedTime_Missing(null);
444 }
445
446 public void setCreatedTime_Missing(ConditionOptionCall<MissingAggregationBuilder> opLambda) {
447 setCreatedTime_Missing("createdTime", opLambda, null);
448 }
449
450 public void setCreatedTime_Missing(ConditionOptionCall<MissingAggregationBuilder> opLambda, OperatorCall<BsLabelTypeCA> aggsLambda) {
451 setCreatedTime_Missing("createdTime", opLambda, aggsLambda);
452 }
453
454 public void setCreatedTime_Missing(String name, ConditionOptionCall<MissingAggregationBuilder> opLambda,
455 OperatorCall<BsLabelTypeCA> aggsLambda) {
456 MissingAggregationBuilder builder = regMissingA(name, "createdTime");
457 if (opLambda != null) {
458 opLambda.callback(builder);
459 }
460 if (aggsLambda != null) {
461 LabelTypeCA ca = new LabelTypeCA();
462 aggsLambda.callback(ca);
463 ca.getAggregationBuilderList().forEach(builder::subAggregation);
464 }
465 }
466
467 public void setExcludedPaths_Terms() {
468 setExcludedPaths_Terms(null);
469 }
470
471 public void setExcludedPaths_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda) {
472 setExcludedPaths_Terms("excludedPaths", opLambda, null);
473 }
474
475 public void setExcludedPaths_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda, OperatorCall<BsLabelTypeCA> aggsLambda) {
476 setExcludedPaths_Terms("excludedPaths", opLambda, aggsLambda);
477 }
478
479 public void setExcludedPaths_Terms(String name, ConditionOptionCall<TermsAggregationBuilder> opLambda,
480 OperatorCall<BsLabelTypeCA> aggsLambda) {
481 TermsAggregationBuilder builder = regTermsA(name, "excludedPaths");
482 if (opLambda != null) {
483 opLambda.callback(builder);
484 }
485 if (aggsLambda != null) {
486 LabelTypeCA ca = new LabelTypeCA();
487 aggsLambda.callback(ca);
488 ca.getAggregationBuilderList().forEach(builder::subAggregation);
489 }
490 }
491
492 public void setExcludedPaths_SignificantTerms() {
493 setExcludedPaths_SignificantTerms(null);
494 }
495
496 public void setExcludedPaths_SignificantTerms(ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda) {
497 setExcludedPaths_SignificantTerms("excludedPaths", opLambda, null);
498 }
499
500 public void setExcludedPaths_SignificantTerms(ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda,
501 OperatorCall<BsLabelTypeCA> aggsLambda) {
502 setExcludedPaths_SignificantTerms("excludedPaths", opLambda, aggsLambda);
503 }
504
505 public void setExcludedPaths_SignificantTerms(String name, ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda,
506 OperatorCall<BsLabelTypeCA> aggsLambda) {
507 SignificantTermsAggregationBuilder builder = regSignificantTermsA(name, "excludedPaths");
508 if (opLambda != null) {
509 opLambda.callback(builder);
510 }
511 if (aggsLambda != null) {
512 LabelTypeCA ca = new LabelTypeCA();
513 aggsLambda.callback(ca);
514 ca.getAggregationBuilderList().forEach(builder::subAggregation);
515 }
516 }
517
518 public void setExcludedPaths_IpRange() {
519 setExcludedPaths_IpRange(null);
520 }
521
522 public void setExcludedPaths_IpRange(ConditionOptionCall<IpRangeAggregationBuilder> opLambda) {
523 setExcludedPaths_IpRange("excludedPaths", opLambda, null);
524 }
525
526 public void setExcludedPaths_IpRange(ConditionOptionCall<IpRangeAggregationBuilder> opLambda, OperatorCall<BsLabelTypeCA> aggsLambda) {
527 setExcludedPaths_IpRange("excludedPaths", opLambda, aggsLambda);
528 }
529
530 public void setExcludedPaths_IpRange(String name, ConditionOptionCall<IpRangeAggregationBuilder> opLambda,
531 OperatorCall<BsLabelTypeCA> aggsLambda) {
532 IpRangeAggregationBuilder builder = regIpRangeA(name, "excludedPaths");
533 if (opLambda != null) {
534 opLambda.callback(builder);
535 }
536 if (aggsLambda != null) {
537 LabelTypeCA ca = new LabelTypeCA();
538 aggsLambda.callback(ca);
539 ca.getAggregationBuilderList().forEach(builder::subAggregation);
540 }
541 }
542
543 public void setExcludedPaths_Count() {
544 setExcludedPaths_Count(null);
545 }
546
547 public void setExcludedPaths_Count(ConditionOptionCall<ValueCountAggregationBuilder> opLambda) {
548 setExcludedPaths_Count("excludedPaths", opLambda);
549 }
550
551 public void setExcludedPaths_Count(String name, ConditionOptionCall<ValueCountAggregationBuilder> opLambda) {
552 ValueCountAggregationBuilder builder = regCountA(name, "excludedPaths");
553 if (opLambda != null) {
554 opLambda.callback(builder);
555 }
556 }
557
558 public void setExcludedPaths_Cardinality() {
559 setExcludedPaths_Cardinality(null);
560 }
561
562 public void setExcludedPaths_Cardinality(ConditionOptionCall<CardinalityAggregationBuilder> opLambda) {
563 setExcludedPaths_Cardinality("excludedPaths", opLambda);
564 }
565
566 public void setExcludedPaths_Cardinality(String name, ConditionOptionCall<CardinalityAggregationBuilder> opLambda) {
567 CardinalityAggregationBuilder builder = regCardinalityA(name, "excludedPaths");
568 if (opLambda != null) {
569 opLambda.callback(builder);
570 }
571 }
572
573 public void setExcludedPaths_Missing() {
574 setExcludedPaths_Missing(null);
575 }
576
577 public void setExcludedPaths_Missing(ConditionOptionCall<MissingAggregationBuilder> opLambda) {
578 setExcludedPaths_Missing("excludedPaths", opLambda, null);
579 }
580
581 public void setExcludedPaths_Missing(ConditionOptionCall<MissingAggregationBuilder> opLambda, OperatorCall<BsLabelTypeCA> aggsLambda) {
582 setExcludedPaths_Missing("excludedPaths", opLambda, aggsLambda);
583 }
584
585 public void setExcludedPaths_Missing(String name, ConditionOptionCall<MissingAggregationBuilder> opLambda,
586 OperatorCall<BsLabelTypeCA> aggsLambda) {
587 MissingAggregationBuilder builder = regMissingA(name, "excludedPaths");
588 if (opLambda != null) {
589 opLambda.callback(builder);
590 }
591 if (aggsLambda != null) {
592 LabelTypeCA ca = new LabelTypeCA();
593 aggsLambda.callback(ca);
594 ca.getAggregationBuilderList().forEach(builder::subAggregation);
595 }
596 }
597
598 public void setIncludedPaths_Terms() {
599 setIncludedPaths_Terms(null);
600 }
601
602 public void setIncludedPaths_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda) {
603 setIncludedPaths_Terms("includedPaths", opLambda, null);
604 }
605
606 public void setIncludedPaths_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda, OperatorCall<BsLabelTypeCA> aggsLambda) {
607 setIncludedPaths_Terms("includedPaths", opLambda, aggsLambda);
608 }
609
610 public void setIncludedPaths_Terms(String name, ConditionOptionCall<TermsAggregationBuilder> opLambda,
611 OperatorCall<BsLabelTypeCA> aggsLambda) {
612 TermsAggregationBuilder builder = regTermsA(name, "includedPaths");
613 if (opLambda != null) {
614 opLambda.callback(builder);
615 }
616 if (aggsLambda != null) {
617 LabelTypeCA ca = new LabelTypeCA();
618 aggsLambda.callback(ca);
619 ca.getAggregationBuilderList().forEach(builder::subAggregation);
620 }
621 }
622
623 public void setIncludedPaths_SignificantTerms() {
624 setIncludedPaths_SignificantTerms(null);
625 }
626
627 public void setIncludedPaths_SignificantTerms(ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda) {
628 setIncludedPaths_SignificantTerms("includedPaths", opLambda, null);
629 }
630
631 public void setIncludedPaths_SignificantTerms(ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda,
632 OperatorCall<BsLabelTypeCA> aggsLambda) {
633 setIncludedPaths_SignificantTerms("includedPaths", opLambda, aggsLambda);
634 }
635
636 public void setIncludedPaths_SignificantTerms(String name, ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda,
637 OperatorCall<BsLabelTypeCA> aggsLambda) {
638 SignificantTermsAggregationBuilder builder = regSignificantTermsA(name, "includedPaths");
639 if (opLambda != null) {
640 opLambda.callback(builder);
641 }
642 if (aggsLambda != null) {
643 LabelTypeCA ca = new LabelTypeCA();
644 aggsLambda.callback(ca);
645 ca.getAggregationBuilderList().forEach(builder::subAggregation);
646 }
647 }
648
649 public void setIncludedPaths_IpRange() {
650 setIncludedPaths_IpRange(null);
651 }
652
653 public void setIncludedPaths_IpRange(ConditionOptionCall<IpRangeAggregationBuilder> opLambda) {
654 setIncludedPaths_IpRange("includedPaths", opLambda, null);
655 }
656
657 public void setIncludedPaths_IpRange(ConditionOptionCall<IpRangeAggregationBuilder> opLambda, OperatorCall<BsLabelTypeCA> aggsLambda) {
658 setIncludedPaths_IpRange("includedPaths", opLambda, aggsLambda);
659 }
660
661 public void setIncludedPaths_IpRange(String name, ConditionOptionCall<IpRangeAggregationBuilder> opLambda,
662 OperatorCall<BsLabelTypeCA> aggsLambda) {
663 IpRangeAggregationBuilder builder = regIpRangeA(name, "includedPaths");
664 if (opLambda != null) {
665 opLambda.callback(builder);
666 }
667 if (aggsLambda != null) {
668 LabelTypeCA ca = new LabelTypeCA();
669 aggsLambda.callback(ca);
670 ca.getAggregationBuilderList().forEach(builder::subAggregation);
671 }
672 }
673
674 public void setIncludedPaths_Count() {
675 setIncludedPaths_Count(null);
676 }
677
678 public void setIncludedPaths_Count(ConditionOptionCall<ValueCountAggregationBuilder> opLambda) {
679 setIncludedPaths_Count("includedPaths", opLambda);
680 }
681
682 public void setIncludedPaths_Count(String name, ConditionOptionCall<ValueCountAggregationBuilder> opLambda) {
683 ValueCountAggregationBuilder builder = regCountA(name, "includedPaths");
684 if (opLambda != null) {
685 opLambda.callback(builder);
686 }
687 }
688
689 public void setIncludedPaths_Cardinality() {
690 setIncludedPaths_Cardinality(null);
691 }
692
693 public void setIncludedPaths_Cardinality(ConditionOptionCall<CardinalityAggregationBuilder> opLambda) {
694 setIncludedPaths_Cardinality("includedPaths", opLambda);
695 }
696
697 public void setIncludedPaths_Cardinality(String name, ConditionOptionCall<CardinalityAggregationBuilder> opLambda) {
698 CardinalityAggregationBuilder builder = regCardinalityA(name, "includedPaths");
699 if (opLambda != null) {
700 opLambda.callback(builder);
701 }
702 }
703
704 public void setIncludedPaths_Missing() {
705 setIncludedPaths_Missing(null);
706 }
707
708 public void setIncludedPaths_Missing(ConditionOptionCall<MissingAggregationBuilder> opLambda) {
709 setIncludedPaths_Missing("includedPaths", opLambda, null);
710 }
711
712 public void setIncludedPaths_Missing(ConditionOptionCall<MissingAggregationBuilder> opLambda, OperatorCall<BsLabelTypeCA> aggsLambda) {
713 setIncludedPaths_Missing("includedPaths", opLambda, aggsLambda);
714 }
715
716 public void setIncludedPaths_Missing(String name, ConditionOptionCall<MissingAggregationBuilder> opLambda,
717 OperatorCall<BsLabelTypeCA> aggsLambda) {
718 MissingAggregationBuilder builder = regMissingA(name, "includedPaths");
719 if (opLambda != null) {
720 opLambda.callback(builder);
721 }
722 if (aggsLambda != null) {
723 LabelTypeCA ca = new LabelTypeCA();
724 aggsLambda.callback(ca);
725 ca.getAggregationBuilderList().forEach(builder::subAggregation);
726 }
727 }
728
729 public void setName_Terms() {
730 setName_Terms(null);
731 }
732
733 public void setName_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda) {
734 setName_Terms("name", opLambda, null);
735 }
736
737 public void setName_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda, OperatorCall<BsLabelTypeCA> aggsLambda) {
738 setName_Terms("name", opLambda, aggsLambda);
739 }
740
741 public void setName_Terms(String name, ConditionOptionCall<TermsAggregationBuilder> opLambda, OperatorCall<BsLabelTypeCA> aggsLambda) {
742 TermsAggregationBuilder builder = regTermsA(name, "name");
743 if (opLambda != null) {
744 opLambda.callback(builder);
745 }
746 if (aggsLambda != null) {
747 LabelTypeCA ca = new LabelTypeCA();
748 aggsLambda.callback(ca);
749 ca.getAggregationBuilderList().forEach(builder::subAggregation);
750 }
751 }
752
753 public void setName_SignificantTerms() {
754 setName_SignificantTerms(null);
755 }
756
757 public void setName_SignificantTerms(ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda) {
758 setName_SignificantTerms("name", opLambda, null);
759 }
760
761 public void setName_SignificantTerms(ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda,
762 OperatorCall<BsLabelTypeCA> aggsLambda) {
763 setName_SignificantTerms("name", opLambda, aggsLambda);
764 }
765
766 public void setName_SignificantTerms(String name, ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda,
767 OperatorCall<BsLabelTypeCA> aggsLambda) {
768 SignificantTermsAggregationBuilder builder = regSignificantTermsA(name, "name");
769 if (opLambda != null) {
770 opLambda.callback(builder);
771 }
772 if (aggsLambda != null) {
773 LabelTypeCA ca = new LabelTypeCA();
774 aggsLambda.callback(ca);
775 ca.getAggregationBuilderList().forEach(builder::subAggregation);
776 }
777 }
778
779 public void setName_IpRange() {
780 setName_IpRange(null);
781 }
782
783 public void setName_IpRange(ConditionOptionCall<IpRangeAggregationBuilder> opLambda) {
784 setName_IpRange("name", opLambda, null);
785 }
786
787 public void setName_IpRange(ConditionOptionCall<IpRangeAggregationBuilder> opLambda, OperatorCall<BsLabelTypeCA> aggsLambda) {
788 setName_IpRange("name", opLambda, aggsLambda);
789 }
790
791 public void setName_IpRange(String name, ConditionOptionCall<IpRangeAggregationBuilder> opLambda,
792 OperatorCall<BsLabelTypeCA> aggsLambda) {
793 IpRangeAggregationBuilder builder = regIpRangeA(name, "name");
794 if (opLambda != null) {
795 opLambda.callback(builder);
796 }
797 if (aggsLambda != null) {
798 LabelTypeCA ca = new LabelTypeCA();
799 aggsLambda.callback(ca);
800 ca.getAggregationBuilderList().forEach(builder::subAggregation);
801 }
802 }
803
804 public void setName_Count() {
805 setName_Count(null);
806 }
807
808 public void setName_Count(ConditionOptionCall<ValueCountAggregationBuilder> opLambda) {
809 setName_Count("name", opLambda);
810 }
811
812 public void setName_Count(String name, ConditionOptionCall<ValueCountAggregationBuilder> opLambda) {
813 ValueCountAggregationBuilder builder = regCountA(name, "name");
814 if (opLambda != null) {
815 opLambda.callback(builder);
816 }
817 }
818
819 public void setName_Cardinality() {
820 setName_Cardinality(null);
821 }
822
823 public void setName_Cardinality(ConditionOptionCall<CardinalityAggregationBuilder> opLambda) {
824 setName_Cardinality("name", opLambda);
825 }
826
827 public void setName_Cardinality(String name, ConditionOptionCall<CardinalityAggregationBuilder> opLambda) {
828 CardinalityAggregationBuilder builder = regCardinalityA(name, "name");
829 if (opLambda != null) {
830 opLambda.callback(builder);
831 }
832 }
833
834 public void setName_Missing() {
835 setName_Missing(null);
836 }
837
838 public void setName_Missing(ConditionOptionCall<MissingAggregationBuilder> opLambda) {
839 setName_Missing("name", opLambda, null);
840 }
841
842 public void setName_Missing(ConditionOptionCall<MissingAggregationBuilder> opLambda, OperatorCall<BsLabelTypeCA> aggsLambda) {
843 setName_Missing("name", opLambda, aggsLambda);
844 }
845
846 public void setName_Missing(String name, ConditionOptionCall<MissingAggregationBuilder> opLambda,
847 OperatorCall<BsLabelTypeCA> aggsLambda) {
848 MissingAggregationBuilder builder = regMissingA(name, "name");
849 if (opLambda != null) {
850 opLambda.callback(builder);
851 }
852 if (aggsLambda != null) {
853 LabelTypeCA ca = new LabelTypeCA();
854 aggsLambda.callback(ca);
855 ca.getAggregationBuilderList().forEach(builder::subAggregation);
856 }
857 }
858
859 public void setPermissions_Terms() {
860 setPermissions_Terms(null);
861 }
862
863 public void setPermissions_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda) {
864 setPermissions_Terms("permissions", opLambda, null);
865 }
866
867 public void setPermissions_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda, OperatorCall<BsLabelTypeCA> aggsLambda) {
868 setPermissions_Terms("permissions", opLambda, aggsLambda);
869 }
870
871 public void setPermissions_Terms(String name, ConditionOptionCall<TermsAggregationBuilder> opLambda,
872 OperatorCall<BsLabelTypeCA> aggsLambda) {
873 TermsAggregationBuilder builder = regTermsA(name, "permissions");
874 if (opLambda != null) {
875 opLambda.callback(builder);
876 }
877 if (aggsLambda != null) {
878 LabelTypeCA ca = new LabelTypeCA();
879 aggsLambda.callback(ca);
880 ca.getAggregationBuilderList().forEach(builder::subAggregation);
881 }
882 }
883
884 public void setPermissions_SignificantTerms() {
885 setPermissions_SignificantTerms(null);
886 }
887
888 public void setPermissions_SignificantTerms(ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda) {
889 setPermissions_SignificantTerms("permissions", opLambda, null);
890 }
891
892 public void setPermissions_SignificantTerms(ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda,
893 OperatorCall<BsLabelTypeCA> aggsLambda) {
894 setPermissions_SignificantTerms("permissions", opLambda, aggsLambda);
895 }
896
897 public void setPermissions_SignificantTerms(String name, ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda,
898 OperatorCall<BsLabelTypeCA> aggsLambda) {
899 SignificantTermsAggregationBuilder builder = regSignificantTermsA(name, "permissions");
900 if (opLambda != null) {
901 opLambda.callback(builder);
902 }
903 if (aggsLambda != null) {
904 LabelTypeCA ca = new LabelTypeCA();
905 aggsLambda.callback(ca);
906 ca.getAggregationBuilderList().forEach(builder::subAggregation);
907 }
908 }
909
910 public void setPermissions_IpRange() {
911 setPermissions_IpRange(null);
912 }
913
914 public void setPermissions_IpRange(ConditionOptionCall<IpRangeAggregationBuilder> opLambda) {
915 setPermissions_IpRange("permissions", opLambda, null);
916 }
917
918 public void setPermissions_IpRange(ConditionOptionCall<IpRangeAggregationBuilder> opLambda, OperatorCall<BsLabelTypeCA> aggsLambda) {
919 setPermissions_IpRange("permissions", opLambda, aggsLambda);
920 }
921
922 public void setPermissions_IpRange(String name, ConditionOptionCall<IpRangeAggregationBuilder> opLambda,
923 OperatorCall<BsLabelTypeCA> aggsLambda) {
924 IpRangeAggregationBuilder builder = regIpRangeA(name, "permissions");
925 if (opLambda != null) {
926 opLambda.callback(builder);
927 }
928 if (aggsLambda != null) {
929 LabelTypeCA ca = new LabelTypeCA();
930 aggsLambda.callback(ca);
931 ca.getAggregationBuilderList().forEach(builder::subAggregation);
932 }
933 }
934
935 public void setPermissions_Count() {
936 setPermissions_Count(null);
937 }
938
939 public void setPermissions_Count(ConditionOptionCall<ValueCountAggregationBuilder> opLambda) {
940 setPermissions_Count("permissions", opLambda);
941 }
942
943 public void setPermissions_Count(String name, ConditionOptionCall<ValueCountAggregationBuilder> opLambda) {
944 ValueCountAggregationBuilder builder = regCountA(name, "permissions");
945 if (opLambda != null) {
946 opLambda.callback(builder);
947 }
948 }
949
950 public void setPermissions_Cardinality() {
951 setPermissions_Cardinality(null);
952 }
953
954 public void setPermissions_Cardinality(ConditionOptionCall<CardinalityAggregationBuilder> opLambda) {
955 setPermissions_Cardinality("permissions", opLambda);
956 }
957
958 public void setPermissions_Cardinality(String name, ConditionOptionCall<CardinalityAggregationBuilder> opLambda) {
959 CardinalityAggregationBuilder builder = regCardinalityA(name, "permissions");
960 if (opLambda != null) {
961 opLambda.callback(builder);
962 }
963 }
964
965 public void setPermissions_Missing() {
966 setPermissions_Missing(null);
967 }
968
969 public void setPermissions_Missing(ConditionOptionCall<MissingAggregationBuilder> opLambda) {
970 setPermissions_Missing("permissions", opLambda, null);
971 }
972
973 public void setPermissions_Missing(ConditionOptionCall<MissingAggregationBuilder> opLambda, OperatorCall<BsLabelTypeCA> aggsLambda) {
974 setPermissions_Missing("permissions", opLambda, aggsLambda);
975 }
976
977 public void setPermissions_Missing(String name, ConditionOptionCall<MissingAggregationBuilder> opLambda,
978 OperatorCall<BsLabelTypeCA> aggsLambda) {
979 MissingAggregationBuilder builder = regMissingA(name, "permissions");
980 if (opLambda != null) {
981 opLambda.callback(builder);
982 }
983 if (aggsLambda != null) {
984 LabelTypeCA ca = new LabelTypeCA();
985 aggsLambda.callback(ca);
986 ca.getAggregationBuilderList().forEach(builder::subAggregation);
987 }
988 }
989
990 public void setSortOrder_Avg() {
991 setSortOrder_Avg(null);
992 }
993
994 public void setSortOrder_Avg(ConditionOptionCall<AvgAggregationBuilder> opLambda) {
995 setSortOrder_Avg("sortOrder", opLambda);
996 }
997
998 public void setSortOrder_Avg(String name, ConditionOptionCall<AvgAggregationBuilder> opLambda) {
999 AvgAggregationBuilder builder = regAvgA(name, "sortOrder");
1000 if (opLambda != null) {
1001 opLambda.callback(builder);
1002 }
1003 }
1004
1005 public void setSortOrder_Max() {
1006 setSortOrder_Max(null);
1007 }
1008
1009 public void setSortOrder_Max(ConditionOptionCall<MaxAggregationBuilder> opLambda) {
1010 setSortOrder_Max("sortOrder", opLambda);
1011 }
1012
1013 public void setSortOrder_Max(String name, ConditionOptionCall<MaxAggregationBuilder> opLambda) {
1014 MaxAggregationBuilder builder = regMaxA(name, "sortOrder");
1015 if (opLambda != null) {
1016 opLambda.callback(builder);
1017 }
1018 }
1019
1020 public void setSortOrder_Min() {
1021 setSortOrder_Min(null);
1022 }
1023
1024 public void setSortOrder_Min(ConditionOptionCall<MinAggregationBuilder> opLambda) {
1025 setSortOrder_Min("sortOrder", opLambda);
1026 }
1027
1028 public void setSortOrder_Min(String name, ConditionOptionCall<MinAggregationBuilder> opLambda) {
1029 MinAggregationBuilder builder = regMinA(name, "sortOrder");
1030 if (opLambda != null) {
1031 opLambda.callback(builder);
1032 }
1033 }
1034
1035 public void setSortOrder_Sum() {
1036 setSortOrder_Sum(null);
1037 }
1038
1039 public void setSortOrder_Sum(ConditionOptionCall<SumAggregationBuilder> opLambda) {
1040 setSortOrder_Sum("sortOrder", opLambda);
1041 }
1042
1043 public void setSortOrder_Sum(String name, ConditionOptionCall<SumAggregationBuilder> opLambda) {
1044 SumAggregationBuilder builder = regSumA(name, "sortOrder");
1045 if (opLambda != null) {
1046 opLambda.callback(builder);
1047 }
1048 }
1049
1050 public void setSortOrder_ExtendedStats() {
1051 setSortOrder_ExtendedStats(null);
1052 }
1053
1054 public void setSortOrder_ExtendedStats(ConditionOptionCall<ExtendedStatsAggregationBuilder> opLambda) {
1055 setSortOrder_ExtendedStats("sortOrder", opLambda);
1056 }
1057
1058 public void setSortOrder_ExtendedStats(String name, ConditionOptionCall<ExtendedStatsAggregationBuilder> opLambda) {
1059 ExtendedStatsAggregationBuilder builder = regExtendedStatsA(name, "sortOrder");
1060 if (opLambda != null) {
1061 opLambda.callback(builder);
1062 }
1063 }
1064
1065 public void setSortOrder_Stats() {
1066 setSortOrder_Stats(null);
1067 }
1068
1069 public void setSortOrder_Stats(ConditionOptionCall<StatsAggregationBuilder> opLambda) {
1070 setSortOrder_Stats("sortOrder", opLambda);
1071 }
1072
1073 public void setSortOrder_Stats(String name, ConditionOptionCall<StatsAggregationBuilder> opLambda) {
1074 StatsAggregationBuilder builder = regStatsA(name, "sortOrder");
1075 if (opLambda != null) {
1076 opLambda.callback(builder);
1077 }
1078 }
1079
1080 public void setSortOrder_Percentiles() {
1081 setSortOrder_Percentiles(null);
1082 }
1083
1084 public void setSortOrder_Percentiles(ConditionOptionCall<PercentilesAggregationBuilder> opLambda) {
1085 setSortOrder_Percentiles("sortOrder", opLambda);
1086 }
1087
1088 public void setSortOrder_Percentiles(String name, ConditionOptionCall<PercentilesAggregationBuilder> opLambda) {
1089 PercentilesAggregationBuilder builder = regPercentilesA(name, "sortOrder");
1090 if (opLambda != null) {
1091 opLambda.callback(builder);
1092 }
1093 }
1094
1095 public void setSortOrder_PercentileRanks(double[] values) {
1096 setSortOrder_PercentileRanks(values, null);
1097 }
1098
1099 public void setSortOrder_PercentileRanks(double[] values, ConditionOptionCall<PercentileRanksAggregationBuilder> opLambda) {
1100 setSortOrder_PercentileRanks("sortOrder", values, opLambda);
1101 }
1102
1103 public void setSortOrder_PercentileRanks(String name, double[] values,
1104 ConditionOptionCall<PercentileRanksAggregationBuilder> opLambda) {
1105 PercentileRanksAggregationBuilder builder = regPercentileRanksA(name, "sortOrder", values);
1106 if (opLambda != null) {
1107 opLambda.callback(builder);
1108 }
1109 }
1110
1111 public void setSortOrder_Histogram() {
1112 setSortOrder_Histogram(null);
1113 }
1114
1115 public void setSortOrder_Histogram(ConditionOptionCall<HistogramAggregationBuilder> opLambda) {
1116 setSortOrder_Histogram("sortOrder", opLambda, null);
1117 }
1118
1119 public void setSortOrder_Histogram(ConditionOptionCall<HistogramAggregationBuilder> opLambda, OperatorCall<BsLabelTypeCA> aggsLambda) {
1120 setSortOrder_Histogram("sortOrder", opLambda, aggsLambda);
1121 }
1122
1123 public void setSortOrder_Histogram(String name, ConditionOptionCall<HistogramAggregationBuilder> opLambda,
1124 OperatorCall<BsLabelTypeCA> aggsLambda) {
1125 HistogramAggregationBuilder builder = regHistogramA(name, "sortOrder");
1126 if (opLambda != null) {
1127 opLambda.callback(builder);
1128 }
1129 if (aggsLambda != null) {
1130 LabelTypeCA ca = new LabelTypeCA();
1131 aggsLambda.callback(ca);
1132 ca.getAggregationBuilderList().forEach(builder::subAggregation);
1133 }
1134 }
1135
1136 public void setSortOrder_Range() {
1137 setSortOrder_Range(null);
1138 }
1139
1140 public void setSortOrder_Range(ConditionOptionCall<RangeAggregationBuilder> opLambda) {
1141 setSortOrder_Range("sortOrder", opLambda, null);
1142 }
1143
1144 public void setSortOrder_Range(ConditionOptionCall<RangeAggregationBuilder> opLambda, OperatorCall<BsLabelTypeCA> aggsLambda) {
1145 setSortOrder_Range("sortOrder", opLambda, aggsLambda);
1146 }
1147
1148 public void setSortOrder_Range(String name, ConditionOptionCall<RangeAggregationBuilder> opLambda,
1149 OperatorCall<BsLabelTypeCA> aggsLambda) {
1150 RangeAggregationBuilder builder = regRangeA(name, "sortOrder");
1151 if (opLambda != null) {
1152 opLambda.callback(builder);
1153 }
1154 if (aggsLambda != null) {
1155 LabelTypeCA ca = new LabelTypeCA();
1156 aggsLambda.callback(ca);
1157 ca.getAggregationBuilderList().forEach(builder::subAggregation);
1158 }
1159 }
1160
1161 public void setSortOrder_Count() {
1162 setSortOrder_Count(null);
1163 }
1164
1165 public void setSortOrder_Count(ConditionOptionCall<ValueCountAggregationBuilder> opLambda) {
1166 setSortOrder_Count("sortOrder", opLambda);
1167 }
1168
1169 public void setSortOrder_Count(String name, ConditionOptionCall<ValueCountAggregationBuilder> opLambda) {
1170 ValueCountAggregationBuilder builder = regCountA(name, "sortOrder");
1171 if (opLambda != null) {
1172 opLambda.callback(builder);
1173 }
1174 }
1175
1176 public void setSortOrder_Cardinality() {
1177 setSortOrder_Cardinality(null);
1178 }
1179
1180 public void setSortOrder_Cardinality(ConditionOptionCall<CardinalityAggregationBuilder> opLambda) {
1181 setSortOrder_Cardinality("sortOrder", opLambda);
1182 }
1183
1184 public void setSortOrder_Cardinality(String name, ConditionOptionCall<CardinalityAggregationBuilder> opLambda) {
1185 CardinalityAggregationBuilder builder = regCardinalityA(name, "sortOrder");
1186 if (opLambda != null) {
1187 opLambda.callback(builder);
1188 }
1189 }
1190
1191 public void setSortOrder_Missing() {
1192 setSortOrder_Missing(null);
1193 }
1194
1195 public void setSortOrder_Missing(ConditionOptionCall<MissingAggregationBuilder> opLambda) {
1196 setSortOrder_Missing("sortOrder", opLambda, null);
1197 }
1198
1199 public void setSortOrder_Missing(ConditionOptionCall<MissingAggregationBuilder> opLambda, OperatorCall<BsLabelTypeCA> aggsLambda) {
1200 setSortOrder_Missing("sortOrder", opLambda, aggsLambda);
1201 }
1202
1203 public void setSortOrder_Missing(String name, ConditionOptionCall<MissingAggregationBuilder> opLambda,
1204 OperatorCall<BsLabelTypeCA> aggsLambda) {
1205 MissingAggregationBuilder builder = regMissingA(name, "sortOrder");
1206 if (opLambda != null) {
1207 opLambda.callback(builder);
1208 }
1209 if (aggsLambda != null) {
1210 LabelTypeCA ca = new LabelTypeCA();
1211 aggsLambda.callback(ca);
1212 ca.getAggregationBuilderList().forEach(builder::subAggregation);
1213 }
1214 }
1215
1216 public void setUpdatedBy_Terms() {
1217 setUpdatedBy_Terms(null);
1218 }
1219
1220 public void setUpdatedBy_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda) {
1221 setUpdatedBy_Terms("updatedBy", opLambda, null);
1222 }
1223
1224 public void setUpdatedBy_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda, OperatorCall<BsLabelTypeCA> aggsLambda) {
1225 setUpdatedBy_Terms("updatedBy", opLambda, aggsLambda);
1226 }
1227
1228 public void setUpdatedBy_Terms(String name, ConditionOptionCall<TermsAggregationBuilder> opLambda,
1229 OperatorCall<BsLabelTypeCA> aggsLambda) {
1230 TermsAggregationBuilder builder = regTermsA(name, "updatedBy");
1231 if (opLambda != null) {
1232 opLambda.callback(builder);
1233 }
1234 if (aggsLambda != null) {
1235 LabelTypeCA ca = new LabelTypeCA();
1236 aggsLambda.callback(ca);
1237 ca.getAggregationBuilderList().forEach(builder::subAggregation);
1238 }
1239 }
1240
1241 public void setUpdatedBy_SignificantTerms() {
1242 setUpdatedBy_SignificantTerms(null);
1243 }
1244
1245 public void setUpdatedBy_SignificantTerms(ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda) {
1246 setUpdatedBy_SignificantTerms("updatedBy", opLambda, null);
1247 }
1248
1249 public void setUpdatedBy_SignificantTerms(ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda,
1250 OperatorCall<BsLabelTypeCA> aggsLambda) {
1251 setUpdatedBy_SignificantTerms("updatedBy", opLambda, aggsLambda);
1252 }
1253
1254 public void setUpdatedBy_SignificantTerms(String name, ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda,
1255 OperatorCall<BsLabelTypeCA> aggsLambda) {
1256 SignificantTermsAggregationBuilder builder = regSignificantTermsA(name, "updatedBy");
1257 if (opLambda != null) {
1258 opLambda.callback(builder);
1259 }
1260 if (aggsLambda != null) {
1261 LabelTypeCA ca = new LabelTypeCA();
1262 aggsLambda.callback(ca);
1263 ca.getAggregationBuilderList().forEach(builder::subAggregation);
1264 }
1265 }
1266
1267 public void setUpdatedBy_IpRange() {
1268 setUpdatedBy_IpRange(null);
1269 }
1270
1271 public void setUpdatedBy_IpRange(ConditionOptionCall<IpRangeAggregationBuilder> opLambda) {
1272 setUpdatedBy_IpRange("updatedBy", opLambda, null);
1273 }
1274
1275 public void setUpdatedBy_IpRange(ConditionOptionCall<IpRangeAggregationBuilder> opLambda, OperatorCall<BsLabelTypeCA> aggsLambda) {
1276 setUpdatedBy_IpRange("updatedBy", opLambda, aggsLambda);
1277 }
1278
1279 public void setUpdatedBy_IpRange(String name, ConditionOptionCall<IpRangeAggregationBuilder> opLambda,
1280 OperatorCall<BsLabelTypeCA> aggsLambda) {
1281 IpRangeAggregationBuilder builder = regIpRangeA(name, "updatedBy");
1282 if (opLambda != null) {
1283 opLambda.callback(builder);
1284 }
1285 if (aggsLambda != null) {
1286 LabelTypeCA ca = new LabelTypeCA();
1287 aggsLambda.callback(ca);
1288 ca.getAggregationBuilderList().forEach(builder::subAggregation);
1289 }
1290 }
1291
1292 public void setUpdatedBy_Count() {
1293 setUpdatedBy_Count(null);
1294 }
1295
1296 public void setUpdatedBy_Count(ConditionOptionCall<ValueCountAggregationBuilder> opLambda) {
1297 setUpdatedBy_Count("updatedBy", opLambda);
1298 }
1299
1300 public void setUpdatedBy_Count(String name, ConditionOptionCall<ValueCountAggregationBuilder> opLambda) {
1301 ValueCountAggregationBuilder builder = regCountA(name, "updatedBy");
1302 if (opLambda != null) {
1303 opLambda.callback(builder);
1304 }
1305 }
1306
1307 public void setUpdatedBy_Cardinality() {
1308 setUpdatedBy_Cardinality(null);
1309 }
1310
1311 public void setUpdatedBy_Cardinality(ConditionOptionCall<CardinalityAggregationBuilder> opLambda) {
1312 setUpdatedBy_Cardinality("updatedBy", opLambda);
1313 }
1314
1315 public void setUpdatedBy_Cardinality(String name, ConditionOptionCall<CardinalityAggregationBuilder> opLambda) {
1316 CardinalityAggregationBuilder builder = regCardinalityA(name, "updatedBy");
1317 if (opLambda != null) {
1318 opLambda.callback(builder);
1319 }
1320 }
1321
1322 public void setUpdatedBy_Missing() {
1323 setUpdatedBy_Missing(null);
1324 }
1325
1326 public void setUpdatedBy_Missing(ConditionOptionCall<MissingAggregationBuilder> opLambda) {
1327 setUpdatedBy_Missing("updatedBy", opLambda, null);
1328 }
1329
1330 public void setUpdatedBy_Missing(ConditionOptionCall<MissingAggregationBuilder> opLambda, OperatorCall<BsLabelTypeCA> aggsLambda) {
1331 setUpdatedBy_Missing("updatedBy", opLambda, aggsLambda);
1332 }
1333
1334 public void setUpdatedBy_Missing(String name, ConditionOptionCall<MissingAggregationBuilder> opLambda,
1335 OperatorCall<BsLabelTypeCA> aggsLambda) {
1336 MissingAggregationBuilder builder = regMissingA(name, "updatedBy");
1337 if (opLambda != null) {
1338 opLambda.callback(builder);
1339 }
1340 if (aggsLambda != null) {
1341 LabelTypeCA ca = new LabelTypeCA();
1342 aggsLambda.callback(ca);
1343 ca.getAggregationBuilderList().forEach(builder::subAggregation);
1344 }
1345 }
1346
1347 public void setUpdatedTime_Avg() {
1348 setUpdatedTime_Avg(null);
1349 }
1350
1351 public void setUpdatedTime_Avg(ConditionOptionCall<AvgAggregationBuilder> opLambda) {
1352 setUpdatedTime_Avg("updatedTime", opLambda);
1353 }
1354
1355 public void setUpdatedTime_Avg(String name, ConditionOptionCall<AvgAggregationBuilder> opLambda) {
1356 AvgAggregationBuilder builder = regAvgA(name, "updatedTime");
1357 if (opLambda != null) {
1358 opLambda.callback(builder);
1359 }
1360 }
1361
1362 public void setUpdatedTime_Max() {
1363 setUpdatedTime_Max(null);
1364 }
1365
1366 public void setUpdatedTime_Max(ConditionOptionCall<MaxAggregationBuilder> opLambda) {
1367 setUpdatedTime_Max("updatedTime", opLambda);
1368 }
1369
1370 public void setUpdatedTime_Max(String name, ConditionOptionCall<MaxAggregationBuilder> opLambda) {
1371 MaxAggregationBuilder builder = regMaxA(name, "updatedTime");
1372 if (opLambda != null) {
1373 opLambda.callback(builder);
1374 }
1375 }
1376
1377 public void setUpdatedTime_Min() {
1378 setUpdatedTime_Min(null);
1379 }
1380
1381 public void setUpdatedTime_Min(ConditionOptionCall<MinAggregationBuilder> opLambda) {
1382 setUpdatedTime_Min("updatedTime", opLambda);
1383 }
1384
1385 public void setUpdatedTime_Min(String name, ConditionOptionCall<MinAggregationBuilder> opLambda) {
1386 MinAggregationBuilder builder = regMinA(name, "updatedTime");
1387 if (opLambda != null) {
1388 opLambda.callback(builder);
1389 }
1390 }
1391
1392 public void setUpdatedTime_Sum() {
1393 setUpdatedTime_Sum(null);
1394 }
1395
1396 public void setUpdatedTime_Sum(ConditionOptionCall<SumAggregationBuilder> opLambda) {
1397 setUpdatedTime_Sum("updatedTime", opLambda);
1398 }
1399
1400 public void setUpdatedTime_Sum(String name, ConditionOptionCall<SumAggregationBuilder> opLambda) {
1401 SumAggregationBuilder builder = regSumA(name, "updatedTime");
1402 if (opLambda != null) {
1403 opLambda.callback(builder);
1404 }
1405 }
1406
1407 public void setUpdatedTime_ExtendedStats() {
1408 setUpdatedTime_ExtendedStats(null);
1409 }
1410
1411 public void setUpdatedTime_ExtendedStats(ConditionOptionCall<ExtendedStatsAggregationBuilder> opLambda) {
1412 setUpdatedTime_ExtendedStats("updatedTime", opLambda);
1413 }
1414
1415 public void setUpdatedTime_ExtendedStats(String name, ConditionOptionCall<ExtendedStatsAggregationBuilder> opLambda) {
1416 ExtendedStatsAggregationBuilder builder = regExtendedStatsA(name, "updatedTime");
1417 if (opLambda != null) {
1418 opLambda.callback(builder);
1419 }
1420 }
1421
1422 public void setUpdatedTime_Stats() {
1423 setUpdatedTime_Stats(null);
1424 }
1425
1426 public void setUpdatedTime_Stats(ConditionOptionCall<StatsAggregationBuilder> opLambda) {
1427 setUpdatedTime_Stats("updatedTime", opLambda);
1428 }
1429
1430 public void setUpdatedTime_Stats(String name, ConditionOptionCall<StatsAggregationBuilder> opLambda) {
1431 StatsAggregationBuilder builder = regStatsA(name, "updatedTime");
1432 if (opLambda != null) {
1433 opLambda.callback(builder);
1434 }
1435 }
1436
1437 public void setUpdatedTime_Percentiles() {
1438 setUpdatedTime_Percentiles(null);
1439 }
1440
1441 public void setUpdatedTime_Percentiles(ConditionOptionCall<PercentilesAggregationBuilder> opLambda) {
1442 setUpdatedTime_Percentiles("updatedTime", opLambda);
1443 }
1444
1445 public void setUpdatedTime_Percentiles(String name, ConditionOptionCall<PercentilesAggregationBuilder> opLambda) {
1446 PercentilesAggregationBuilder builder = regPercentilesA(name, "updatedTime");
1447 if (opLambda != null) {
1448 opLambda.callback(builder);
1449 }
1450 }
1451
1452 public void setUpdatedTime_PercentileRanks(double[] values) {
1453 setUpdatedTime_PercentileRanks(values, null);
1454 }
1455
1456 public void setUpdatedTime_PercentileRanks(double[] values, ConditionOptionCall<PercentileRanksAggregationBuilder> opLambda) {
1457 setUpdatedTime_PercentileRanks("updatedTime", values, opLambda);
1458 }
1459
1460 public void setUpdatedTime_PercentileRanks(String name, double[] values,
1461 ConditionOptionCall<PercentileRanksAggregationBuilder> opLambda) {
1462 PercentileRanksAggregationBuilder builder = regPercentileRanksA(name, "updatedTime", values);
1463 if (opLambda != null) {
1464 opLambda.callback(builder);
1465 }
1466 }
1467
1468 public void setUpdatedTime_Histogram() {
1469 setUpdatedTime_Histogram(null);
1470 }
1471
1472 public void setUpdatedTime_Histogram(ConditionOptionCall<HistogramAggregationBuilder> opLambda) {
1473 setUpdatedTime_Histogram("updatedTime", opLambda, null);
1474 }
1475
1476 public void setUpdatedTime_Histogram(ConditionOptionCall<HistogramAggregationBuilder> opLambda,
1477 OperatorCall<BsLabelTypeCA> aggsLambda) {
1478 setUpdatedTime_Histogram("updatedTime", opLambda, aggsLambda);
1479 }
1480
1481 public void setUpdatedTime_Histogram(String name, ConditionOptionCall<HistogramAggregationBuilder> opLambda,
1482 OperatorCall<BsLabelTypeCA> aggsLambda) {
1483 HistogramAggregationBuilder builder = regHistogramA(name, "updatedTime");
1484 if (opLambda != null) {
1485 opLambda.callback(builder);
1486 }
1487 if (aggsLambda != null) {
1488 LabelTypeCA ca = new LabelTypeCA();
1489 aggsLambda.callback(ca);
1490 ca.getAggregationBuilderList().forEach(builder::subAggregation);
1491 }
1492 }
1493
1494 public void setUpdatedTime_Range() {
1495 setUpdatedTime_Range(null);
1496 }
1497
1498 public void setUpdatedTime_Range(ConditionOptionCall<RangeAggregationBuilder> opLambda) {
1499 setUpdatedTime_Range("updatedTime", opLambda, null);
1500 }
1501
1502 public void setUpdatedTime_Range(ConditionOptionCall<RangeAggregationBuilder> opLambda, OperatorCall<BsLabelTypeCA> aggsLambda) {
1503 setUpdatedTime_Range("updatedTime", opLambda, aggsLambda);
1504 }
1505
1506 public void setUpdatedTime_Range(String name, ConditionOptionCall<RangeAggregationBuilder> opLambda,
1507 OperatorCall<BsLabelTypeCA> aggsLambda) {
1508 RangeAggregationBuilder builder = regRangeA(name, "updatedTime");
1509 if (opLambda != null) {
1510 opLambda.callback(builder);
1511 }
1512 if (aggsLambda != null) {
1513 LabelTypeCA ca = new LabelTypeCA();
1514 aggsLambda.callback(ca);
1515 ca.getAggregationBuilderList().forEach(builder::subAggregation);
1516 }
1517 }
1518
1519 public void setUpdatedTime_Count() {
1520 setUpdatedTime_Count(null);
1521 }
1522
1523 public void setUpdatedTime_Count(ConditionOptionCall<ValueCountAggregationBuilder> opLambda) {
1524 setUpdatedTime_Count("updatedTime", opLambda);
1525 }
1526
1527 public void setUpdatedTime_Count(String name, ConditionOptionCall<ValueCountAggregationBuilder> opLambda) {
1528 ValueCountAggregationBuilder builder = regCountA(name, "updatedTime");
1529 if (opLambda != null) {
1530 opLambda.callback(builder);
1531 }
1532 }
1533
1534 public void setUpdatedTime_Cardinality() {
1535 setUpdatedTime_Cardinality(null);
1536 }
1537
1538 public void setUpdatedTime_Cardinality(ConditionOptionCall<CardinalityAggregationBuilder> opLambda) {
1539 setUpdatedTime_Cardinality("updatedTime", opLambda);
1540 }
1541
1542 public void setUpdatedTime_Cardinality(String name, ConditionOptionCall<CardinalityAggregationBuilder> opLambda) {
1543 CardinalityAggregationBuilder builder = regCardinalityA(name, "updatedTime");
1544 if (opLambda != null) {
1545 opLambda.callback(builder);
1546 }
1547 }
1548
1549 public void setUpdatedTime_Missing() {
1550 setUpdatedTime_Missing(null);
1551 }
1552
1553 public void setUpdatedTime_Missing(ConditionOptionCall<MissingAggregationBuilder> opLambda) {
1554 setUpdatedTime_Missing("updatedTime", opLambda, null);
1555 }
1556
1557 public void setUpdatedTime_Missing(ConditionOptionCall<MissingAggregationBuilder> opLambda, OperatorCall<BsLabelTypeCA> aggsLambda) {
1558 setUpdatedTime_Missing("updatedTime", opLambda, aggsLambda);
1559 }
1560
1561 public void setUpdatedTime_Missing(String name, ConditionOptionCall<MissingAggregationBuilder> opLambda,
1562 OperatorCall<BsLabelTypeCA> aggsLambda) {
1563 MissingAggregationBuilder builder = regMissingA(name, "updatedTime");
1564 if (opLambda != null) {
1565 opLambda.callback(builder);
1566 }
1567 if (aggsLambda != null) {
1568 LabelTypeCA ca = new LabelTypeCA();
1569 aggsLambda.callback(ca);
1570 ca.getAggregationBuilderList().forEach(builder::subAggregation);
1571 }
1572 }
1573
1574 public void setValue_Terms() {
1575 setValue_Terms(null);
1576 }
1577
1578 public void setValue_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda) {
1579 setValue_Terms("value", opLambda, null);
1580 }
1581
1582 public void setValue_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda, OperatorCall<BsLabelTypeCA> aggsLambda) {
1583 setValue_Terms("value", opLambda, aggsLambda);
1584 }
1585
1586 public void setValue_Terms(String name, ConditionOptionCall<TermsAggregationBuilder> opLambda, OperatorCall<BsLabelTypeCA> aggsLambda) {
1587 TermsAggregationBuilder builder = regTermsA(name, "value");
1588 if (opLambda != null) {
1589 opLambda.callback(builder);
1590 }
1591 if (aggsLambda != null) {
1592 LabelTypeCA ca = new LabelTypeCA();
1593 aggsLambda.callback(ca);
1594 ca.getAggregationBuilderList().forEach(builder::subAggregation);
1595 }
1596 }
1597
1598 public void setValue_SignificantTerms() {
1599 setValue_SignificantTerms(null);
1600 }
1601
1602 public void setValue_SignificantTerms(ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda) {
1603 setValue_SignificantTerms("value", opLambda, null);
1604 }
1605
1606 public void setValue_SignificantTerms(ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda,
1607 OperatorCall<BsLabelTypeCA> aggsLambda) {
1608 setValue_SignificantTerms("value", opLambda, aggsLambda);
1609 }
1610
1611 public void setValue_SignificantTerms(String name, ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda,
1612 OperatorCall<BsLabelTypeCA> aggsLambda) {
1613 SignificantTermsAggregationBuilder builder = regSignificantTermsA(name, "value");
1614 if (opLambda != null) {
1615 opLambda.callback(builder);
1616 }
1617 if (aggsLambda != null) {
1618 LabelTypeCA ca = new LabelTypeCA();
1619 aggsLambda.callback(ca);
1620 ca.getAggregationBuilderList().forEach(builder::subAggregation);
1621 }
1622 }
1623
1624 public void setValue_IpRange() {
1625 setValue_IpRange(null);
1626 }
1627
1628 public void setValue_IpRange(ConditionOptionCall<IpRangeAggregationBuilder> opLambda) {
1629 setValue_IpRange("value", opLambda, null);
1630 }
1631
1632 public void setValue_IpRange(ConditionOptionCall<IpRangeAggregationBuilder> opLambda, OperatorCall<BsLabelTypeCA> aggsLambda) {
1633 setValue_IpRange("value", opLambda, aggsLambda);
1634 }
1635
1636 public void setValue_IpRange(String name, ConditionOptionCall<IpRangeAggregationBuilder> opLambda,
1637 OperatorCall<BsLabelTypeCA> aggsLambda) {
1638 IpRangeAggregationBuilder builder = regIpRangeA(name, "value");
1639 if (opLambda != null) {
1640 opLambda.callback(builder);
1641 }
1642 if (aggsLambda != null) {
1643 LabelTypeCA ca = new LabelTypeCA();
1644 aggsLambda.callback(ca);
1645 ca.getAggregationBuilderList().forEach(builder::subAggregation);
1646 }
1647 }
1648
1649 public void setValue_Count() {
1650 setValue_Count(null);
1651 }
1652
1653 public void setValue_Count(ConditionOptionCall<ValueCountAggregationBuilder> opLambda) {
1654 setValue_Count("value", opLambda);
1655 }
1656
1657 public void setValue_Count(String name, ConditionOptionCall<ValueCountAggregationBuilder> opLambda) {
1658 ValueCountAggregationBuilder builder = regCountA(name, "value");
1659 if (opLambda != null) {
1660 opLambda.callback(builder);
1661 }
1662 }
1663
1664 public void setValue_Cardinality() {
1665 setValue_Cardinality(null);
1666 }
1667
1668 public void setValue_Cardinality(ConditionOptionCall<CardinalityAggregationBuilder> opLambda) {
1669 setValue_Cardinality("value", opLambda);
1670 }
1671
1672 public void setValue_Cardinality(String name, ConditionOptionCall<CardinalityAggregationBuilder> opLambda) {
1673 CardinalityAggregationBuilder builder = regCardinalityA(name, "value");
1674 if (opLambda != null) {
1675 opLambda.callback(builder);
1676 }
1677 }
1678
1679 public void setValue_Missing() {
1680 setValue_Missing(null);
1681 }
1682
1683 public void setValue_Missing(ConditionOptionCall<MissingAggregationBuilder> opLambda) {
1684 setValue_Missing("value", opLambda, null);
1685 }
1686
1687 public void setValue_Missing(ConditionOptionCall<MissingAggregationBuilder> opLambda, OperatorCall<BsLabelTypeCA> aggsLambda) {
1688 setValue_Missing("value", opLambda, aggsLambda);
1689 }
1690
1691 public void setValue_Missing(String name, ConditionOptionCall<MissingAggregationBuilder> opLambda,
1692 OperatorCall<BsLabelTypeCA> aggsLambda) {
1693 MissingAggregationBuilder builder = regMissingA(name, "value");
1694 if (opLambda != null) {
1695 opLambda.callback(builder);
1696 }
1697 if (aggsLambda != null) {
1698 LabelTypeCA ca = new LabelTypeCA();
1699 aggsLambda.callback(ca);
1700 ca.getAggregationBuilderList().forEach(builder::subAggregation);
1701 }
1702 }
1703
1704 public void setVirtualHost_Terms() {
1705 setVirtualHost_Terms(null);
1706 }
1707
1708 public void setVirtualHost_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda) {
1709 setVirtualHost_Terms("virtualHost", opLambda, null);
1710 }
1711
1712 public void setVirtualHost_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda, OperatorCall<BsLabelTypeCA> aggsLambda) {
1713 setVirtualHost_Terms("virtualHost", opLambda, aggsLambda);
1714 }
1715
1716 public void setVirtualHost_Terms(String name, ConditionOptionCall<TermsAggregationBuilder> opLambda,
1717 OperatorCall<BsLabelTypeCA> aggsLambda) {
1718 TermsAggregationBuilder builder = regTermsA(name, "virtualHost");
1719 if (opLambda != null) {
1720 opLambda.callback(builder);
1721 }
1722 if (aggsLambda != null) {
1723 LabelTypeCA ca = new LabelTypeCA();
1724 aggsLambda.callback(ca);
1725 ca.getAggregationBuilderList().forEach(builder::subAggregation);
1726 }
1727 }
1728
1729 public void setVirtualHost_SignificantTerms() {
1730 setVirtualHost_SignificantTerms(null);
1731 }
1732
1733 public void setVirtualHost_SignificantTerms(ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda) {
1734 setVirtualHost_SignificantTerms("virtualHost", opLambda, null);
1735 }
1736
1737 public void setVirtualHost_SignificantTerms(ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda,
1738 OperatorCall<BsLabelTypeCA> aggsLambda) {
1739 setVirtualHost_SignificantTerms("virtualHost", opLambda, aggsLambda);
1740 }
1741
1742 public void setVirtualHost_SignificantTerms(String name, ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda,
1743 OperatorCall<BsLabelTypeCA> aggsLambda) {
1744 SignificantTermsAggregationBuilder builder = regSignificantTermsA(name, "virtualHost");
1745 if (opLambda != null) {
1746 opLambda.callback(builder);
1747 }
1748 if (aggsLambda != null) {
1749 LabelTypeCA ca = new LabelTypeCA();
1750 aggsLambda.callback(ca);
1751 ca.getAggregationBuilderList().forEach(builder::subAggregation);
1752 }
1753 }
1754
1755 public void setVirtualHost_IpRange() {
1756 setVirtualHost_IpRange(null);
1757 }
1758
1759 public void setVirtualHost_IpRange(ConditionOptionCall<IpRangeAggregationBuilder> opLambda) {
1760 setVirtualHost_IpRange("virtualHost", opLambda, null);
1761 }
1762
1763 public void setVirtualHost_IpRange(ConditionOptionCall<IpRangeAggregationBuilder> opLambda, OperatorCall<BsLabelTypeCA> aggsLambda) {
1764 setVirtualHost_IpRange("virtualHost", opLambda, aggsLambda);
1765 }
1766
1767 public void setVirtualHost_IpRange(String name, ConditionOptionCall<IpRangeAggregationBuilder> opLambda,
1768 OperatorCall<BsLabelTypeCA> aggsLambda) {
1769 IpRangeAggregationBuilder builder = regIpRangeA(name, "virtualHost");
1770 if (opLambda != null) {
1771 opLambda.callback(builder);
1772 }
1773 if (aggsLambda != null) {
1774 LabelTypeCA ca = new LabelTypeCA();
1775 aggsLambda.callback(ca);
1776 ca.getAggregationBuilderList().forEach(builder::subAggregation);
1777 }
1778 }
1779
1780 public void setVirtualHost_Count() {
1781 setVirtualHost_Count(null);
1782 }
1783
1784 public void setVirtualHost_Count(ConditionOptionCall<ValueCountAggregationBuilder> opLambda) {
1785 setVirtualHost_Count("virtualHost", opLambda);
1786 }
1787
1788 public void setVirtualHost_Count(String name, ConditionOptionCall<ValueCountAggregationBuilder> opLambda) {
1789 ValueCountAggregationBuilder builder = regCountA(name, "virtualHost");
1790 if (opLambda != null) {
1791 opLambda.callback(builder);
1792 }
1793 }
1794
1795 public void setVirtualHost_Cardinality() {
1796 setVirtualHost_Cardinality(null);
1797 }
1798
1799 public void setVirtualHost_Cardinality(ConditionOptionCall<CardinalityAggregationBuilder> opLambda) {
1800 setVirtualHost_Cardinality("virtualHost", opLambda);
1801 }
1802
1803 public void setVirtualHost_Cardinality(String name, ConditionOptionCall<CardinalityAggregationBuilder> opLambda) {
1804 CardinalityAggregationBuilder builder = regCardinalityA(name, "virtualHost");
1805 if (opLambda != null) {
1806 opLambda.callback(builder);
1807 }
1808 }
1809
1810 public void setVirtualHost_Missing() {
1811 setVirtualHost_Missing(null);
1812 }
1813
1814 public void setVirtualHost_Missing(ConditionOptionCall<MissingAggregationBuilder> opLambda) {
1815 setVirtualHost_Missing("virtualHost", opLambda, null);
1816 }
1817
1818 public void setVirtualHost_Missing(ConditionOptionCall<MissingAggregationBuilder> opLambda, OperatorCall<BsLabelTypeCA> aggsLambda) {
1819 setVirtualHost_Missing("virtualHost", opLambda, aggsLambda);
1820 }
1821
1822 public void setVirtualHost_Missing(String name, ConditionOptionCall<MissingAggregationBuilder> opLambda,
1823 OperatorCall<BsLabelTypeCA> aggsLambda) {
1824 MissingAggregationBuilder builder = regMissingA(name, "virtualHost");
1825 if (opLambda != null) {
1826 opLambda.callback(builder);
1827 }
1828 if (aggsLambda != null) {
1829 LabelTypeCA ca = new LabelTypeCA();
1830 aggsLambda.callback(ca);
1831 ca.getAggregationBuilderList().forEach(builder::subAggregation);
1832 }
1833 }
1834
1835 }