View Javadoc
1   /*
2    * Copyright 2012-2025 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.opensearch.config.cbean.cq.bs;
17  
18  import java.time.LocalDateTime;
19  import java.util.ArrayList;
20  import java.util.Collection;
21  
22  import org.codelibs.fess.opensearch.config.allcommon.EsAbstractConditionQuery;
23  import org.codelibs.fess.opensearch.config.cbean.cq.PathMappingCQ;
24  import org.dbflute.cbean.ckey.ConditionKey;
25  import org.opensearch.index.query.BoolQueryBuilder;
26  import org.opensearch.index.query.CommonTermsQueryBuilder;
27  import org.opensearch.index.query.ExistsQueryBuilder;
28  import org.opensearch.index.query.IdsQueryBuilder;
29  import org.opensearch.index.query.MatchPhrasePrefixQueryBuilder;
30  import org.opensearch.index.query.MatchPhraseQueryBuilder;
31  import org.opensearch.index.query.MatchQueryBuilder;
32  import org.opensearch.index.query.PrefixQueryBuilder;
33  import org.opensearch.index.query.RangeQueryBuilder;
34  import org.opensearch.index.query.RegexpQueryBuilder;
35  import org.opensearch.index.query.SpanTermQueryBuilder;
36  import org.opensearch.index.query.TermQueryBuilder;
37  import org.opensearch.index.query.TermsQueryBuilder;
38  import org.opensearch.index.query.WildcardQueryBuilder;
39  import org.opensearch.index.query.functionscore.FunctionScoreQueryBuilder;
40  import org.opensearch.index.query.functionscore.FunctionScoreQueryBuilder.FilterFunctionBuilder;
41  
42  /**
43   * @author ESFlute (using FreeGen)
44   */
45  public abstract class BsPathMappingCQ extends EsAbstractConditionQuery {
46  
47      protected static final Class<?> suppressUnusedImportLocalDateTime = LocalDateTime.class;
48  
49      // ===================================================================================
50      //                                                                       Name Override
51      //                                                                       =============
52      @Override
53      public String asTableDbName() {
54          return "path_mapping";
55      }
56  
57      @Override
58      public String xgetAliasName() {
59          return "path_mapping";
60      }
61  
62      // ===================================================================================
63      //                                                                       Query Control
64      //                                                                       =============
65      public void functionScore(OperatorCall<PathMappingCQ> queryLambda,
66              ScoreFunctionCall<ScoreFunctionCreator<PathMappingCQ>> functionsLambda,
67              final ConditionOptionCall<FunctionScoreQueryBuilder> opLambda) {
68          PathMappingCQ cq = new PathMappingCQ();
69          queryLambda.callback(cq);
70          final Collection<FilterFunctionBuilder> list = new ArrayList<>();
71          if (functionsLambda != null) {
72              functionsLambda.callback((cqLambda, scoreFunctionBuilder) -> {
73                  PathMappingCQ cf = new PathMappingCQ();
74                  cqLambda.callback(cf);
75                  list.add(new FilterFunctionBuilder(cf.getQuery(), scoreFunctionBuilder));
76              });
77          }
78          final FunctionScoreQueryBuilder builder = regFunctionScoreQ(cq.getQuery(), list);
79          if (opLambda != null) {
80              opLambda.callback(builder);
81          }
82      }
83  
84      public void filtered(FilteredCall<PathMappingCQ, PathMappingCQ> filteredLambda) {
85          filtered(filteredLambda, null);
86      }
87  
88      public void filtered(FilteredCall<PathMappingCQ, PathMappingCQ> filteredLambda, ConditionOptionCall<BoolQueryBuilder> opLambda) {
89          bool((must, should, mustNot, filter) -> {
90              filteredLambda.callback(must, filter);
91          }, opLambda);
92      }
93  
94      public void not(OperatorCall<PathMappingCQ> notLambda) {
95          not(notLambda, null);
96      }
97  
98      public void not(final OperatorCall<PathMappingCQ> notLambda, final ConditionOptionCall<BoolQueryBuilder> opLambda) {
99          bool((must, should, mustNot, filter) -> notLambda.callback(mustNot), opLambda);
100     }
101 
102     public void bool(BoolCall<PathMappingCQ> boolLambda) {
103         bool(boolLambda, null);
104     }
105 
106     public void bool(BoolCall<PathMappingCQ> boolLambda, ConditionOptionCall<BoolQueryBuilder> opLambda) {
107         PathMappingCQ mustQuery = new PathMappingCQ();
108         PathMappingCQ shouldQuery = new PathMappingCQ();
109         PathMappingCQ mustNotQuery = new PathMappingCQ();
110         PathMappingCQ filterQuery = new PathMappingCQ();
111         boolLambda.callback(mustQuery, shouldQuery, mustNotQuery, filterQuery);
112         if (mustQuery.hasQueries() || shouldQuery.hasQueries() || mustNotQuery.hasQueries() || filterQuery.hasQueries()) {
113             BoolQueryBuilder builder = regBoolCQ(mustQuery.getQueryBuilderList(), shouldQuery.getQueryBuilderList(),
114                     mustNotQuery.getQueryBuilderList(), filterQuery.getQueryBuilderList());
115             if (opLambda != null) {
116                 opLambda.callback(builder);
117             }
118         }
119     }
120 
121     // ===================================================================================
122     //                                                                           Query Set
123     //                                                                           =========
124     public void setId_Equal(String id) {
125         setId_Term(id, null);
126     }
127 
128     public void setId_Equal(String id, ConditionOptionCall<TermQueryBuilder> opLambda) {
129         setId_Term(id, opLambda);
130     }
131 
132     public void setId_Term(String id) {
133         setId_Term(id, null);
134     }
135 
136     public void setId_Term(String id, ConditionOptionCall<TermQueryBuilder> opLambda) {
137         TermQueryBuilder builder = regTermQ("_id", id);
138         if (opLambda != null) {
139             opLambda.callback(builder);
140         }
141     }
142 
143     public void setId_NotEqual(String id) {
144         setId_NotTerm(id, null);
145     }
146 
147     public void setId_NotTerm(String id) {
148         setId_NotTerm(id, null);
149     }
150 
151     public void setId_NotEqual(String id, ConditionOptionCall<BoolQueryBuilder> opLambda) {
152         setId_NotTerm(id, opLambda);
153     }
154 
155     public void setId_NotTerm(String id, ConditionOptionCall<BoolQueryBuilder> opLambda) {
156         not(not -> not.setId_Term(id), opLambda);
157     }
158 
159     public void setId_Terms(Collection<String> idList) {
160         setId_Terms(idList, null);
161     }
162 
163     public void setId_Terms(Collection<String> idList, ConditionOptionCall<IdsQueryBuilder> opLambda) {
164         IdsQueryBuilder builder = regIdsQ(idList);
165         if (opLambda != null) {
166             opLambda.callback(builder);
167         }
168     }
169 
170     public void setId_InScope(Collection<String> idList) {
171         setId_Terms(idList, null);
172     }
173 
174     public void setId_InScope(Collection<String> idList, ConditionOptionCall<IdsQueryBuilder> opLambda) {
175         setId_Terms(idList, opLambda);
176     }
177 
178     @Deprecated
179     public BsPathMappingCQ addOrderBy_Id_Asc() {
180         regOBA("_id");
181         return this;
182     }
183 
184     @Deprecated
185     public BsPathMappingCQ addOrderBy_Id_Desc() {
186         regOBD("_id");
187         return this;
188     }
189 
190     public void setCreatedBy_Equal(String createdBy) {
191         setCreatedBy_Term(createdBy, null);
192     }
193 
194     public void setCreatedBy_Equal(String createdBy, ConditionOptionCall<TermQueryBuilder> opLambda) {
195         setCreatedBy_Term(createdBy, opLambda);
196     }
197 
198     public void setCreatedBy_Term(String createdBy) {
199         setCreatedBy_Term(createdBy, null);
200     }
201 
202     public void setCreatedBy_Term(String createdBy, ConditionOptionCall<TermQueryBuilder> opLambda) {
203         TermQueryBuilder builder = regTermQ("createdBy", createdBy);
204         if (opLambda != null) {
205             opLambda.callback(builder);
206         }
207     }
208 
209     public void setCreatedBy_NotEqual(String createdBy) {
210         setCreatedBy_NotTerm(createdBy, null);
211     }
212 
213     public void setCreatedBy_NotTerm(String createdBy) {
214         setCreatedBy_NotTerm(createdBy, null);
215     }
216 
217     public void setCreatedBy_NotEqual(String createdBy, ConditionOptionCall<BoolQueryBuilder> opLambda) {
218         setCreatedBy_NotTerm(createdBy, opLambda);
219     }
220 
221     public void setCreatedBy_NotTerm(String createdBy, ConditionOptionCall<BoolQueryBuilder> opLambda) {
222         not(not -> not.setCreatedBy_Term(createdBy), opLambda);
223     }
224 
225     public void setCreatedBy_Terms(Collection<String> createdByList) {
226         setCreatedBy_Terms(createdByList, null);
227     }
228 
229     public void setCreatedBy_Terms(Collection<String> createdByList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
230         TermsQueryBuilder builder = regTermsQ("createdBy", createdByList);
231         if (opLambda != null) {
232             opLambda.callback(builder);
233         }
234     }
235 
236     public void setCreatedBy_InScope(Collection<String> createdByList) {
237         setCreatedBy_Terms(createdByList, null);
238     }
239 
240     public void setCreatedBy_InScope(Collection<String> createdByList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
241         setCreatedBy_Terms(createdByList, opLambda);
242     }
243 
244     public void setCreatedBy_Match(String createdBy) {
245         setCreatedBy_Match(createdBy, null);
246     }
247 
248     public void setCreatedBy_Match(String createdBy, ConditionOptionCall<MatchQueryBuilder> opLambda) {
249         MatchQueryBuilder builder = regMatchQ("createdBy", createdBy);
250         if (opLambda != null) {
251             opLambda.callback(builder);
252         }
253     }
254 
255     public void setCreatedBy_MatchPhrase(String createdBy) {
256         setCreatedBy_MatchPhrase(createdBy, null);
257     }
258 
259     public void setCreatedBy_MatchPhrase(String createdBy, ConditionOptionCall<MatchPhraseQueryBuilder> opLambda) {
260         MatchPhraseQueryBuilder builder = regMatchPhraseQ("createdBy", createdBy);
261         if (opLambda != null) {
262             opLambda.callback(builder);
263         }
264     }
265 
266     public void setCreatedBy_MatchPhrasePrefix(String createdBy) {
267         setCreatedBy_MatchPhrasePrefix(createdBy, null);
268     }
269 
270     public void setCreatedBy_MatchPhrasePrefix(String createdBy, ConditionOptionCall<MatchPhrasePrefixQueryBuilder> opLambda) {
271         MatchPhrasePrefixQueryBuilder builder = regMatchPhrasePrefixQ("createdBy", createdBy);
272         if (opLambda != null) {
273             opLambda.callback(builder);
274         }
275     }
276 
277     public void setCreatedBy_Fuzzy(String createdBy) {
278         setCreatedBy_Fuzzy(createdBy, null);
279     }
280 
281     public void setCreatedBy_Fuzzy(String createdBy, ConditionOptionCall<MatchQueryBuilder> opLambda) {
282         MatchQueryBuilder builder = regFuzzyQ("createdBy", createdBy);
283         if (opLambda != null) {
284             opLambda.callback(builder);
285         }
286     }
287 
288     public void setCreatedBy_Prefix(String createdBy) {
289         setCreatedBy_Prefix(createdBy, null);
290     }
291 
292     public void setCreatedBy_Prefix(String createdBy, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
293         PrefixQueryBuilder builder = regPrefixQ("createdBy", createdBy);
294         if (opLambda != null) {
295             opLambda.callback(builder);
296         }
297     }
298 
299     public void setCreatedBy_Wildcard(String createdBy) {
300         setCreatedBy_Wildcard(createdBy, null);
301     }
302 
303     public void setCreatedBy_Wildcard(String createdBy, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
304         WildcardQueryBuilder builder = regWildcardQ("createdBy", createdBy);
305         if (opLambda != null) {
306             opLambda.callback(builder);
307         }
308     }
309 
310     public void setCreatedBy_Regexp(String createdBy) {
311         setCreatedBy_Regexp(createdBy, null);
312     }
313 
314     public void setCreatedBy_Regexp(String createdBy, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
315         RegexpQueryBuilder builder = regRegexpQ("createdBy", createdBy);
316         if (opLambda != null) {
317             opLambda.callback(builder);
318         }
319     }
320 
321     public void setCreatedBy_SpanTerm(String createdBy) {
322         setCreatedBy_SpanTerm("createdBy", null);
323     }
324 
325     public void setCreatedBy_SpanTerm(String createdBy, ConditionOptionCall<SpanTermQueryBuilder> opLambda) {
326         SpanTermQueryBuilder builder = regSpanTermQ("createdBy", createdBy);
327         if (opLambda != null) {
328             opLambda.callback(builder);
329         }
330     }
331 
332     public void setCreatedBy_GreaterThan(String createdBy) {
333         setCreatedBy_GreaterThan(createdBy, null);
334     }
335 
336     public void setCreatedBy_GreaterThan(String createdBy, ConditionOptionCall<RangeQueryBuilder> opLambda) {
337         final Object _value = createdBy;
338         RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_GREATER_THAN, _value);
339         if (opLambda != null) {
340             opLambda.callback(builder);
341         }
342     }
343 
344     public void setCreatedBy_LessThan(String createdBy) {
345         setCreatedBy_LessThan(createdBy, null);
346     }
347 
348     public void setCreatedBy_LessThan(String createdBy, ConditionOptionCall<RangeQueryBuilder> opLambda) {
349         final Object _value = createdBy;
350         RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_LESS_THAN, _value);
351         if (opLambda != null) {
352             opLambda.callback(builder);
353         }
354     }
355 
356     public void setCreatedBy_GreaterEqual(String createdBy) {
357         setCreatedBy_GreaterEqual(createdBy, null);
358     }
359 
360     public void setCreatedBy_GreaterEqual(String createdBy, ConditionOptionCall<RangeQueryBuilder> opLambda) {
361         final Object _value = createdBy;
362         RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_GREATER_EQUAL, _value);
363         if (opLambda != null) {
364             opLambda.callback(builder);
365         }
366     }
367 
368     public void setCreatedBy_LessEqual(String createdBy) {
369         setCreatedBy_LessEqual(createdBy, null);
370     }
371 
372     public void setCreatedBy_LessEqual(String createdBy, ConditionOptionCall<RangeQueryBuilder> opLambda) {
373         final Object _value = createdBy;
374         RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_LESS_EQUAL, _value);
375         if (opLambda != null) {
376             opLambda.callback(builder);
377         }
378     }
379 
380     public void setCreatedBy_Exists() {
381         setCreatedBy_Exists(null);
382     }
383 
384     public void setCreatedBy_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
385         ExistsQueryBuilder builder = regExistsQ("createdBy");
386         if (opLambda != null) {
387             opLambda.callback(builder);
388         }
389     }
390 
391     @Deprecated
392     public void setCreatedBy_CommonTerms(String createdBy) {
393         setCreatedBy_CommonTerms(createdBy, null);
394     }
395 
396     @Deprecated
397     public void setCreatedBy_CommonTerms(String createdBy, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
398         CommonTermsQueryBuilder builder = regCommonTermsQ("createdBy", createdBy);
399         if (opLambda != null) {
400             opLambda.callback(builder);
401         }
402     }
403 
404     public BsPathMappingCQ addOrderBy_CreatedBy_Asc() {
405         regOBA("createdBy");
406         return this;
407     }
408 
409     public BsPathMappingCQ addOrderBy_CreatedBy_Desc() {
410         regOBD("createdBy");
411         return this;
412     }
413 
414     public void setCreatedTime_Equal(Long createdTime) {
415         setCreatedTime_Term(createdTime, null);
416     }
417 
418     public void setCreatedTime_Equal(Long createdTime, ConditionOptionCall<TermQueryBuilder> opLambda) {
419         setCreatedTime_Term(createdTime, opLambda);
420     }
421 
422     public void setCreatedTime_Term(Long createdTime) {
423         setCreatedTime_Term(createdTime, null);
424     }
425 
426     public void setCreatedTime_Term(Long createdTime, ConditionOptionCall<TermQueryBuilder> opLambda) {
427         TermQueryBuilder builder = regTermQ("createdTime", createdTime);
428         if (opLambda != null) {
429             opLambda.callback(builder);
430         }
431     }
432 
433     public void setCreatedTime_NotEqual(Long createdTime) {
434         setCreatedTime_NotTerm(createdTime, null);
435     }
436 
437     public void setCreatedTime_NotTerm(Long createdTime) {
438         setCreatedTime_NotTerm(createdTime, null);
439     }
440 
441     public void setCreatedTime_NotEqual(Long createdTime, ConditionOptionCall<BoolQueryBuilder> opLambda) {
442         setCreatedTime_NotTerm(createdTime, opLambda);
443     }
444 
445     public void setCreatedTime_NotTerm(Long createdTime, ConditionOptionCall<BoolQueryBuilder> opLambda) {
446         not(not -> not.setCreatedTime_Term(createdTime), opLambda);
447     }
448 
449     public void setCreatedTime_Terms(Collection<Long> createdTimeList) {
450         setCreatedTime_Terms(createdTimeList, null);
451     }
452 
453     public void setCreatedTime_Terms(Collection<Long> createdTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
454         TermsQueryBuilder builder = regTermsQ("createdTime", createdTimeList);
455         if (opLambda != null) {
456             opLambda.callback(builder);
457         }
458     }
459 
460     public void setCreatedTime_InScope(Collection<Long> createdTimeList) {
461         setCreatedTime_Terms(createdTimeList, null);
462     }
463 
464     public void setCreatedTime_InScope(Collection<Long> createdTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
465         setCreatedTime_Terms(createdTimeList, opLambda);
466     }
467 
468     public void setCreatedTime_Match(Long createdTime) {
469         setCreatedTime_Match(createdTime, null);
470     }
471 
472     public void setCreatedTime_Match(Long createdTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
473         MatchQueryBuilder builder = regMatchQ("createdTime", createdTime);
474         if (opLambda != null) {
475             opLambda.callback(builder);
476         }
477     }
478 
479     public void setCreatedTime_MatchPhrase(Long createdTime) {
480         setCreatedTime_MatchPhrase(createdTime, null);
481     }
482 
483     public void setCreatedTime_MatchPhrase(Long createdTime, ConditionOptionCall<MatchPhraseQueryBuilder> opLambda) {
484         MatchPhraseQueryBuilder builder = regMatchPhraseQ("createdTime", createdTime);
485         if (opLambda != null) {
486             opLambda.callback(builder);
487         }
488     }
489 
490     public void setCreatedTime_MatchPhrasePrefix(Long createdTime) {
491         setCreatedTime_MatchPhrasePrefix(createdTime, null);
492     }
493 
494     public void setCreatedTime_MatchPhrasePrefix(Long createdTime, ConditionOptionCall<MatchPhrasePrefixQueryBuilder> opLambda) {
495         MatchPhrasePrefixQueryBuilder builder = regMatchPhrasePrefixQ("createdTime", createdTime);
496         if (opLambda != null) {
497             opLambda.callback(builder);
498         }
499     }
500 
501     public void setCreatedTime_Fuzzy(Long createdTime) {
502         setCreatedTime_Fuzzy(createdTime, null);
503     }
504 
505     public void setCreatedTime_Fuzzy(Long createdTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
506         MatchQueryBuilder builder = regFuzzyQ("createdTime", createdTime);
507         if (opLambda != null) {
508             opLambda.callback(builder);
509         }
510     }
511 
512     public void setCreatedTime_GreaterThan(Long createdTime) {
513         setCreatedTime_GreaterThan(createdTime, null);
514     }
515 
516     public void setCreatedTime_GreaterThan(Long createdTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
517         final Object _value = createdTime;
518         RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_GREATER_THAN, _value);
519         if (opLambda != null) {
520             opLambda.callback(builder);
521         }
522     }
523 
524     public void setCreatedTime_LessThan(Long createdTime) {
525         setCreatedTime_LessThan(createdTime, null);
526     }
527 
528     public void setCreatedTime_LessThan(Long createdTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
529         final Object _value = createdTime;
530         RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_LESS_THAN, _value);
531         if (opLambda != null) {
532             opLambda.callback(builder);
533         }
534     }
535 
536     public void setCreatedTime_GreaterEqual(Long createdTime) {
537         setCreatedTime_GreaterEqual(createdTime, null);
538     }
539 
540     public void setCreatedTime_GreaterEqual(Long createdTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
541         final Object _value = createdTime;
542         RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_GREATER_EQUAL, _value);
543         if (opLambda != null) {
544             opLambda.callback(builder);
545         }
546     }
547 
548     public void setCreatedTime_LessEqual(Long createdTime) {
549         setCreatedTime_LessEqual(createdTime, null);
550     }
551 
552     public void setCreatedTime_LessEqual(Long createdTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
553         final Object _value = createdTime;
554         RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_LESS_EQUAL, _value);
555         if (opLambda != null) {
556             opLambda.callback(builder);
557         }
558     }
559 
560     public void setCreatedTime_Exists() {
561         setCreatedTime_Exists(null);
562     }
563 
564     public void setCreatedTime_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
565         ExistsQueryBuilder builder = regExistsQ("createdTime");
566         if (opLambda != null) {
567             opLambda.callback(builder);
568         }
569     }
570 
571     @Deprecated
572     public void setCreatedTime_CommonTerms(Long createdTime) {
573         setCreatedTime_CommonTerms(createdTime, null);
574     }
575 
576     @Deprecated
577     public void setCreatedTime_CommonTerms(Long createdTime, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
578         CommonTermsQueryBuilder builder = regCommonTermsQ("createdTime", createdTime);
579         if (opLambda != null) {
580             opLambda.callback(builder);
581         }
582     }
583 
584     public BsPathMappingCQ addOrderBy_CreatedTime_Asc() {
585         regOBA("createdTime");
586         return this;
587     }
588 
589     public BsPathMappingCQ addOrderBy_CreatedTime_Desc() {
590         regOBD("createdTime");
591         return this;
592     }
593 
594     public void setProcessType_Equal(String processType) {
595         setProcessType_Term(processType, null);
596     }
597 
598     public void setProcessType_Equal(String processType, ConditionOptionCall<TermQueryBuilder> opLambda) {
599         setProcessType_Term(processType, opLambda);
600     }
601 
602     public void setProcessType_Term(String processType) {
603         setProcessType_Term(processType, null);
604     }
605 
606     public void setProcessType_Term(String processType, ConditionOptionCall<TermQueryBuilder> opLambda) {
607         TermQueryBuilder builder = regTermQ("processType", processType);
608         if (opLambda != null) {
609             opLambda.callback(builder);
610         }
611     }
612 
613     public void setProcessType_NotEqual(String processType) {
614         setProcessType_NotTerm(processType, null);
615     }
616 
617     public void setProcessType_NotTerm(String processType) {
618         setProcessType_NotTerm(processType, null);
619     }
620 
621     public void setProcessType_NotEqual(String processType, ConditionOptionCall<BoolQueryBuilder> opLambda) {
622         setProcessType_NotTerm(processType, opLambda);
623     }
624 
625     public void setProcessType_NotTerm(String processType, ConditionOptionCall<BoolQueryBuilder> opLambda) {
626         not(not -> not.setProcessType_Term(processType), opLambda);
627     }
628 
629     public void setProcessType_Terms(Collection<String> processTypeList) {
630         setProcessType_Terms(processTypeList, null);
631     }
632 
633     public void setProcessType_Terms(Collection<String> processTypeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
634         TermsQueryBuilder builder = regTermsQ("processType", processTypeList);
635         if (opLambda != null) {
636             opLambda.callback(builder);
637         }
638     }
639 
640     public void setProcessType_InScope(Collection<String> processTypeList) {
641         setProcessType_Terms(processTypeList, null);
642     }
643 
644     public void setProcessType_InScope(Collection<String> processTypeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
645         setProcessType_Terms(processTypeList, opLambda);
646     }
647 
648     public void setProcessType_Match(String processType) {
649         setProcessType_Match(processType, null);
650     }
651 
652     public void setProcessType_Match(String processType, ConditionOptionCall<MatchQueryBuilder> opLambda) {
653         MatchQueryBuilder builder = regMatchQ("processType", processType);
654         if (opLambda != null) {
655             opLambda.callback(builder);
656         }
657     }
658 
659     public void setProcessType_MatchPhrase(String processType) {
660         setProcessType_MatchPhrase(processType, null);
661     }
662 
663     public void setProcessType_MatchPhrase(String processType, ConditionOptionCall<MatchPhraseQueryBuilder> opLambda) {
664         MatchPhraseQueryBuilder builder = regMatchPhraseQ("processType", processType);
665         if (opLambda != null) {
666             opLambda.callback(builder);
667         }
668     }
669 
670     public void setProcessType_MatchPhrasePrefix(String processType) {
671         setProcessType_MatchPhrasePrefix(processType, null);
672     }
673 
674     public void setProcessType_MatchPhrasePrefix(String processType, ConditionOptionCall<MatchPhrasePrefixQueryBuilder> opLambda) {
675         MatchPhrasePrefixQueryBuilder builder = regMatchPhrasePrefixQ("processType", processType);
676         if (opLambda != null) {
677             opLambda.callback(builder);
678         }
679     }
680 
681     public void setProcessType_Fuzzy(String processType) {
682         setProcessType_Fuzzy(processType, null);
683     }
684 
685     public void setProcessType_Fuzzy(String processType, ConditionOptionCall<MatchQueryBuilder> opLambda) {
686         MatchQueryBuilder builder = regFuzzyQ("processType", processType);
687         if (opLambda != null) {
688             opLambda.callback(builder);
689         }
690     }
691 
692     public void setProcessType_Prefix(String processType) {
693         setProcessType_Prefix(processType, null);
694     }
695 
696     public void setProcessType_Prefix(String processType, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
697         PrefixQueryBuilder builder = regPrefixQ("processType", processType);
698         if (opLambda != null) {
699             opLambda.callback(builder);
700         }
701     }
702 
703     public void setProcessType_Wildcard(String processType) {
704         setProcessType_Wildcard(processType, null);
705     }
706 
707     public void setProcessType_Wildcard(String processType, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
708         WildcardQueryBuilder builder = regWildcardQ("processType", processType);
709         if (opLambda != null) {
710             opLambda.callback(builder);
711         }
712     }
713 
714     public void setProcessType_Regexp(String processType) {
715         setProcessType_Regexp(processType, null);
716     }
717 
718     public void setProcessType_Regexp(String processType, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
719         RegexpQueryBuilder builder = regRegexpQ("processType", processType);
720         if (opLambda != null) {
721             opLambda.callback(builder);
722         }
723     }
724 
725     public void setProcessType_SpanTerm(String processType) {
726         setProcessType_SpanTerm("processType", null);
727     }
728 
729     public void setProcessType_SpanTerm(String processType, ConditionOptionCall<SpanTermQueryBuilder> opLambda) {
730         SpanTermQueryBuilder builder = regSpanTermQ("processType", processType);
731         if (opLambda != null) {
732             opLambda.callback(builder);
733         }
734     }
735 
736     public void setProcessType_GreaterThan(String processType) {
737         setProcessType_GreaterThan(processType, null);
738     }
739 
740     public void setProcessType_GreaterThan(String processType, ConditionOptionCall<RangeQueryBuilder> opLambda) {
741         final Object _value = processType;
742         RangeQueryBuilder builder = regRangeQ("processType", ConditionKey.CK_GREATER_THAN, _value);
743         if (opLambda != null) {
744             opLambda.callback(builder);
745         }
746     }
747 
748     public void setProcessType_LessThan(String processType) {
749         setProcessType_LessThan(processType, null);
750     }
751 
752     public void setProcessType_LessThan(String processType, ConditionOptionCall<RangeQueryBuilder> opLambda) {
753         final Object _value = processType;
754         RangeQueryBuilder builder = regRangeQ("processType", ConditionKey.CK_LESS_THAN, _value);
755         if (opLambda != null) {
756             opLambda.callback(builder);
757         }
758     }
759 
760     public void setProcessType_GreaterEqual(String processType) {
761         setProcessType_GreaterEqual(processType, null);
762     }
763 
764     public void setProcessType_GreaterEqual(String processType, ConditionOptionCall<RangeQueryBuilder> opLambda) {
765         final Object _value = processType;
766         RangeQueryBuilder builder = regRangeQ("processType", ConditionKey.CK_GREATER_EQUAL, _value);
767         if (opLambda != null) {
768             opLambda.callback(builder);
769         }
770     }
771 
772     public void setProcessType_LessEqual(String processType) {
773         setProcessType_LessEqual(processType, null);
774     }
775 
776     public void setProcessType_LessEqual(String processType, ConditionOptionCall<RangeQueryBuilder> opLambda) {
777         final Object _value = processType;
778         RangeQueryBuilder builder = regRangeQ("processType", ConditionKey.CK_LESS_EQUAL, _value);
779         if (opLambda != null) {
780             opLambda.callback(builder);
781         }
782     }
783 
784     public void setProcessType_Exists() {
785         setProcessType_Exists(null);
786     }
787 
788     public void setProcessType_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
789         ExistsQueryBuilder builder = regExistsQ("processType");
790         if (opLambda != null) {
791             opLambda.callback(builder);
792         }
793     }
794 
795     @Deprecated
796     public void setProcessType_CommonTerms(String processType) {
797         setProcessType_CommonTerms(processType, null);
798     }
799 
800     @Deprecated
801     public void setProcessType_CommonTerms(String processType, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
802         CommonTermsQueryBuilder builder = regCommonTermsQ("processType", processType);
803         if (opLambda != null) {
804             opLambda.callback(builder);
805         }
806     }
807 
808     public BsPathMappingCQ addOrderBy_ProcessType_Asc() {
809         regOBA("processType");
810         return this;
811     }
812 
813     public BsPathMappingCQ addOrderBy_ProcessType_Desc() {
814         regOBD("processType");
815         return this;
816     }
817 
818     public void setRegex_Equal(String regex) {
819         setRegex_Term(regex, null);
820     }
821 
822     public void setRegex_Equal(String regex, ConditionOptionCall<TermQueryBuilder> opLambda) {
823         setRegex_Term(regex, opLambda);
824     }
825 
826     public void setRegex_Term(String regex) {
827         setRegex_Term(regex, null);
828     }
829 
830     public void setRegex_Term(String regex, ConditionOptionCall<TermQueryBuilder> opLambda) {
831         TermQueryBuilder builder = regTermQ("regex", regex);
832         if (opLambda != null) {
833             opLambda.callback(builder);
834         }
835     }
836 
837     public void setRegex_NotEqual(String regex) {
838         setRegex_NotTerm(regex, null);
839     }
840 
841     public void setRegex_NotTerm(String regex) {
842         setRegex_NotTerm(regex, null);
843     }
844 
845     public void setRegex_NotEqual(String regex, ConditionOptionCall<BoolQueryBuilder> opLambda) {
846         setRegex_NotTerm(regex, opLambda);
847     }
848 
849     public void setRegex_NotTerm(String regex, ConditionOptionCall<BoolQueryBuilder> opLambda) {
850         not(not -> not.setRegex_Term(regex), opLambda);
851     }
852 
853     public void setRegex_Terms(Collection<String> regexList) {
854         setRegex_Terms(regexList, null);
855     }
856 
857     public void setRegex_Terms(Collection<String> regexList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
858         TermsQueryBuilder builder = regTermsQ("regex", regexList);
859         if (opLambda != null) {
860             opLambda.callback(builder);
861         }
862     }
863 
864     public void setRegex_InScope(Collection<String> regexList) {
865         setRegex_Terms(regexList, null);
866     }
867 
868     public void setRegex_InScope(Collection<String> regexList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
869         setRegex_Terms(regexList, opLambda);
870     }
871 
872     public void setRegex_Match(String regex) {
873         setRegex_Match(regex, null);
874     }
875 
876     public void setRegex_Match(String regex, ConditionOptionCall<MatchQueryBuilder> opLambda) {
877         MatchQueryBuilder builder = regMatchQ("regex", regex);
878         if (opLambda != null) {
879             opLambda.callback(builder);
880         }
881     }
882 
883     public void setRegex_MatchPhrase(String regex) {
884         setRegex_MatchPhrase(regex, null);
885     }
886 
887     public void setRegex_MatchPhrase(String regex, ConditionOptionCall<MatchPhraseQueryBuilder> opLambda) {
888         MatchPhraseQueryBuilder builder = regMatchPhraseQ("regex", regex);
889         if (opLambda != null) {
890             opLambda.callback(builder);
891         }
892     }
893 
894     public void setRegex_MatchPhrasePrefix(String regex) {
895         setRegex_MatchPhrasePrefix(regex, null);
896     }
897 
898     public void setRegex_MatchPhrasePrefix(String regex, ConditionOptionCall<MatchPhrasePrefixQueryBuilder> opLambda) {
899         MatchPhrasePrefixQueryBuilder builder = regMatchPhrasePrefixQ("regex", regex);
900         if (opLambda != null) {
901             opLambda.callback(builder);
902         }
903     }
904 
905     public void setRegex_Fuzzy(String regex) {
906         setRegex_Fuzzy(regex, null);
907     }
908 
909     public void setRegex_Fuzzy(String regex, ConditionOptionCall<MatchQueryBuilder> opLambda) {
910         MatchQueryBuilder builder = regFuzzyQ("regex", regex);
911         if (opLambda != null) {
912             opLambda.callback(builder);
913         }
914     }
915 
916     public void setRegex_Prefix(String regex) {
917         setRegex_Prefix(regex, null);
918     }
919 
920     public void setRegex_Prefix(String regex, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
921         PrefixQueryBuilder builder = regPrefixQ("regex", regex);
922         if (opLambda != null) {
923             opLambda.callback(builder);
924         }
925     }
926 
927     public void setRegex_Wildcard(String regex) {
928         setRegex_Wildcard(regex, null);
929     }
930 
931     public void setRegex_Wildcard(String regex, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
932         WildcardQueryBuilder builder = regWildcardQ("regex", regex);
933         if (opLambda != null) {
934             opLambda.callback(builder);
935         }
936     }
937 
938     public void setRegex_Regexp(String regex) {
939         setRegex_Regexp(regex, null);
940     }
941 
942     public void setRegex_Regexp(String regex, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
943         RegexpQueryBuilder builder = regRegexpQ("regex", regex);
944         if (opLambda != null) {
945             opLambda.callback(builder);
946         }
947     }
948 
949     public void setRegex_SpanTerm(String regex) {
950         setRegex_SpanTerm("regex", null);
951     }
952 
953     public void setRegex_SpanTerm(String regex, ConditionOptionCall<SpanTermQueryBuilder> opLambda) {
954         SpanTermQueryBuilder builder = regSpanTermQ("regex", regex);
955         if (opLambda != null) {
956             opLambda.callback(builder);
957         }
958     }
959 
960     public void setRegex_GreaterThan(String regex) {
961         setRegex_GreaterThan(regex, null);
962     }
963 
964     public void setRegex_GreaterThan(String regex, ConditionOptionCall<RangeQueryBuilder> opLambda) {
965         final Object _value = regex;
966         RangeQueryBuilder builder = regRangeQ("regex", ConditionKey.CK_GREATER_THAN, _value);
967         if (opLambda != null) {
968             opLambda.callback(builder);
969         }
970     }
971 
972     public void setRegex_LessThan(String regex) {
973         setRegex_LessThan(regex, null);
974     }
975 
976     public void setRegex_LessThan(String regex, ConditionOptionCall<RangeQueryBuilder> opLambda) {
977         final Object _value = regex;
978         RangeQueryBuilder builder = regRangeQ("regex", ConditionKey.CK_LESS_THAN, _value);
979         if (opLambda != null) {
980             opLambda.callback(builder);
981         }
982     }
983 
984     public void setRegex_GreaterEqual(String regex) {
985         setRegex_GreaterEqual(regex, null);
986     }
987 
988     public void setRegex_GreaterEqual(String regex, ConditionOptionCall<RangeQueryBuilder> opLambda) {
989         final Object _value = regex;
990         RangeQueryBuilder builder = regRangeQ("regex", ConditionKey.CK_GREATER_EQUAL, _value);
991         if (opLambda != null) {
992             opLambda.callback(builder);
993         }
994     }
995 
996     public void setRegex_LessEqual(String regex) {
997         setRegex_LessEqual(regex, null);
998     }
999 
1000     public void setRegex_LessEqual(String regex, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1001         final Object _value = regex;
1002         RangeQueryBuilder builder = regRangeQ("regex", ConditionKey.CK_LESS_EQUAL, _value);
1003         if (opLambda != null) {
1004             opLambda.callback(builder);
1005         }
1006     }
1007 
1008     public void setRegex_Exists() {
1009         setRegex_Exists(null);
1010     }
1011 
1012     public void setRegex_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
1013         ExistsQueryBuilder builder = regExistsQ("regex");
1014         if (opLambda != null) {
1015             opLambda.callback(builder);
1016         }
1017     }
1018 
1019     @Deprecated
1020     public void setRegex_CommonTerms(String regex) {
1021         setRegex_CommonTerms(regex, null);
1022     }
1023 
1024     @Deprecated
1025     public void setRegex_CommonTerms(String regex, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
1026         CommonTermsQueryBuilder builder = regCommonTermsQ("regex", regex);
1027         if (opLambda != null) {
1028             opLambda.callback(builder);
1029         }
1030     }
1031 
1032     public BsPathMappingCQ addOrderBy_Regex_Asc() {
1033         regOBA("regex");
1034         return this;
1035     }
1036 
1037     public BsPathMappingCQ addOrderBy_Regex_Desc() {
1038         regOBD("regex");
1039         return this;
1040     }
1041 
1042     public void setReplacement_Equal(String replacement) {
1043         setReplacement_Term(replacement, null);
1044     }
1045 
1046     public void setReplacement_Equal(String replacement, ConditionOptionCall<TermQueryBuilder> opLambda) {
1047         setReplacement_Term(replacement, opLambda);
1048     }
1049 
1050     public void setReplacement_Term(String replacement) {
1051         setReplacement_Term(replacement, null);
1052     }
1053 
1054     public void setReplacement_Term(String replacement, ConditionOptionCall<TermQueryBuilder> opLambda) {
1055         TermQueryBuilder builder = regTermQ("replacement", replacement);
1056         if (opLambda != null) {
1057             opLambda.callback(builder);
1058         }
1059     }
1060 
1061     public void setReplacement_NotEqual(String replacement) {
1062         setReplacement_NotTerm(replacement, null);
1063     }
1064 
1065     public void setReplacement_NotTerm(String replacement) {
1066         setReplacement_NotTerm(replacement, null);
1067     }
1068 
1069     public void setReplacement_NotEqual(String replacement, ConditionOptionCall<BoolQueryBuilder> opLambda) {
1070         setReplacement_NotTerm(replacement, opLambda);
1071     }
1072 
1073     public void setReplacement_NotTerm(String replacement, ConditionOptionCall<BoolQueryBuilder> opLambda) {
1074         not(not -> not.setReplacement_Term(replacement), opLambda);
1075     }
1076 
1077     public void setReplacement_Terms(Collection<String> replacementList) {
1078         setReplacement_Terms(replacementList, null);
1079     }
1080 
1081     public void setReplacement_Terms(Collection<String> replacementList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
1082         TermsQueryBuilder builder = regTermsQ("replacement", replacementList);
1083         if (opLambda != null) {
1084             opLambda.callback(builder);
1085         }
1086     }
1087 
1088     public void setReplacement_InScope(Collection<String> replacementList) {
1089         setReplacement_Terms(replacementList, null);
1090     }
1091 
1092     public void setReplacement_InScope(Collection<String> replacementList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
1093         setReplacement_Terms(replacementList, opLambda);
1094     }
1095 
1096     public void setReplacement_Match(String replacement) {
1097         setReplacement_Match(replacement, null);
1098     }
1099 
1100     public void setReplacement_Match(String replacement, ConditionOptionCall<MatchQueryBuilder> opLambda) {
1101         MatchQueryBuilder builder = regMatchQ("replacement", replacement);
1102         if (opLambda != null) {
1103             opLambda.callback(builder);
1104         }
1105     }
1106 
1107     public void setReplacement_MatchPhrase(String replacement) {
1108         setReplacement_MatchPhrase(replacement, null);
1109     }
1110 
1111     public void setReplacement_MatchPhrase(String replacement, ConditionOptionCall<MatchPhraseQueryBuilder> opLambda) {
1112         MatchPhraseQueryBuilder builder = regMatchPhraseQ("replacement", replacement);
1113         if (opLambda != null) {
1114             opLambda.callback(builder);
1115         }
1116     }
1117 
1118     public void setReplacement_MatchPhrasePrefix(String replacement) {
1119         setReplacement_MatchPhrasePrefix(replacement, null);
1120     }
1121 
1122     public void setReplacement_MatchPhrasePrefix(String replacement, ConditionOptionCall<MatchPhrasePrefixQueryBuilder> opLambda) {
1123         MatchPhrasePrefixQueryBuilder builder = regMatchPhrasePrefixQ("replacement", replacement);
1124         if (opLambda != null) {
1125             opLambda.callback(builder);
1126         }
1127     }
1128 
1129     public void setReplacement_Fuzzy(String replacement) {
1130         setReplacement_Fuzzy(replacement, null);
1131     }
1132 
1133     public void setReplacement_Fuzzy(String replacement, ConditionOptionCall<MatchQueryBuilder> opLambda) {
1134         MatchQueryBuilder builder = regFuzzyQ("replacement", replacement);
1135         if (opLambda != null) {
1136             opLambda.callback(builder);
1137         }
1138     }
1139 
1140     public void setReplacement_Prefix(String replacement) {
1141         setReplacement_Prefix(replacement, null);
1142     }
1143 
1144     public void setReplacement_Prefix(String replacement, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
1145         PrefixQueryBuilder builder = regPrefixQ("replacement", replacement);
1146         if (opLambda != null) {
1147             opLambda.callback(builder);
1148         }
1149     }
1150 
1151     public void setReplacement_Wildcard(String replacement) {
1152         setReplacement_Wildcard(replacement, null);
1153     }
1154 
1155     public void setReplacement_Wildcard(String replacement, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
1156         WildcardQueryBuilder builder = regWildcardQ("replacement", replacement);
1157         if (opLambda != null) {
1158             opLambda.callback(builder);
1159         }
1160     }
1161 
1162     public void setReplacement_Regexp(String replacement) {
1163         setReplacement_Regexp(replacement, null);
1164     }
1165 
1166     public void setReplacement_Regexp(String replacement, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
1167         RegexpQueryBuilder builder = regRegexpQ("replacement", replacement);
1168         if (opLambda != null) {
1169             opLambda.callback(builder);
1170         }
1171     }
1172 
1173     public void setReplacement_SpanTerm(String replacement) {
1174         setReplacement_SpanTerm("replacement", null);
1175     }
1176 
1177     public void setReplacement_SpanTerm(String replacement, ConditionOptionCall<SpanTermQueryBuilder> opLambda) {
1178         SpanTermQueryBuilder builder = regSpanTermQ("replacement", replacement);
1179         if (opLambda != null) {
1180             opLambda.callback(builder);
1181         }
1182     }
1183 
1184     public void setReplacement_GreaterThan(String replacement) {
1185         setReplacement_GreaterThan(replacement, null);
1186     }
1187 
1188     public void setReplacement_GreaterThan(String replacement, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1189         final Object _value = replacement;
1190         RangeQueryBuilder builder = regRangeQ("replacement", ConditionKey.CK_GREATER_THAN, _value);
1191         if (opLambda != null) {
1192             opLambda.callback(builder);
1193         }
1194     }
1195 
1196     public void setReplacement_LessThan(String replacement) {
1197         setReplacement_LessThan(replacement, null);
1198     }
1199 
1200     public void setReplacement_LessThan(String replacement, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1201         final Object _value = replacement;
1202         RangeQueryBuilder builder = regRangeQ("replacement", ConditionKey.CK_LESS_THAN, _value);
1203         if (opLambda != null) {
1204             opLambda.callback(builder);
1205         }
1206     }
1207 
1208     public void setReplacement_GreaterEqual(String replacement) {
1209         setReplacement_GreaterEqual(replacement, null);
1210     }
1211 
1212     public void setReplacement_GreaterEqual(String replacement, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1213         final Object _value = replacement;
1214         RangeQueryBuilder builder = regRangeQ("replacement", ConditionKey.CK_GREATER_EQUAL, _value);
1215         if (opLambda != null) {
1216             opLambda.callback(builder);
1217         }
1218     }
1219 
1220     public void setReplacement_LessEqual(String replacement) {
1221         setReplacement_LessEqual(replacement, null);
1222     }
1223 
1224     public void setReplacement_LessEqual(String replacement, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1225         final Object _value = replacement;
1226         RangeQueryBuilder builder = regRangeQ("replacement", ConditionKey.CK_LESS_EQUAL, _value);
1227         if (opLambda != null) {
1228             opLambda.callback(builder);
1229         }
1230     }
1231 
1232     public void setReplacement_Exists() {
1233         setReplacement_Exists(null);
1234     }
1235 
1236     public void setReplacement_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
1237         ExistsQueryBuilder builder = regExistsQ("replacement");
1238         if (opLambda != null) {
1239             opLambda.callback(builder);
1240         }
1241     }
1242 
1243     @Deprecated
1244     public void setReplacement_CommonTerms(String replacement) {
1245         setReplacement_CommonTerms(replacement, null);
1246     }
1247 
1248     @Deprecated
1249     public void setReplacement_CommonTerms(String replacement, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
1250         CommonTermsQueryBuilder builder = regCommonTermsQ("replacement", replacement);
1251         if (opLambda != null) {
1252             opLambda.callback(builder);
1253         }
1254     }
1255 
1256     public BsPathMappingCQ addOrderBy_Replacement_Asc() {
1257         regOBA("replacement");
1258         return this;
1259     }
1260 
1261     public BsPathMappingCQ addOrderBy_Replacement_Desc() {
1262         regOBD("replacement");
1263         return this;
1264     }
1265 
1266     public void setSortOrder_Equal(Integer sortOrder) {
1267         setSortOrder_Term(sortOrder, null);
1268     }
1269 
1270     public void setSortOrder_Equal(Integer sortOrder, ConditionOptionCall<TermQueryBuilder> opLambda) {
1271         setSortOrder_Term(sortOrder, opLambda);
1272     }
1273 
1274     public void setSortOrder_Term(Integer sortOrder) {
1275         setSortOrder_Term(sortOrder, null);
1276     }
1277 
1278     public void setSortOrder_Term(Integer sortOrder, ConditionOptionCall<TermQueryBuilder> opLambda) {
1279         TermQueryBuilder builder = regTermQ("sortOrder", sortOrder);
1280         if (opLambda != null) {
1281             opLambda.callback(builder);
1282         }
1283     }
1284 
1285     public void setSortOrder_NotEqual(Integer sortOrder) {
1286         setSortOrder_NotTerm(sortOrder, null);
1287     }
1288 
1289     public void setSortOrder_NotTerm(Integer sortOrder) {
1290         setSortOrder_NotTerm(sortOrder, null);
1291     }
1292 
1293     public void setSortOrder_NotEqual(Integer sortOrder, ConditionOptionCall<BoolQueryBuilder> opLambda) {
1294         setSortOrder_NotTerm(sortOrder, opLambda);
1295     }
1296 
1297     public void setSortOrder_NotTerm(Integer sortOrder, ConditionOptionCall<BoolQueryBuilder> opLambda) {
1298         not(not -> not.setSortOrder_Term(sortOrder), opLambda);
1299     }
1300 
1301     public void setSortOrder_Terms(Collection<Integer> sortOrderList) {
1302         setSortOrder_Terms(sortOrderList, null);
1303     }
1304 
1305     public void setSortOrder_Terms(Collection<Integer> sortOrderList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
1306         TermsQueryBuilder builder = regTermsQ("sortOrder", sortOrderList);
1307         if (opLambda != null) {
1308             opLambda.callback(builder);
1309         }
1310     }
1311 
1312     public void setSortOrder_InScope(Collection<Integer> sortOrderList) {
1313         setSortOrder_Terms(sortOrderList, null);
1314     }
1315 
1316     public void setSortOrder_InScope(Collection<Integer> sortOrderList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
1317         setSortOrder_Terms(sortOrderList, opLambda);
1318     }
1319 
1320     public void setSortOrder_Match(Integer sortOrder) {
1321         setSortOrder_Match(sortOrder, null);
1322     }
1323 
1324     public void setSortOrder_Match(Integer sortOrder, ConditionOptionCall<MatchQueryBuilder> opLambda) {
1325         MatchQueryBuilder builder = regMatchQ("sortOrder", sortOrder);
1326         if (opLambda != null) {
1327             opLambda.callback(builder);
1328         }
1329     }
1330 
1331     public void setSortOrder_MatchPhrase(Integer sortOrder) {
1332         setSortOrder_MatchPhrase(sortOrder, null);
1333     }
1334 
1335     public void setSortOrder_MatchPhrase(Integer sortOrder, ConditionOptionCall<MatchPhraseQueryBuilder> opLambda) {
1336         MatchPhraseQueryBuilder builder = regMatchPhraseQ("sortOrder", sortOrder);
1337         if (opLambda != null) {
1338             opLambda.callback(builder);
1339         }
1340     }
1341 
1342     public void setSortOrder_MatchPhrasePrefix(Integer sortOrder) {
1343         setSortOrder_MatchPhrasePrefix(sortOrder, null);
1344     }
1345 
1346     public void setSortOrder_MatchPhrasePrefix(Integer sortOrder, ConditionOptionCall<MatchPhrasePrefixQueryBuilder> opLambda) {
1347         MatchPhrasePrefixQueryBuilder builder = regMatchPhrasePrefixQ("sortOrder", sortOrder);
1348         if (opLambda != null) {
1349             opLambda.callback(builder);
1350         }
1351     }
1352 
1353     public void setSortOrder_Fuzzy(Integer sortOrder) {
1354         setSortOrder_Fuzzy(sortOrder, null);
1355     }
1356 
1357     public void setSortOrder_Fuzzy(Integer sortOrder, ConditionOptionCall<MatchQueryBuilder> opLambda) {
1358         MatchQueryBuilder builder = regFuzzyQ("sortOrder", sortOrder);
1359         if (opLambda != null) {
1360             opLambda.callback(builder);
1361         }
1362     }
1363 
1364     public void setSortOrder_GreaterThan(Integer sortOrder) {
1365         setSortOrder_GreaterThan(sortOrder, null);
1366     }
1367 
1368     public void setSortOrder_GreaterThan(Integer sortOrder, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1369         final Object _value = sortOrder;
1370         RangeQueryBuilder builder = regRangeQ("sortOrder", ConditionKey.CK_GREATER_THAN, _value);
1371         if (opLambda != null) {
1372             opLambda.callback(builder);
1373         }
1374     }
1375 
1376     public void setSortOrder_LessThan(Integer sortOrder) {
1377         setSortOrder_LessThan(sortOrder, null);
1378     }
1379 
1380     public void setSortOrder_LessThan(Integer sortOrder, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1381         final Object _value = sortOrder;
1382         RangeQueryBuilder builder = regRangeQ("sortOrder", ConditionKey.CK_LESS_THAN, _value);
1383         if (opLambda != null) {
1384             opLambda.callback(builder);
1385         }
1386     }
1387 
1388     public void setSortOrder_GreaterEqual(Integer sortOrder) {
1389         setSortOrder_GreaterEqual(sortOrder, null);
1390     }
1391 
1392     public void setSortOrder_GreaterEqual(Integer sortOrder, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1393         final Object _value = sortOrder;
1394         RangeQueryBuilder builder = regRangeQ("sortOrder", ConditionKey.CK_GREATER_EQUAL, _value);
1395         if (opLambda != null) {
1396             opLambda.callback(builder);
1397         }
1398     }
1399 
1400     public void setSortOrder_LessEqual(Integer sortOrder) {
1401         setSortOrder_LessEqual(sortOrder, null);
1402     }
1403 
1404     public void setSortOrder_LessEqual(Integer sortOrder, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1405         final Object _value = sortOrder;
1406         RangeQueryBuilder builder = regRangeQ("sortOrder", ConditionKey.CK_LESS_EQUAL, _value);
1407         if (opLambda != null) {
1408             opLambda.callback(builder);
1409         }
1410     }
1411 
1412     public void setSortOrder_Exists() {
1413         setSortOrder_Exists(null);
1414     }
1415 
1416     public void setSortOrder_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
1417         ExistsQueryBuilder builder = regExistsQ("sortOrder");
1418         if (opLambda != null) {
1419             opLambda.callback(builder);
1420         }
1421     }
1422 
1423     @Deprecated
1424     public void setSortOrder_CommonTerms(Integer sortOrder) {
1425         setSortOrder_CommonTerms(sortOrder, null);
1426     }
1427 
1428     @Deprecated
1429     public void setSortOrder_CommonTerms(Integer sortOrder, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
1430         CommonTermsQueryBuilder builder = regCommonTermsQ("sortOrder", sortOrder);
1431         if (opLambda != null) {
1432             opLambda.callback(builder);
1433         }
1434     }
1435 
1436     public BsPathMappingCQ addOrderBy_SortOrder_Asc() {
1437         regOBA("sortOrder");
1438         return this;
1439     }
1440 
1441     public BsPathMappingCQ addOrderBy_SortOrder_Desc() {
1442         regOBD("sortOrder");
1443         return this;
1444     }
1445 
1446     public void setUpdatedBy_Equal(String updatedBy) {
1447         setUpdatedBy_Term(updatedBy, null);
1448     }
1449 
1450     public void setUpdatedBy_Equal(String updatedBy, ConditionOptionCall<TermQueryBuilder> opLambda) {
1451         setUpdatedBy_Term(updatedBy, opLambda);
1452     }
1453 
1454     public void setUpdatedBy_Term(String updatedBy) {
1455         setUpdatedBy_Term(updatedBy, null);
1456     }
1457 
1458     public void setUpdatedBy_Term(String updatedBy, ConditionOptionCall<TermQueryBuilder> opLambda) {
1459         TermQueryBuilder builder = regTermQ("updatedBy", updatedBy);
1460         if (opLambda != null) {
1461             opLambda.callback(builder);
1462         }
1463     }
1464 
1465     public void setUpdatedBy_NotEqual(String updatedBy) {
1466         setUpdatedBy_NotTerm(updatedBy, null);
1467     }
1468 
1469     public void setUpdatedBy_NotTerm(String updatedBy) {
1470         setUpdatedBy_NotTerm(updatedBy, null);
1471     }
1472 
1473     public void setUpdatedBy_NotEqual(String updatedBy, ConditionOptionCall<BoolQueryBuilder> opLambda) {
1474         setUpdatedBy_NotTerm(updatedBy, opLambda);
1475     }
1476 
1477     public void setUpdatedBy_NotTerm(String updatedBy, ConditionOptionCall<BoolQueryBuilder> opLambda) {
1478         not(not -> not.setUpdatedBy_Term(updatedBy), opLambda);
1479     }
1480 
1481     public void setUpdatedBy_Terms(Collection<String> updatedByList) {
1482         setUpdatedBy_Terms(updatedByList, null);
1483     }
1484 
1485     public void setUpdatedBy_Terms(Collection<String> updatedByList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
1486         TermsQueryBuilder builder = regTermsQ("updatedBy", updatedByList);
1487         if (opLambda != null) {
1488             opLambda.callback(builder);
1489         }
1490     }
1491 
1492     public void setUpdatedBy_InScope(Collection<String> updatedByList) {
1493         setUpdatedBy_Terms(updatedByList, null);
1494     }
1495 
1496     public void setUpdatedBy_InScope(Collection<String> updatedByList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
1497         setUpdatedBy_Terms(updatedByList, opLambda);
1498     }
1499 
1500     public void setUpdatedBy_Match(String updatedBy) {
1501         setUpdatedBy_Match(updatedBy, null);
1502     }
1503 
1504     public void setUpdatedBy_Match(String updatedBy, ConditionOptionCall<MatchQueryBuilder> opLambda) {
1505         MatchQueryBuilder builder = regMatchQ("updatedBy", updatedBy);
1506         if (opLambda != null) {
1507             opLambda.callback(builder);
1508         }
1509     }
1510 
1511     public void setUpdatedBy_MatchPhrase(String updatedBy) {
1512         setUpdatedBy_MatchPhrase(updatedBy, null);
1513     }
1514 
1515     public void setUpdatedBy_MatchPhrase(String updatedBy, ConditionOptionCall<MatchPhraseQueryBuilder> opLambda) {
1516         MatchPhraseQueryBuilder builder = regMatchPhraseQ("updatedBy", updatedBy);
1517         if (opLambda != null) {
1518             opLambda.callback(builder);
1519         }
1520     }
1521 
1522     public void setUpdatedBy_MatchPhrasePrefix(String updatedBy) {
1523         setUpdatedBy_MatchPhrasePrefix(updatedBy, null);
1524     }
1525 
1526     public void setUpdatedBy_MatchPhrasePrefix(String updatedBy, ConditionOptionCall<MatchPhrasePrefixQueryBuilder> opLambda) {
1527         MatchPhrasePrefixQueryBuilder builder = regMatchPhrasePrefixQ("updatedBy", updatedBy);
1528         if (opLambda != null) {
1529             opLambda.callback(builder);
1530         }
1531     }
1532 
1533     public void setUpdatedBy_Fuzzy(String updatedBy) {
1534         setUpdatedBy_Fuzzy(updatedBy, null);
1535     }
1536 
1537     public void setUpdatedBy_Fuzzy(String updatedBy, ConditionOptionCall<MatchQueryBuilder> opLambda) {
1538         MatchQueryBuilder builder = regFuzzyQ("updatedBy", updatedBy);
1539         if (opLambda != null) {
1540             opLambda.callback(builder);
1541         }
1542     }
1543 
1544     public void setUpdatedBy_Prefix(String updatedBy) {
1545         setUpdatedBy_Prefix(updatedBy, null);
1546     }
1547 
1548     public void setUpdatedBy_Prefix(String updatedBy, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
1549         PrefixQueryBuilder builder = regPrefixQ("updatedBy", updatedBy);
1550         if (opLambda != null) {
1551             opLambda.callback(builder);
1552         }
1553     }
1554 
1555     public void setUpdatedBy_Wildcard(String updatedBy) {
1556         setUpdatedBy_Wildcard(updatedBy, null);
1557     }
1558 
1559     public void setUpdatedBy_Wildcard(String updatedBy, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
1560         WildcardQueryBuilder builder = regWildcardQ("updatedBy", updatedBy);
1561         if (opLambda != null) {
1562             opLambda.callback(builder);
1563         }
1564     }
1565 
1566     public void setUpdatedBy_Regexp(String updatedBy) {
1567         setUpdatedBy_Regexp(updatedBy, null);
1568     }
1569 
1570     public void setUpdatedBy_Regexp(String updatedBy, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
1571         RegexpQueryBuilder builder = regRegexpQ("updatedBy", updatedBy);
1572         if (opLambda != null) {
1573             opLambda.callback(builder);
1574         }
1575     }
1576 
1577     public void setUpdatedBy_SpanTerm(String updatedBy) {
1578         setUpdatedBy_SpanTerm("updatedBy", null);
1579     }
1580 
1581     public void setUpdatedBy_SpanTerm(String updatedBy, ConditionOptionCall<SpanTermQueryBuilder> opLambda) {
1582         SpanTermQueryBuilder builder = regSpanTermQ("updatedBy", updatedBy);
1583         if (opLambda != null) {
1584             opLambda.callback(builder);
1585         }
1586     }
1587 
1588     public void setUpdatedBy_GreaterThan(String updatedBy) {
1589         setUpdatedBy_GreaterThan(updatedBy, null);
1590     }
1591 
1592     public void setUpdatedBy_GreaterThan(String updatedBy, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1593         final Object _value = updatedBy;
1594         RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_GREATER_THAN, _value);
1595         if (opLambda != null) {
1596             opLambda.callback(builder);
1597         }
1598     }
1599 
1600     public void setUpdatedBy_LessThan(String updatedBy) {
1601         setUpdatedBy_LessThan(updatedBy, null);
1602     }
1603 
1604     public void setUpdatedBy_LessThan(String updatedBy, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1605         final Object _value = updatedBy;
1606         RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_LESS_THAN, _value);
1607         if (opLambda != null) {
1608             opLambda.callback(builder);
1609         }
1610     }
1611 
1612     public void setUpdatedBy_GreaterEqual(String updatedBy) {
1613         setUpdatedBy_GreaterEqual(updatedBy, null);
1614     }
1615 
1616     public void setUpdatedBy_GreaterEqual(String updatedBy, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1617         final Object _value = updatedBy;
1618         RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_GREATER_EQUAL, _value);
1619         if (opLambda != null) {
1620             opLambda.callback(builder);
1621         }
1622     }
1623 
1624     public void setUpdatedBy_LessEqual(String updatedBy) {
1625         setUpdatedBy_LessEqual(updatedBy, null);
1626     }
1627 
1628     public void setUpdatedBy_LessEqual(String updatedBy, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1629         final Object _value = updatedBy;
1630         RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_LESS_EQUAL, _value);
1631         if (opLambda != null) {
1632             opLambda.callback(builder);
1633         }
1634     }
1635 
1636     public void setUpdatedBy_Exists() {
1637         setUpdatedBy_Exists(null);
1638     }
1639 
1640     public void setUpdatedBy_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
1641         ExistsQueryBuilder builder = regExistsQ("updatedBy");
1642         if (opLambda != null) {
1643             opLambda.callback(builder);
1644         }
1645     }
1646 
1647     @Deprecated
1648     public void setUpdatedBy_CommonTerms(String updatedBy) {
1649         setUpdatedBy_CommonTerms(updatedBy, null);
1650     }
1651 
1652     @Deprecated
1653     public void setUpdatedBy_CommonTerms(String updatedBy, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
1654         CommonTermsQueryBuilder builder = regCommonTermsQ("updatedBy", updatedBy);
1655         if (opLambda != null) {
1656             opLambda.callback(builder);
1657         }
1658     }
1659 
1660     public BsPathMappingCQ addOrderBy_UpdatedBy_Asc() {
1661         regOBA("updatedBy");
1662         return this;
1663     }
1664 
1665     public BsPathMappingCQ addOrderBy_UpdatedBy_Desc() {
1666         regOBD("updatedBy");
1667         return this;
1668     }
1669 
1670     public void setUpdatedTime_Equal(Long updatedTime) {
1671         setUpdatedTime_Term(updatedTime, null);
1672     }
1673 
1674     public void setUpdatedTime_Equal(Long updatedTime, ConditionOptionCall<TermQueryBuilder> opLambda) {
1675         setUpdatedTime_Term(updatedTime, opLambda);
1676     }
1677 
1678     public void setUpdatedTime_Term(Long updatedTime) {
1679         setUpdatedTime_Term(updatedTime, null);
1680     }
1681 
1682     public void setUpdatedTime_Term(Long updatedTime, ConditionOptionCall<TermQueryBuilder> opLambda) {
1683         TermQueryBuilder builder = regTermQ("updatedTime", updatedTime);
1684         if (opLambda != null) {
1685             opLambda.callback(builder);
1686         }
1687     }
1688 
1689     public void setUpdatedTime_NotEqual(Long updatedTime) {
1690         setUpdatedTime_NotTerm(updatedTime, null);
1691     }
1692 
1693     public void setUpdatedTime_NotTerm(Long updatedTime) {
1694         setUpdatedTime_NotTerm(updatedTime, null);
1695     }
1696 
1697     public void setUpdatedTime_NotEqual(Long updatedTime, ConditionOptionCall<BoolQueryBuilder> opLambda) {
1698         setUpdatedTime_NotTerm(updatedTime, opLambda);
1699     }
1700 
1701     public void setUpdatedTime_NotTerm(Long updatedTime, ConditionOptionCall<BoolQueryBuilder> opLambda) {
1702         not(not -> not.setUpdatedTime_Term(updatedTime), opLambda);
1703     }
1704 
1705     public void setUpdatedTime_Terms(Collection<Long> updatedTimeList) {
1706         setUpdatedTime_Terms(updatedTimeList, null);
1707     }
1708 
1709     public void setUpdatedTime_Terms(Collection<Long> updatedTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
1710         TermsQueryBuilder builder = regTermsQ("updatedTime", updatedTimeList);
1711         if (opLambda != null) {
1712             opLambda.callback(builder);
1713         }
1714     }
1715 
1716     public void setUpdatedTime_InScope(Collection<Long> updatedTimeList) {
1717         setUpdatedTime_Terms(updatedTimeList, null);
1718     }
1719 
1720     public void setUpdatedTime_InScope(Collection<Long> updatedTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
1721         setUpdatedTime_Terms(updatedTimeList, opLambda);
1722     }
1723 
1724     public void setUpdatedTime_Match(Long updatedTime) {
1725         setUpdatedTime_Match(updatedTime, null);
1726     }
1727 
1728     public void setUpdatedTime_Match(Long updatedTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
1729         MatchQueryBuilder builder = regMatchQ("updatedTime", updatedTime);
1730         if (opLambda != null) {
1731             opLambda.callback(builder);
1732         }
1733     }
1734 
1735     public void setUpdatedTime_MatchPhrase(Long updatedTime) {
1736         setUpdatedTime_MatchPhrase(updatedTime, null);
1737     }
1738 
1739     public void setUpdatedTime_MatchPhrase(Long updatedTime, ConditionOptionCall<MatchPhraseQueryBuilder> opLambda) {
1740         MatchPhraseQueryBuilder builder = regMatchPhraseQ("updatedTime", updatedTime);
1741         if (opLambda != null) {
1742             opLambda.callback(builder);
1743         }
1744     }
1745 
1746     public void setUpdatedTime_MatchPhrasePrefix(Long updatedTime) {
1747         setUpdatedTime_MatchPhrasePrefix(updatedTime, null);
1748     }
1749 
1750     public void setUpdatedTime_MatchPhrasePrefix(Long updatedTime, ConditionOptionCall<MatchPhrasePrefixQueryBuilder> opLambda) {
1751         MatchPhrasePrefixQueryBuilder builder = regMatchPhrasePrefixQ("updatedTime", updatedTime);
1752         if (opLambda != null) {
1753             opLambda.callback(builder);
1754         }
1755     }
1756 
1757     public void setUpdatedTime_Fuzzy(Long updatedTime) {
1758         setUpdatedTime_Fuzzy(updatedTime, null);
1759     }
1760 
1761     public void setUpdatedTime_Fuzzy(Long updatedTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
1762         MatchQueryBuilder builder = regFuzzyQ("updatedTime", updatedTime);
1763         if (opLambda != null) {
1764             opLambda.callback(builder);
1765         }
1766     }
1767 
1768     public void setUpdatedTime_GreaterThan(Long updatedTime) {
1769         setUpdatedTime_GreaterThan(updatedTime, null);
1770     }
1771 
1772     public void setUpdatedTime_GreaterThan(Long updatedTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1773         final Object _value = updatedTime;
1774         RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_GREATER_THAN, _value);
1775         if (opLambda != null) {
1776             opLambda.callback(builder);
1777         }
1778     }
1779 
1780     public void setUpdatedTime_LessThan(Long updatedTime) {
1781         setUpdatedTime_LessThan(updatedTime, null);
1782     }
1783 
1784     public void setUpdatedTime_LessThan(Long updatedTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1785         final Object _value = updatedTime;
1786         RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_LESS_THAN, _value);
1787         if (opLambda != null) {
1788             opLambda.callback(builder);
1789         }
1790     }
1791 
1792     public void setUpdatedTime_GreaterEqual(Long updatedTime) {
1793         setUpdatedTime_GreaterEqual(updatedTime, null);
1794     }
1795 
1796     public void setUpdatedTime_GreaterEqual(Long updatedTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1797         final Object _value = updatedTime;
1798         RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_GREATER_EQUAL, _value);
1799         if (opLambda != null) {
1800             opLambda.callback(builder);
1801         }
1802     }
1803 
1804     public void setUpdatedTime_LessEqual(Long updatedTime) {
1805         setUpdatedTime_LessEqual(updatedTime, null);
1806     }
1807 
1808     public void setUpdatedTime_LessEqual(Long updatedTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1809         final Object _value = updatedTime;
1810         RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_LESS_EQUAL, _value);
1811         if (opLambda != null) {
1812             opLambda.callback(builder);
1813         }
1814     }
1815 
1816     public void setUpdatedTime_Exists() {
1817         setUpdatedTime_Exists(null);
1818     }
1819 
1820     public void setUpdatedTime_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
1821         ExistsQueryBuilder builder = regExistsQ("updatedTime");
1822         if (opLambda != null) {
1823             opLambda.callback(builder);
1824         }
1825     }
1826 
1827     @Deprecated
1828     public void setUpdatedTime_CommonTerms(Long updatedTime) {
1829         setUpdatedTime_CommonTerms(updatedTime, null);
1830     }
1831 
1832     @Deprecated
1833     public void setUpdatedTime_CommonTerms(Long updatedTime, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
1834         CommonTermsQueryBuilder builder = regCommonTermsQ("updatedTime", updatedTime);
1835         if (opLambda != null) {
1836             opLambda.callback(builder);
1837         }
1838     }
1839 
1840     public BsPathMappingCQ addOrderBy_UpdatedTime_Asc() {
1841         regOBA("updatedTime");
1842         return this;
1843     }
1844 
1845     public BsPathMappingCQ addOrderBy_UpdatedTime_Desc() {
1846         regOBD("updatedTime");
1847         return this;
1848     }
1849 
1850     public void setUserAgent_Equal(String userAgent) {
1851         setUserAgent_Term(userAgent, null);
1852     }
1853 
1854     public void setUserAgent_Equal(String userAgent, ConditionOptionCall<TermQueryBuilder> opLambda) {
1855         setUserAgent_Term(userAgent, opLambda);
1856     }
1857 
1858     public void setUserAgent_Term(String userAgent) {
1859         setUserAgent_Term(userAgent, null);
1860     }
1861 
1862     public void setUserAgent_Term(String userAgent, ConditionOptionCall<TermQueryBuilder> opLambda) {
1863         TermQueryBuilder builder = regTermQ("userAgent", userAgent);
1864         if (opLambda != null) {
1865             opLambda.callback(builder);
1866         }
1867     }
1868 
1869     public void setUserAgent_NotEqual(String userAgent) {
1870         setUserAgent_NotTerm(userAgent, null);
1871     }
1872 
1873     public void setUserAgent_NotTerm(String userAgent) {
1874         setUserAgent_NotTerm(userAgent, null);
1875     }
1876 
1877     public void setUserAgent_NotEqual(String userAgent, ConditionOptionCall<BoolQueryBuilder> opLambda) {
1878         setUserAgent_NotTerm(userAgent, opLambda);
1879     }
1880 
1881     public void setUserAgent_NotTerm(String userAgent, ConditionOptionCall<BoolQueryBuilder> opLambda) {
1882         not(not -> not.setUserAgent_Term(userAgent), opLambda);
1883     }
1884 
1885     public void setUserAgent_Terms(Collection<String> userAgentList) {
1886         setUserAgent_Terms(userAgentList, null);
1887     }
1888 
1889     public void setUserAgent_Terms(Collection<String> userAgentList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
1890         TermsQueryBuilder builder = regTermsQ("userAgent", userAgentList);
1891         if (opLambda != null) {
1892             opLambda.callback(builder);
1893         }
1894     }
1895 
1896     public void setUserAgent_InScope(Collection<String> userAgentList) {
1897         setUserAgent_Terms(userAgentList, null);
1898     }
1899 
1900     public void setUserAgent_InScope(Collection<String> userAgentList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
1901         setUserAgent_Terms(userAgentList, opLambda);
1902     }
1903 
1904     public void setUserAgent_Match(String userAgent) {
1905         setUserAgent_Match(userAgent, null);
1906     }
1907 
1908     public void setUserAgent_Match(String userAgent, ConditionOptionCall<MatchQueryBuilder> opLambda) {
1909         MatchQueryBuilder builder = regMatchQ("userAgent", userAgent);
1910         if (opLambda != null) {
1911             opLambda.callback(builder);
1912         }
1913     }
1914 
1915     public void setUserAgent_MatchPhrase(String userAgent) {
1916         setUserAgent_MatchPhrase(userAgent, null);
1917     }
1918 
1919     public void setUserAgent_MatchPhrase(String userAgent, ConditionOptionCall<MatchPhraseQueryBuilder> opLambda) {
1920         MatchPhraseQueryBuilder builder = regMatchPhraseQ("userAgent", userAgent);
1921         if (opLambda != null) {
1922             opLambda.callback(builder);
1923         }
1924     }
1925 
1926     public void setUserAgent_MatchPhrasePrefix(String userAgent) {
1927         setUserAgent_MatchPhrasePrefix(userAgent, null);
1928     }
1929 
1930     public void setUserAgent_MatchPhrasePrefix(String userAgent, ConditionOptionCall<MatchPhrasePrefixQueryBuilder> opLambda) {
1931         MatchPhrasePrefixQueryBuilder builder = regMatchPhrasePrefixQ("userAgent", userAgent);
1932         if (opLambda != null) {
1933             opLambda.callback(builder);
1934         }
1935     }
1936 
1937     public void setUserAgent_Fuzzy(String userAgent) {
1938         setUserAgent_Fuzzy(userAgent, null);
1939     }
1940 
1941     public void setUserAgent_Fuzzy(String userAgent, ConditionOptionCall<MatchQueryBuilder> opLambda) {
1942         MatchQueryBuilder builder = regFuzzyQ("userAgent", userAgent);
1943         if (opLambda != null) {
1944             opLambda.callback(builder);
1945         }
1946     }
1947 
1948     public void setUserAgent_Prefix(String userAgent) {
1949         setUserAgent_Prefix(userAgent, null);
1950     }
1951 
1952     public void setUserAgent_Prefix(String userAgent, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
1953         PrefixQueryBuilder builder = regPrefixQ("userAgent", userAgent);
1954         if (opLambda != null) {
1955             opLambda.callback(builder);
1956         }
1957     }
1958 
1959     public void setUserAgent_Wildcard(String userAgent) {
1960         setUserAgent_Wildcard(userAgent, null);
1961     }
1962 
1963     public void setUserAgent_Wildcard(String userAgent, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
1964         WildcardQueryBuilder builder = regWildcardQ("userAgent", userAgent);
1965         if (opLambda != null) {
1966             opLambda.callback(builder);
1967         }
1968     }
1969 
1970     public void setUserAgent_Regexp(String userAgent) {
1971         setUserAgent_Regexp(userAgent, null);
1972     }
1973 
1974     public void setUserAgent_Regexp(String userAgent, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
1975         RegexpQueryBuilder builder = regRegexpQ("userAgent", userAgent);
1976         if (opLambda != null) {
1977             opLambda.callback(builder);
1978         }
1979     }
1980 
1981     public void setUserAgent_SpanTerm(String userAgent) {
1982         setUserAgent_SpanTerm("userAgent", null);
1983     }
1984 
1985     public void setUserAgent_SpanTerm(String userAgent, ConditionOptionCall<SpanTermQueryBuilder> opLambda) {
1986         SpanTermQueryBuilder builder = regSpanTermQ("userAgent", userAgent);
1987         if (opLambda != null) {
1988             opLambda.callback(builder);
1989         }
1990     }
1991 
1992     public void setUserAgent_GreaterThan(String userAgent) {
1993         setUserAgent_GreaterThan(userAgent, null);
1994     }
1995 
1996     public void setUserAgent_GreaterThan(String userAgent, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1997         final Object _value = userAgent;
1998         RangeQueryBuilder builder = regRangeQ("userAgent", ConditionKey.CK_GREATER_THAN, _value);
1999         if (opLambda != null) {
2000             opLambda.callback(builder);
2001         }
2002     }
2003 
2004     public void setUserAgent_LessThan(String userAgent) {
2005         setUserAgent_LessThan(userAgent, null);
2006     }
2007 
2008     public void setUserAgent_LessThan(String userAgent, ConditionOptionCall<RangeQueryBuilder> opLambda) {
2009         final Object _value = userAgent;
2010         RangeQueryBuilder builder = regRangeQ("userAgent", ConditionKey.CK_LESS_THAN, _value);
2011         if (opLambda != null) {
2012             opLambda.callback(builder);
2013         }
2014     }
2015 
2016     public void setUserAgent_GreaterEqual(String userAgent) {
2017         setUserAgent_GreaterEqual(userAgent, null);
2018     }
2019 
2020     public void setUserAgent_GreaterEqual(String userAgent, ConditionOptionCall<RangeQueryBuilder> opLambda) {
2021         final Object _value = userAgent;
2022         RangeQueryBuilder builder = regRangeQ("userAgent", ConditionKey.CK_GREATER_EQUAL, _value);
2023         if (opLambda != null) {
2024             opLambda.callback(builder);
2025         }
2026     }
2027 
2028     public void setUserAgent_LessEqual(String userAgent) {
2029         setUserAgent_LessEqual(userAgent, null);
2030     }
2031 
2032     public void setUserAgent_LessEqual(String userAgent, ConditionOptionCall<RangeQueryBuilder> opLambda) {
2033         final Object _value = userAgent;
2034         RangeQueryBuilder builder = regRangeQ("userAgent", ConditionKey.CK_LESS_EQUAL, _value);
2035         if (opLambda != null) {
2036             opLambda.callback(builder);
2037         }
2038     }
2039 
2040     public void setUserAgent_Exists() {
2041         setUserAgent_Exists(null);
2042     }
2043 
2044     public void setUserAgent_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
2045         ExistsQueryBuilder builder = regExistsQ("userAgent");
2046         if (opLambda != null) {
2047             opLambda.callback(builder);
2048         }
2049     }
2050 
2051     @Deprecated
2052     public void setUserAgent_CommonTerms(String userAgent) {
2053         setUserAgent_CommonTerms(userAgent, null);
2054     }
2055 
2056     @Deprecated
2057     public void setUserAgent_CommonTerms(String userAgent, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
2058         CommonTermsQueryBuilder builder = regCommonTermsQ("userAgent", userAgent);
2059         if (opLambda != null) {
2060             opLambda.callback(builder);
2061         }
2062     }
2063 
2064     public BsPathMappingCQ addOrderBy_UserAgent_Asc() {
2065         regOBA("userAgent");
2066         return this;
2067     }
2068 
2069     public BsPathMappingCQ addOrderBy_UserAgent_Desc() {
2070         regOBD("userAgent");
2071         return this;
2072     }
2073 
2074 }