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