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.ThumbnailQueueCA;
21 import org.codelibs.fess.opensearch.config.cbean.cq.ThumbnailQueueCQ;
22 import org.codelibs.fess.opensearch.config.cbean.cq.bs.BsThumbnailQueueCQ;
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 BsThumbnailQueueCA extends EsAbstractConditionAggregation {
49
50
51
52
53
54 public void filter(String name, EsAbstractConditionQuery.OperatorCall<BsThumbnailQueueCQ> queryLambda,
55 ConditionOptionCall<FilterAggregationBuilder> opLambda, OperatorCall<BsThumbnailQueueCA> aggsLambda) {
56 ThumbnailQueueCQ cq = new ThumbnailQueueCQ();
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 ThumbnailQueueCA ca = new ThumbnailQueueCA();
66 aggsLambda.callback(ca);
67 ca.getAggregationBuilderList().forEach(builder::subAggregation);
68 }
69 }
70
71 public void global(String name, ConditionOptionCall<GlobalAggregationBuilder> opLambda, OperatorCall<BsThumbnailQueueCA> aggsLambda) {
72 GlobalAggregationBuilder builder = regGlobalA(name);
73 if (opLambda != null) {
74 opLambda.callback(builder);
75 }
76 if (aggsLambda != null) {
77 ThumbnailQueueCA ca = new ThumbnailQueueCA();
78 aggsLambda.callback(ca);
79 ca.getAggregationBuilderList().forEach(builder::subAggregation);
80 }
81 }
82
83 public void sampler(String name, ConditionOptionCall<SamplerAggregationBuilder> opLambda, OperatorCall<BsThumbnailQueueCA> aggsLambda) {
84 SamplerAggregationBuilder builder = regSamplerA(name);
85 if (opLambda != null) {
86 opLambda.callback(builder);
87 }
88 if (aggsLambda != null) {
89 ThumbnailQueueCA ca = new ThumbnailQueueCA();
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<BsThumbnailQueueCA> aggsLambda) {
118 setCreatedBy_Terms("createdBy", opLambda, aggsLambda);
119 }
120
121 public void setCreatedBy_Terms(String name, ConditionOptionCall<TermsAggregationBuilder> opLambda,
122 OperatorCall<BsThumbnailQueueCA> aggsLambda) {
123 TermsAggregationBuilder builder = regTermsA(name, "createdBy");
124 if (opLambda != null) {
125 opLambda.callback(builder);
126 }
127 if (aggsLambda != null) {
128 ThumbnailQueueCA ca = new ThumbnailQueueCA();
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<BsThumbnailQueueCA> aggsLambda) {
144 setCreatedBy_SignificantTerms("createdBy", opLambda, aggsLambda);
145 }
146
147 public void setCreatedBy_SignificantTerms(String name, ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda,
148 OperatorCall<BsThumbnailQueueCA> aggsLambda) {
149 SignificantTermsAggregationBuilder builder = regSignificantTermsA(name, "createdBy");
150 if (opLambda != null) {
151 opLambda.callback(builder);
152 }
153 if (aggsLambda != null) {
154 ThumbnailQueueCA ca = new ThumbnailQueueCA();
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<BsThumbnailQueueCA> aggsLambda) {
169 setCreatedBy_IpRange("createdBy", opLambda, aggsLambda);
170 }
171
172 public void setCreatedBy_IpRange(String name, ConditionOptionCall<IpRangeAggregationBuilder> opLambda,
173 OperatorCall<BsThumbnailQueueCA> aggsLambda) {
174 IpRangeAggregationBuilder builder = regIpRangeA(name, "createdBy");
175 if (opLambda != null) {
176 opLambda.callback(builder);
177 }
178 if (aggsLambda != null) {
179 ThumbnailQueueCA ca = new ThumbnailQueueCA();
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<BsThumbnailQueueCA> aggsLambda) {
224 setCreatedBy_Missing("createdBy", opLambda, aggsLambda);
225 }
226
227 public void setCreatedBy_Missing(String name, ConditionOptionCall<MissingAggregationBuilder> opLambda,
228 OperatorCall<BsThumbnailQueueCA> aggsLambda) {
229 MissingAggregationBuilder builder = regMissingA(name, "createdBy");
230 if (opLambda != null) {
231 opLambda.callback(builder);
232 }
233 if (aggsLambda != null) {
234 ThumbnailQueueCA ca = new ThumbnailQueueCA();
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<BsThumbnailQueueCA> aggsLambda) {
371 setCreatedTime_Histogram("createdTime", opLambda, aggsLambda);
372 }
373
374 public void setCreatedTime_Histogram(String name, ConditionOptionCall<HistogramAggregationBuilder> opLambda,
375 OperatorCall<BsThumbnailQueueCA> aggsLambda) {
376 HistogramAggregationBuilder builder = regHistogramA(name, "createdTime");
377 if (opLambda != null) {
378 opLambda.callback(builder);
379 }
380 if (aggsLambda != null) {
381 ThumbnailQueueCA ca = new ThumbnailQueueCA();
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<BsThumbnailQueueCA> aggsLambda) {
396 setCreatedTime_Range("createdTime", opLambda, aggsLambda);
397 }
398
399 public void setCreatedTime_Range(String name, ConditionOptionCall<RangeAggregationBuilder> opLambda,
400 OperatorCall<BsThumbnailQueueCA> aggsLambda) {
401 RangeAggregationBuilder builder = regRangeA(name, "createdTime");
402 if (opLambda != null) {
403 opLambda.callback(builder);
404 }
405 if (aggsLambda != null) {
406 ThumbnailQueueCA ca = new ThumbnailQueueCA();
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,
451 OperatorCall<BsThumbnailQueueCA> aggsLambda) {
452 setCreatedTime_Missing("createdTime", opLambda, aggsLambda);
453 }
454
455 public void setCreatedTime_Missing(String name, ConditionOptionCall<MissingAggregationBuilder> opLambda,
456 OperatorCall<BsThumbnailQueueCA> aggsLambda) {
457 MissingAggregationBuilder builder = regMissingA(name, "createdTime");
458 if (opLambda != null) {
459 opLambda.callback(builder);
460 }
461 if (aggsLambda != null) {
462 ThumbnailQueueCA ca = new ThumbnailQueueCA();
463 aggsLambda.callback(ca);
464 ca.getAggregationBuilderList().forEach(builder::subAggregation);
465 }
466 }
467
468 public void setGenerator_Terms() {
469 setGenerator_Terms(null);
470 }
471
472 public void setGenerator_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda) {
473 setGenerator_Terms("generator", opLambda, null);
474 }
475
476 public void setGenerator_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda, OperatorCall<BsThumbnailQueueCA> aggsLambda) {
477 setGenerator_Terms("generator", opLambda, aggsLambda);
478 }
479
480 public void setGenerator_Terms(String name, ConditionOptionCall<TermsAggregationBuilder> opLambda,
481 OperatorCall<BsThumbnailQueueCA> aggsLambda) {
482 TermsAggregationBuilder builder = regTermsA(name, "generator");
483 if (opLambda != null) {
484 opLambda.callback(builder);
485 }
486 if (aggsLambda != null) {
487 ThumbnailQueueCA ca = new ThumbnailQueueCA();
488 aggsLambda.callback(ca);
489 ca.getAggregationBuilderList().forEach(builder::subAggregation);
490 }
491 }
492
493 public void setGenerator_SignificantTerms() {
494 setGenerator_SignificantTerms(null);
495 }
496
497 public void setGenerator_SignificantTerms(ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda) {
498 setGenerator_SignificantTerms("generator", opLambda, null);
499 }
500
501 public void setGenerator_SignificantTerms(ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda,
502 OperatorCall<BsThumbnailQueueCA> aggsLambda) {
503 setGenerator_SignificantTerms("generator", opLambda, aggsLambda);
504 }
505
506 public void setGenerator_SignificantTerms(String name, ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda,
507 OperatorCall<BsThumbnailQueueCA> aggsLambda) {
508 SignificantTermsAggregationBuilder builder = regSignificantTermsA(name, "generator");
509 if (opLambda != null) {
510 opLambda.callback(builder);
511 }
512 if (aggsLambda != null) {
513 ThumbnailQueueCA ca = new ThumbnailQueueCA();
514 aggsLambda.callback(ca);
515 ca.getAggregationBuilderList().forEach(builder::subAggregation);
516 }
517 }
518
519 public void setGenerator_IpRange() {
520 setGenerator_IpRange(null);
521 }
522
523 public void setGenerator_IpRange(ConditionOptionCall<IpRangeAggregationBuilder> opLambda) {
524 setGenerator_IpRange("generator", opLambda, null);
525 }
526
527 public void setGenerator_IpRange(ConditionOptionCall<IpRangeAggregationBuilder> opLambda, OperatorCall<BsThumbnailQueueCA> aggsLambda) {
528 setGenerator_IpRange("generator", opLambda, aggsLambda);
529 }
530
531 public void setGenerator_IpRange(String name, ConditionOptionCall<IpRangeAggregationBuilder> opLambda,
532 OperatorCall<BsThumbnailQueueCA> aggsLambda) {
533 IpRangeAggregationBuilder builder = regIpRangeA(name, "generator");
534 if (opLambda != null) {
535 opLambda.callback(builder);
536 }
537 if (aggsLambda != null) {
538 ThumbnailQueueCA ca = new ThumbnailQueueCA();
539 aggsLambda.callback(ca);
540 ca.getAggregationBuilderList().forEach(builder::subAggregation);
541 }
542 }
543
544 public void setGenerator_Count() {
545 setGenerator_Count(null);
546 }
547
548 public void setGenerator_Count(ConditionOptionCall<ValueCountAggregationBuilder> opLambda) {
549 setGenerator_Count("generator", opLambda);
550 }
551
552 public void setGenerator_Count(String name, ConditionOptionCall<ValueCountAggregationBuilder> opLambda) {
553 ValueCountAggregationBuilder builder = regCountA(name, "generator");
554 if (opLambda != null) {
555 opLambda.callback(builder);
556 }
557 }
558
559 public void setGenerator_Cardinality() {
560 setGenerator_Cardinality(null);
561 }
562
563 public void setGenerator_Cardinality(ConditionOptionCall<CardinalityAggregationBuilder> opLambda) {
564 setGenerator_Cardinality("generator", opLambda);
565 }
566
567 public void setGenerator_Cardinality(String name, ConditionOptionCall<CardinalityAggregationBuilder> opLambda) {
568 CardinalityAggregationBuilder builder = regCardinalityA(name, "generator");
569 if (opLambda != null) {
570 opLambda.callback(builder);
571 }
572 }
573
574 public void setGenerator_Missing() {
575 setGenerator_Missing(null);
576 }
577
578 public void setGenerator_Missing(ConditionOptionCall<MissingAggregationBuilder> opLambda) {
579 setGenerator_Missing("generator", opLambda, null);
580 }
581
582 public void setGenerator_Missing(ConditionOptionCall<MissingAggregationBuilder> opLambda, OperatorCall<BsThumbnailQueueCA> aggsLambda) {
583 setGenerator_Missing("generator", opLambda, aggsLambda);
584 }
585
586 public void setGenerator_Missing(String name, ConditionOptionCall<MissingAggregationBuilder> opLambda,
587 OperatorCall<BsThumbnailQueueCA> aggsLambda) {
588 MissingAggregationBuilder builder = regMissingA(name, "generator");
589 if (opLambda != null) {
590 opLambda.callback(builder);
591 }
592 if (aggsLambda != null) {
593 ThumbnailQueueCA ca = new ThumbnailQueueCA();
594 aggsLambda.callback(ca);
595 ca.getAggregationBuilderList().forEach(builder::subAggregation);
596 }
597 }
598
599 public void setPath_Terms() {
600 setPath_Terms(null);
601 }
602
603 public void setPath_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda) {
604 setPath_Terms("path", opLambda, null);
605 }
606
607 public void setPath_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda, OperatorCall<BsThumbnailQueueCA> aggsLambda) {
608 setPath_Terms("path", opLambda, aggsLambda);
609 }
610
611 public void setPath_Terms(String name, ConditionOptionCall<TermsAggregationBuilder> opLambda,
612 OperatorCall<BsThumbnailQueueCA> aggsLambda) {
613 TermsAggregationBuilder builder = regTermsA(name, "path");
614 if (opLambda != null) {
615 opLambda.callback(builder);
616 }
617 if (aggsLambda != null) {
618 ThumbnailQueueCA ca = new ThumbnailQueueCA();
619 aggsLambda.callback(ca);
620 ca.getAggregationBuilderList().forEach(builder::subAggregation);
621 }
622 }
623
624 public void setPath_SignificantTerms() {
625 setPath_SignificantTerms(null);
626 }
627
628 public void setPath_SignificantTerms(ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda) {
629 setPath_SignificantTerms("path", opLambda, null);
630 }
631
632 public void setPath_SignificantTerms(ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda,
633 OperatorCall<BsThumbnailQueueCA> aggsLambda) {
634 setPath_SignificantTerms("path", opLambda, aggsLambda);
635 }
636
637 public void setPath_SignificantTerms(String name, ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda,
638 OperatorCall<BsThumbnailQueueCA> aggsLambda) {
639 SignificantTermsAggregationBuilder builder = regSignificantTermsA(name, "path");
640 if (opLambda != null) {
641 opLambda.callback(builder);
642 }
643 if (aggsLambda != null) {
644 ThumbnailQueueCA ca = new ThumbnailQueueCA();
645 aggsLambda.callback(ca);
646 ca.getAggregationBuilderList().forEach(builder::subAggregation);
647 }
648 }
649
650 public void setPath_IpRange() {
651 setPath_IpRange(null);
652 }
653
654 public void setPath_IpRange(ConditionOptionCall<IpRangeAggregationBuilder> opLambda) {
655 setPath_IpRange("path", opLambda, null);
656 }
657
658 public void setPath_IpRange(ConditionOptionCall<IpRangeAggregationBuilder> opLambda, OperatorCall<BsThumbnailQueueCA> aggsLambda) {
659 setPath_IpRange("path", opLambda, aggsLambda);
660 }
661
662 public void setPath_IpRange(String name, ConditionOptionCall<IpRangeAggregationBuilder> opLambda,
663 OperatorCall<BsThumbnailQueueCA> aggsLambda) {
664 IpRangeAggregationBuilder builder = regIpRangeA(name, "path");
665 if (opLambda != null) {
666 opLambda.callback(builder);
667 }
668 if (aggsLambda != null) {
669 ThumbnailQueueCA ca = new ThumbnailQueueCA();
670 aggsLambda.callback(ca);
671 ca.getAggregationBuilderList().forEach(builder::subAggregation);
672 }
673 }
674
675 public void setPath_Count() {
676 setPath_Count(null);
677 }
678
679 public void setPath_Count(ConditionOptionCall<ValueCountAggregationBuilder> opLambda) {
680 setPath_Count("path", opLambda);
681 }
682
683 public void setPath_Count(String name, ConditionOptionCall<ValueCountAggregationBuilder> opLambda) {
684 ValueCountAggregationBuilder builder = regCountA(name, "path");
685 if (opLambda != null) {
686 opLambda.callback(builder);
687 }
688 }
689
690 public void setPath_Cardinality() {
691 setPath_Cardinality(null);
692 }
693
694 public void setPath_Cardinality(ConditionOptionCall<CardinalityAggregationBuilder> opLambda) {
695 setPath_Cardinality("path", opLambda);
696 }
697
698 public void setPath_Cardinality(String name, ConditionOptionCall<CardinalityAggregationBuilder> opLambda) {
699 CardinalityAggregationBuilder builder = regCardinalityA(name, "path");
700 if (opLambda != null) {
701 opLambda.callback(builder);
702 }
703 }
704
705 public void setPath_Missing() {
706 setPath_Missing(null);
707 }
708
709 public void setPath_Missing(ConditionOptionCall<MissingAggregationBuilder> opLambda) {
710 setPath_Missing("path", opLambda, null);
711 }
712
713 public void setPath_Missing(ConditionOptionCall<MissingAggregationBuilder> opLambda, OperatorCall<BsThumbnailQueueCA> aggsLambda) {
714 setPath_Missing("path", opLambda, aggsLambda);
715 }
716
717 public void setPath_Missing(String name, ConditionOptionCall<MissingAggregationBuilder> opLambda,
718 OperatorCall<BsThumbnailQueueCA> aggsLambda) {
719 MissingAggregationBuilder builder = regMissingA(name, "path");
720 if (opLambda != null) {
721 opLambda.callback(builder);
722 }
723 if (aggsLambda != null) {
724 ThumbnailQueueCA ca = new ThumbnailQueueCA();
725 aggsLambda.callback(ca);
726 ca.getAggregationBuilderList().forEach(builder::subAggregation);
727 }
728 }
729
730 public void setTarget_Terms() {
731 setTarget_Terms(null);
732 }
733
734 public void setTarget_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda) {
735 setTarget_Terms("target", opLambda, null);
736 }
737
738 public void setTarget_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda, OperatorCall<BsThumbnailQueueCA> aggsLambda) {
739 setTarget_Terms("target", opLambda, aggsLambda);
740 }
741
742 public void setTarget_Terms(String name, ConditionOptionCall<TermsAggregationBuilder> opLambda,
743 OperatorCall<BsThumbnailQueueCA> aggsLambda) {
744 TermsAggregationBuilder builder = regTermsA(name, "target");
745 if (opLambda != null) {
746 opLambda.callback(builder);
747 }
748 if (aggsLambda != null) {
749 ThumbnailQueueCA ca = new ThumbnailQueueCA();
750 aggsLambda.callback(ca);
751 ca.getAggregationBuilderList().forEach(builder::subAggregation);
752 }
753 }
754
755 public void setTarget_SignificantTerms() {
756 setTarget_SignificantTerms(null);
757 }
758
759 public void setTarget_SignificantTerms(ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda) {
760 setTarget_SignificantTerms("target", opLambda, null);
761 }
762
763 public void setTarget_SignificantTerms(ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda,
764 OperatorCall<BsThumbnailQueueCA> aggsLambda) {
765 setTarget_SignificantTerms("target", opLambda, aggsLambda);
766 }
767
768 public void setTarget_SignificantTerms(String name, ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda,
769 OperatorCall<BsThumbnailQueueCA> aggsLambda) {
770 SignificantTermsAggregationBuilder builder = regSignificantTermsA(name, "target");
771 if (opLambda != null) {
772 opLambda.callback(builder);
773 }
774 if (aggsLambda != null) {
775 ThumbnailQueueCA ca = new ThumbnailQueueCA();
776 aggsLambda.callback(ca);
777 ca.getAggregationBuilderList().forEach(builder::subAggregation);
778 }
779 }
780
781 public void setTarget_IpRange() {
782 setTarget_IpRange(null);
783 }
784
785 public void setTarget_IpRange(ConditionOptionCall<IpRangeAggregationBuilder> opLambda) {
786 setTarget_IpRange("target", opLambda, null);
787 }
788
789 public void setTarget_IpRange(ConditionOptionCall<IpRangeAggregationBuilder> opLambda, OperatorCall<BsThumbnailQueueCA> aggsLambda) {
790 setTarget_IpRange("target", opLambda, aggsLambda);
791 }
792
793 public void setTarget_IpRange(String name, ConditionOptionCall<IpRangeAggregationBuilder> opLambda,
794 OperatorCall<BsThumbnailQueueCA> aggsLambda) {
795 IpRangeAggregationBuilder builder = regIpRangeA(name, "target");
796 if (opLambda != null) {
797 opLambda.callback(builder);
798 }
799 if (aggsLambda != null) {
800 ThumbnailQueueCA ca = new ThumbnailQueueCA();
801 aggsLambda.callback(ca);
802 ca.getAggregationBuilderList().forEach(builder::subAggregation);
803 }
804 }
805
806 public void setTarget_Count() {
807 setTarget_Count(null);
808 }
809
810 public void setTarget_Count(ConditionOptionCall<ValueCountAggregationBuilder> opLambda) {
811 setTarget_Count("target", opLambda);
812 }
813
814 public void setTarget_Count(String name, ConditionOptionCall<ValueCountAggregationBuilder> opLambda) {
815 ValueCountAggregationBuilder builder = regCountA(name, "target");
816 if (opLambda != null) {
817 opLambda.callback(builder);
818 }
819 }
820
821 public void setTarget_Cardinality() {
822 setTarget_Cardinality(null);
823 }
824
825 public void setTarget_Cardinality(ConditionOptionCall<CardinalityAggregationBuilder> opLambda) {
826 setTarget_Cardinality("target", opLambda);
827 }
828
829 public void setTarget_Cardinality(String name, ConditionOptionCall<CardinalityAggregationBuilder> opLambda) {
830 CardinalityAggregationBuilder builder = regCardinalityA(name, "target");
831 if (opLambda != null) {
832 opLambda.callback(builder);
833 }
834 }
835
836 public void setTarget_Missing() {
837 setTarget_Missing(null);
838 }
839
840 public void setTarget_Missing(ConditionOptionCall<MissingAggregationBuilder> opLambda) {
841 setTarget_Missing("target", opLambda, null);
842 }
843
844 public void setTarget_Missing(ConditionOptionCall<MissingAggregationBuilder> opLambda, OperatorCall<BsThumbnailQueueCA> aggsLambda) {
845 setTarget_Missing("target", opLambda, aggsLambda);
846 }
847
848 public void setTarget_Missing(String name, ConditionOptionCall<MissingAggregationBuilder> opLambda,
849 OperatorCall<BsThumbnailQueueCA> aggsLambda) {
850 MissingAggregationBuilder builder = regMissingA(name, "target");
851 if (opLambda != null) {
852 opLambda.callback(builder);
853 }
854 if (aggsLambda != null) {
855 ThumbnailQueueCA ca = new ThumbnailQueueCA();
856 aggsLambda.callback(ca);
857 ca.getAggregationBuilderList().forEach(builder::subAggregation);
858 }
859 }
860
861 public void setThumbnailId_Terms() {
862 setThumbnailId_Terms(null);
863 }
864
865 public void setThumbnailId_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda) {
866 setThumbnailId_Terms("thumbnail_id", opLambda, null);
867 }
868
869 public void setThumbnailId_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda, OperatorCall<BsThumbnailQueueCA> aggsLambda) {
870 setThumbnailId_Terms("thumbnail_id", opLambda, aggsLambda);
871 }
872
873 public void setThumbnailId_Terms(String name, ConditionOptionCall<TermsAggregationBuilder> opLambda,
874 OperatorCall<BsThumbnailQueueCA> aggsLambda) {
875 TermsAggregationBuilder builder = regTermsA(name, "thumbnail_id");
876 if (opLambda != null) {
877 opLambda.callback(builder);
878 }
879 if (aggsLambda != null) {
880 ThumbnailQueueCA ca = new ThumbnailQueueCA();
881 aggsLambda.callback(ca);
882 ca.getAggregationBuilderList().forEach(builder::subAggregation);
883 }
884 }
885
886 public void setThumbnailId_SignificantTerms() {
887 setThumbnailId_SignificantTerms(null);
888 }
889
890 public void setThumbnailId_SignificantTerms(ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda) {
891 setThumbnailId_SignificantTerms("thumbnail_id", opLambda, null);
892 }
893
894 public void setThumbnailId_SignificantTerms(ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda,
895 OperatorCall<BsThumbnailQueueCA> aggsLambda) {
896 setThumbnailId_SignificantTerms("thumbnail_id", opLambda, aggsLambda);
897 }
898
899 public void setThumbnailId_SignificantTerms(String name, ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda,
900 OperatorCall<BsThumbnailQueueCA> aggsLambda) {
901 SignificantTermsAggregationBuilder builder = regSignificantTermsA(name, "thumbnail_id");
902 if (opLambda != null) {
903 opLambda.callback(builder);
904 }
905 if (aggsLambda != null) {
906 ThumbnailQueueCA ca = new ThumbnailQueueCA();
907 aggsLambda.callback(ca);
908 ca.getAggregationBuilderList().forEach(builder::subAggregation);
909 }
910 }
911
912 public void setThumbnailId_IpRange() {
913 setThumbnailId_IpRange(null);
914 }
915
916 public void setThumbnailId_IpRange(ConditionOptionCall<IpRangeAggregationBuilder> opLambda) {
917 setThumbnailId_IpRange("thumbnail_id", opLambda, null);
918 }
919
920 public void setThumbnailId_IpRange(ConditionOptionCall<IpRangeAggregationBuilder> opLambda,
921 OperatorCall<BsThumbnailQueueCA> aggsLambda) {
922 setThumbnailId_IpRange("thumbnail_id", opLambda, aggsLambda);
923 }
924
925 public void setThumbnailId_IpRange(String name, ConditionOptionCall<IpRangeAggregationBuilder> opLambda,
926 OperatorCall<BsThumbnailQueueCA> aggsLambda) {
927 IpRangeAggregationBuilder builder = regIpRangeA(name, "thumbnail_id");
928 if (opLambda != null) {
929 opLambda.callback(builder);
930 }
931 if (aggsLambda != null) {
932 ThumbnailQueueCA ca = new ThumbnailQueueCA();
933 aggsLambda.callback(ca);
934 ca.getAggregationBuilderList().forEach(builder::subAggregation);
935 }
936 }
937
938 public void setThumbnailId_Count() {
939 setThumbnailId_Count(null);
940 }
941
942 public void setThumbnailId_Count(ConditionOptionCall<ValueCountAggregationBuilder> opLambda) {
943 setThumbnailId_Count("thumbnail_id", opLambda);
944 }
945
946 public void setThumbnailId_Count(String name, ConditionOptionCall<ValueCountAggregationBuilder> opLambda) {
947 ValueCountAggregationBuilder builder = regCountA(name, "thumbnail_id");
948 if (opLambda != null) {
949 opLambda.callback(builder);
950 }
951 }
952
953 public void setThumbnailId_Cardinality() {
954 setThumbnailId_Cardinality(null);
955 }
956
957 public void setThumbnailId_Cardinality(ConditionOptionCall<CardinalityAggregationBuilder> opLambda) {
958 setThumbnailId_Cardinality("thumbnail_id", opLambda);
959 }
960
961 public void setThumbnailId_Cardinality(String name, ConditionOptionCall<CardinalityAggregationBuilder> opLambda) {
962 CardinalityAggregationBuilder builder = regCardinalityA(name, "thumbnail_id");
963 if (opLambda != null) {
964 opLambda.callback(builder);
965 }
966 }
967
968 public void setThumbnailId_Missing() {
969 setThumbnailId_Missing(null);
970 }
971
972 public void setThumbnailId_Missing(ConditionOptionCall<MissingAggregationBuilder> opLambda) {
973 setThumbnailId_Missing("thumbnail_id", opLambda, null);
974 }
975
976 public void setThumbnailId_Missing(ConditionOptionCall<MissingAggregationBuilder> opLambda,
977 OperatorCall<BsThumbnailQueueCA> aggsLambda) {
978 setThumbnailId_Missing("thumbnail_id", opLambda, aggsLambda);
979 }
980
981 public void setThumbnailId_Missing(String name, ConditionOptionCall<MissingAggregationBuilder> opLambda,
982 OperatorCall<BsThumbnailQueueCA> aggsLambda) {
983 MissingAggregationBuilder builder = regMissingA(name, "thumbnail_id");
984 if (opLambda != null) {
985 opLambda.callback(builder);
986 }
987 if (aggsLambda != null) {
988 ThumbnailQueueCA ca = new ThumbnailQueueCA();
989 aggsLambda.callback(ca);
990 ca.getAggregationBuilderList().forEach(builder::subAggregation);
991 }
992 }
993
994 }