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