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.AccessTokenCQ;
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 BsAccessTokenCQ 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 "access_token";
55      }
56  
57      @Override
58      public String xgetAliasName() {
59          return "access_token";
60      }
61  
62      // ===================================================================================
63      //                                                                       Query Control
64      //                                                                       =============
65      public void functionScore(OperatorCall<AccessTokenCQ> queryLambda,
66              ScoreFunctionCall<ScoreFunctionCreator<AccessTokenCQ>> functionsLambda,
67              final ConditionOptionCall<FunctionScoreQueryBuilder> opLambda) {
68          AccessTokenCQ cq = new AccessTokenCQ();
69          queryLambda.callback(cq);
70          final Collection<FilterFunctionBuilder> list = new ArrayList<>();
71          if (functionsLambda != null) {
72              functionsLambda.callback((cqLambda, scoreFunctionBuilder) -> {
73                  AccessTokenCQ cf = new AccessTokenCQ();
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<AccessTokenCQ, AccessTokenCQ> filteredLambda) {
85          filtered(filteredLambda, null);
86      }
87  
88      public void filtered(FilteredCall<AccessTokenCQ, AccessTokenCQ> filteredLambda, ConditionOptionCall<BoolQueryBuilder> opLambda) {
89          bool((must, should, mustNot, filter) -> {
90              filteredLambda.callback(must, filter);
91          }, opLambda);
92      }
93  
94      public void not(OperatorCall<AccessTokenCQ> notLambda) {
95          not(notLambda, null);
96      }
97  
98      public void not(final OperatorCall<AccessTokenCQ> notLambda, final ConditionOptionCall<BoolQueryBuilder> opLambda) {
99          bool((must, should, mustNot, filter) -> notLambda.callback(mustNot), opLambda);
100     }
101 
102     public void bool(BoolCall<AccessTokenCQ> boolLambda) {
103         bool(boolLambda, null);
104     }
105 
106     public void bool(BoolCall<AccessTokenCQ> boolLambda, ConditionOptionCall<BoolQueryBuilder> opLambda) {
107         AccessTokenCQ mustQuery = new AccessTokenCQ();
108         AccessTokenCQ shouldQuery = new AccessTokenCQ();
109         AccessTokenCQ mustNotQuery = new AccessTokenCQ();
110         AccessTokenCQ filterQuery = new AccessTokenCQ();
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 BsAccessTokenCQ addOrderBy_Id_Asc() {
180         regOBA("_id");
181         return this;
182     }
183 
184     @Deprecated
185     public BsAccessTokenCQ 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 BsAccessTokenCQ addOrderBy_CreatedBy_Asc() {
405         regOBA("createdBy");
406         return this;
407     }
408 
409     public BsAccessTokenCQ 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 BsAccessTokenCQ addOrderBy_CreatedTime_Asc() {
585         regOBA("createdTime");
586         return this;
587     }
588 
589     public BsAccessTokenCQ addOrderBy_CreatedTime_Desc() {
590         regOBD("createdTime");
591         return this;
592     }
593 
594     public void setExpiredTime_Equal(Long expiredTime) {
595         setExpiredTime_Term(expiredTime, null);
596     }
597 
598     public void setExpiredTime_Equal(Long expiredTime, ConditionOptionCall<TermQueryBuilder> opLambda) {
599         setExpiredTime_Term(expiredTime, opLambda);
600     }
601 
602     public void setExpiredTime_Term(Long expiredTime) {
603         setExpiredTime_Term(expiredTime, null);
604     }
605 
606     public void setExpiredTime_Term(Long expiredTime, ConditionOptionCall<TermQueryBuilder> opLambda) {
607         TermQueryBuilder builder = regTermQ("expiredTime", expiredTime);
608         if (opLambda != null) {
609             opLambda.callback(builder);
610         }
611     }
612 
613     public void setExpiredTime_NotEqual(Long expiredTime) {
614         setExpiredTime_NotTerm(expiredTime, null);
615     }
616 
617     public void setExpiredTime_NotTerm(Long expiredTime) {
618         setExpiredTime_NotTerm(expiredTime, null);
619     }
620 
621     public void setExpiredTime_NotEqual(Long expiredTime, ConditionOptionCall<BoolQueryBuilder> opLambda) {
622         setExpiredTime_NotTerm(expiredTime, opLambda);
623     }
624 
625     public void setExpiredTime_NotTerm(Long expiredTime, ConditionOptionCall<BoolQueryBuilder> opLambda) {
626         not(not -> not.setExpiredTime_Term(expiredTime), opLambda);
627     }
628 
629     public void setExpiredTime_Terms(Collection<Long> expiredTimeList) {
630         setExpiredTime_Terms(expiredTimeList, null);
631     }
632 
633     public void setExpiredTime_Terms(Collection<Long> expiredTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
634         TermsQueryBuilder builder = regTermsQ("expiredTime", expiredTimeList);
635         if (opLambda != null) {
636             opLambda.callback(builder);
637         }
638     }
639 
640     public void setExpiredTime_InScope(Collection<Long> expiredTimeList) {
641         setExpiredTime_Terms(expiredTimeList, null);
642     }
643 
644     public void setExpiredTime_InScope(Collection<Long> expiredTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
645         setExpiredTime_Terms(expiredTimeList, opLambda);
646     }
647 
648     public void setExpiredTime_Match(Long expiredTime) {
649         setExpiredTime_Match(expiredTime, null);
650     }
651 
652     public void setExpiredTime_Match(Long expiredTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
653         MatchQueryBuilder builder = regMatchQ("expiredTime", expiredTime);
654         if (opLambda != null) {
655             opLambda.callback(builder);
656         }
657     }
658 
659     public void setExpiredTime_MatchPhrase(Long expiredTime) {
660         setExpiredTime_MatchPhrase(expiredTime, null);
661     }
662 
663     public void setExpiredTime_MatchPhrase(Long expiredTime, ConditionOptionCall<MatchPhraseQueryBuilder> opLambda) {
664         MatchPhraseQueryBuilder builder = regMatchPhraseQ("expiredTime", expiredTime);
665         if (opLambda != null) {
666             opLambda.callback(builder);
667         }
668     }
669 
670     public void setExpiredTime_MatchPhrasePrefix(Long expiredTime) {
671         setExpiredTime_MatchPhrasePrefix(expiredTime, null);
672     }
673 
674     public void setExpiredTime_MatchPhrasePrefix(Long expiredTime, ConditionOptionCall<MatchPhrasePrefixQueryBuilder> opLambda) {
675         MatchPhrasePrefixQueryBuilder builder = regMatchPhrasePrefixQ("expiredTime", expiredTime);
676         if (opLambda != null) {
677             opLambda.callback(builder);
678         }
679     }
680 
681     public void setExpiredTime_Fuzzy(Long expiredTime) {
682         setExpiredTime_Fuzzy(expiredTime, null);
683     }
684 
685     public void setExpiredTime_Fuzzy(Long expiredTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
686         MatchQueryBuilder builder = regFuzzyQ("expiredTime", expiredTime);
687         if (opLambda != null) {
688             opLambda.callback(builder);
689         }
690     }
691 
692     public void setExpiredTime_GreaterThan(Long expiredTime) {
693         setExpiredTime_GreaterThan(expiredTime, null);
694     }
695 
696     public void setExpiredTime_GreaterThan(Long expiredTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
697         final Object _value = expiredTime;
698         RangeQueryBuilder builder = regRangeQ("expiredTime", ConditionKey.CK_GREATER_THAN, _value);
699         if (opLambda != null) {
700             opLambda.callback(builder);
701         }
702     }
703 
704     public void setExpiredTime_LessThan(Long expiredTime) {
705         setExpiredTime_LessThan(expiredTime, null);
706     }
707 
708     public void setExpiredTime_LessThan(Long expiredTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
709         final Object _value = expiredTime;
710         RangeQueryBuilder builder = regRangeQ("expiredTime", ConditionKey.CK_LESS_THAN, _value);
711         if (opLambda != null) {
712             opLambda.callback(builder);
713         }
714     }
715 
716     public void setExpiredTime_GreaterEqual(Long expiredTime) {
717         setExpiredTime_GreaterEqual(expiredTime, null);
718     }
719 
720     public void setExpiredTime_GreaterEqual(Long expiredTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
721         final Object _value = expiredTime;
722         RangeQueryBuilder builder = regRangeQ("expiredTime", ConditionKey.CK_GREATER_EQUAL, _value);
723         if (opLambda != null) {
724             opLambda.callback(builder);
725         }
726     }
727 
728     public void setExpiredTime_LessEqual(Long expiredTime) {
729         setExpiredTime_LessEqual(expiredTime, null);
730     }
731 
732     public void setExpiredTime_LessEqual(Long expiredTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
733         final Object _value = expiredTime;
734         RangeQueryBuilder builder = regRangeQ("expiredTime", ConditionKey.CK_LESS_EQUAL, _value);
735         if (opLambda != null) {
736             opLambda.callback(builder);
737         }
738     }
739 
740     public void setExpiredTime_Exists() {
741         setExpiredTime_Exists(null);
742     }
743 
744     public void setExpiredTime_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
745         ExistsQueryBuilder builder = regExistsQ("expiredTime");
746         if (opLambda != null) {
747             opLambda.callback(builder);
748         }
749     }
750 
751     @Deprecated
752     public void setExpiredTime_CommonTerms(Long expiredTime) {
753         setExpiredTime_CommonTerms(expiredTime, null);
754     }
755 
756     @Deprecated
757     public void setExpiredTime_CommonTerms(Long expiredTime, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
758         CommonTermsQueryBuilder builder = regCommonTermsQ("expiredTime", expiredTime);
759         if (opLambda != null) {
760             opLambda.callback(builder);
761         }
762     }
763 
764     public BsAccessTokenCQ addOrderBy_ExpiredTime_Asc() {
765         regOBA("expiredTime");
766         return this;
767     }
768 
769     public BsAccessTokenCQ addOrderBy_ExpiredTime_Desc() {
770         regOBD("expiredTime");
771         return this;
772     }
773 
774     public void setName_Equal(String name) {
775         setName_Term(name, null);
776     }
777 
778     public void setName_Equal(String name, ConditionOptionCall<TermQueryBuilder> opLambda) {
779         setName_Term(name, opLambda);
780     }
781 
782     public void setName_Term(String name) {
783         setName_Term(name, null);
784     }
785 
786     public void setName_Term(String name, ConditionOptionCall<TermQueryBuilder> opLambda) {
787         TermQueryBuilder builder = regTermQ("name", name);
788         if (opLambda != null) {
789             opLambda.callback(builder);
790         }
791     }
792 
793     public void setName_NotEqual(String name) {
794         setName_NotTerm(name, null);
795     }
796 
797     public void setName_NotTerm(String name) {
798         setName_NotTerm(name, null);
799     }
800 
801     public void setName_NotEqual(String name, ConditionOptionCall<BoolQueryBuilder> opLambda) {
802         setName_NotTerm(name, opLambda);
803     }
804 
805     public void setName_NotTerm(String name, ConditionOptionCall<BoolQueryBuilder> opLambda) {
806         not(not -> not.setName_Term(name), opLambda);
807     }
808 
809     public void setName_Terms(Collection<String> nameList) {
810         setName_Terms(nameList, null);
811     }
812 
813     public void setName_Terms(Collection<String> nameList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
814         TermsQueryBuilder builder = regTermsQ("name", nameList);
815         if (opLambda != null) {
816             opLambda.callback(builder);
817         }
818     }
819 
820     public void setName_InScope(Collection<String> nameList) {
821         setName_Terms(nameList, null);
822     }
823 
824     public void setName_InScope(Collection<String> nameList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
825         setName_Terms(nameList, opLambda);
826     }
827 
828     public void setName_Match(String name) {
829         setName_Match(name, null);
830     }
831 
832     public void setName_Match(String name, ConditionOptionCall<MatchQueryBuilder> opLambda) {
833         MatchQueryBuilder builder = regMatchQ("name", name);
834         if (opLambda != null) {
835             opLambda.callback(builder);
836         }
837     }
838 
839     public void setName_MatchPhrase(String name) {
840         setName_MatchPhrase(name, null);
841     }
842 
843     public void setName_MatchPhrase(String name, ConditionOptionCall<MatchPhraseQueryBuilder> opLambda) {
844         MatchPhraseQueryBuilder builder = regMatchPhraseQ("name", name);
845         if (opLambda != null) {
846             opLambda.callback(builder);
847         }
848     }
849 
850     public void setName_MatchPhrasePrefix(String name) {
851         setName_MatchPhrasePrefix(name, null);
852     }
853 
854     public void setName_MatchPhrasePrefix(String name, ConditionOptionCall<MatchPhrasePrefixQueryBuilder> opLambda) {
855         MatchPhrasePrefixQueryBuilder builder = regMatchPhrasePrefixQ("name", name);
856         if (opLambda != null) {
857             opLambda.callback(builder);
858         }
859     }
860 
861     public void setName_Fuzzy(String name) {
862         setName_Fuzzy(name, null);
863     }
864 
865     public void setName_Fuzzy(String name, ConditionOptionCall<MatchQueryBuilder> opLambda) {
866         MatchQueryBuilder builder = regFuzzyQ("name", name);
867         if (opLambda != null) {
868             opLambda.callback(builder);
869         }
870     }
871 
872     public void setName_Prefix(String name) {
873         setName_Prefix(name, null);
874     }
875 
876     public void setName_Prefix(String name, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
877         PrefixQueryBuilder builder = regPrefixQ("name", name);
878         if (opLambda != null) {
879             opLambda.callback(builder);
880         }
881     }
882 
883     public void setName_Wildcard(String name) {
884         setName_Wildcard(name, null);
885     }
886 
887     public void setName_Wildcard(String name, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
888         WildcardQueryBuilder builder = regWildcardQ("name", name);
889         if (opLambda != null) {
890             opLambda.callback(builder);
891         }
892     }
893 
894     public void setName_Regexp(String name) {
895         setName_Regexp(name, null);
896     }
897 
898     public void setName_Regexp(String name, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
899         RegexpQueryBuilder builder = regRegexpQ("name", name);
900         if (opLambda != null) {
901             opLambda.callback(builder);
902         }
903     }
904 
905     public void setName_SpanTerm(String name) {
906         setName_SpanTerm("name", null);
907     }
908 
909     public void setName_SpanTerm(String name, ConditionOptionCall<SpanTermQueryBuilder> opLambda) {
910         SpanTermQueryBuilder builder = regSpanTermQ("name", name);
911         if (opLambda != null) {
912             opLambda.callback(builder);
913         }
914     }
915 
916     public void setName_GreaterThan(String name) {
917         setName_GreaterThan(name, null);
918     }
919 
920     public void setName_GreaterThan(String name, ConditionOptionCall<RangeQueryBuilder> opLambda) {
921         final Object _value = name;
922         RangeQueryBuilder builder = regRangeQ("name", ConditionKey.CK_GREATER_THAN, _value);
923         if (opLambda != null) {
924             opLambda.callback(builder);
925         }
926     }
927 
928     public void setName_LessThan(String name) {
929         setName_LessThan(name, null);
930     }
931 
932     public void setName_LessThan(String name, ConditionOptionCall<RangeQueryBuilder> opLambda) {
933         final Object _value = name;
934         RangeQueryBuilder builder = regRangeQ("name", ConditionKey.CK_LESS_THAN, _value);
935         if (opLambda != null) {
936             opLambda.callback(builder);
937         }
938     }
939 
940     public void setName_GreaterEqual(String name) {
941         setName_GreaterEqual(name, null);
942     }
943 
944     public void setName_GreaterEqual(String name, ConditionOptionCall<RangeQueryBuilder> opLambda) {
945         final Object _value = name;
946         RangeQueryBuilder builder = regRangeQ("name", ConditionKey.CK_GREATER_EQUAL, _value);
947         if (opLambda != null) {
948             opLambda.callback(builder);
949         }
950     }
951 
952     public void setName_LessEqual(String name) {
953         setName_LessEqual(name, null);
954     }
955 
956     public void setName_LessEqual(String name, ConditionOptionCall<RangeQueryBuilder> opLambda) {
957         final Object _value = name;
958         RangeQueryBuilder builder = regRangeQ("name", ConditionKey.CK_LESS_EQUAL, _value);
959         if (opLambda != null) {
960             opLambda.callback(builder);
961         }
962     }
963 
964     public void setName_Exists() {
965         setName_Exists(null);
966     }
967 
968     public void setName_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
969         ExistsQueryBuilder builder = regExistsQ("name");
970         if (opLambda != null) {
971             opLambda.callback(builder);
972         }
973     }
974 
975     @Deprecated
976     public void setName_CommonTerms(String name) {
977         setName_CommonTerms(name, null);
978     }
979 
980     @Deprecated
981     public void setName_CommonTerms(String name, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
982         CommonTermsQueryBuilder builder = regCommonTermsQ("name", name);
983         if (opLambda != null) {
984             opLambda.callback(builder);
985         }
986     }
987 
988     public BsAccessTokenCQ addOrderBy_Name_Asc() {
989         regOBA("name");
990         return this;
991     }
992 
993     public BsAccessTokenCQ addOrderBy_Name_Desc() {
994         regOBD("name");
995         return this;
996     }
997 
998     public void setParameterName_Equal(String parameterName) {
999         setParameterName_Term(parameterName, null);
1000     }
1001 
1002     public void setParameterName_Equal(String parameterName, ConditionOptionCall<TermQueryBuilder> opLambda) {
1003         setParameterName_Term(parameterName, opLambda);
1004     }
1005 
1006     public void setParameterName_Term(String parameterName) {
1007         setParameterName_Term(parameterName, null);
1008     }
1009 
1010     public void setParameterName_Term(String parameterName, ConditionOptionCall<TermQueryBuilder> opLambda) {
1011         TermQueryBuilder builder = regTermQ("parameter_name", parameterName);
1012         if (opLambda != null) {
1013             opLambda.callback(builder);
1014         }
1015     }
1016 
1017     public void setParameterName_NotEqual(String parameterName) {
1018         setParameterName_NotTerm(parameterName, null);
1019     }
1020 
1021     public void setParameterName_NotTerm(String parameterName) {
1022         setParameterName_NotTerm(parameterName, null);
1023     }
1024 
1025     public void setParameterName_NotEqual(String parameterName, ConditionOptionCall<BoolQueryBuilder> opLambda) {
1026         setParameterName_NotTerm(parameterName, opLambda);
1027     }
1028 
1029     public void setParameterName_NotTerm(String parameterName, ConditionOptionCall<BoolQueryBuilder> opLambda) {
1030         not(not -> not.setParameterName_Term(parameterName), opLambda);
1031     }
1032 
1033     public void setParameterName_Terms(Collection<String> parameterNameList) {
1034         setParameterName_Terms(parameterNameList, null);
1035     }
1036 
1037     public void setParameterName_Terms(Collection<String> parameterNameList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
1038         TermsQueryBuilder builder = regTermsQ("parameter_name", parameterNameList);
1039         if (opLambda != null) {
1040             opLambda.callback(builder);
1041         }
1042     }
1043 
1044     public void setParameterName_InScope(Collection<String> parameterNameList) {
1045         setParameterName_Terms(parameterNameList, null);
1046     }
1047 
1048     public void setParameterName_InScope(Collection<String> parameterNameList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
1049         setParameterName_Terms(parameterNameList, opLambda);
1050     }
1051 
1052     public void setParameterName_Match(String parameterName) {
1053         setParameterName_Match(parameterName, null);
1054     }
1055 
1056     public void setParameterName_Match(String parameterName, ConditionOptionCall<MatchQueryBuilder> opLambda) {
1057         MatchQueryBuilder builder = regMatchQ("parameter_name", parameterName);
1058         if (opLambda != null) {
1059             opLambda.callback(builder);
1060         }
1061     }
1062 
1063     public void setParameterName_MatchPhrase(String parameterName) {
1064         setParameterName_MatchPhrase(parameterName, null);
1065     }
1066 
1067     public void setParameterName_MatchPhrase(String parameterName, ConditionOptionCall<MatchPhraseQueryBuilder> opLambda) {
1068         MatchPhraseQueryBuilder builder = regMatchPhraseQ("parameter_name", parameterName);
1069         if (opLambda != null) {
1070             opLambda.callback(builder);
1071         }
1072     }
1073 
1074     public void setParameterName_MatchPhrasePrefix(String parameterName) {
1075         setParameterName_MatchPhrasePrefix(parameterName, null);
1076     }
1077 
1078     public void setParameterName_MatchPhrasePrefix(String parameterName, ConditionOptionCall<MatchPhrasePrefixQueryBuilder> opLambda) {
1079         MatchPhrasePrefixQueryBuilder builder = regMatchPhrasePrefixQ("parameter_name", parameterName);
1080         if (opLambda != null) {
1081             opLambda.callback(builder);
1082         }
1083     }
1084 
1085     public void setParameterName_Fuzzy(String parameterName) {
1086         setParameterName_Fuzzy(parameterName, null);
1087     }
1088 
1089     public void setParameterName_Fuzzy(String parameterName, ConditionOptionCall<MatchQueryBuilder> opLambda) {
1090         MatchQueryBuilder builder = regFuzzyQ("parameter_name", parameterName);
1091         if (opLambda != null) {
1092             opLambda.callback(builder);
1093         }
1094     }
1095 
1096     public void setParameterName_Prefix(String parameterName) {
1097         setParameterName_Prefix(parameterName, null);
1098     }
1099 
1100     public void setParameterName_Prefix(String parameterName, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
1101         PrefixQueryBuilder builder = regPrefixQ("parameter_name", parameterName);
1102         if (opLambda != null) {
1103             opLambda.callback(builder);
1104         }
1105     }
1106 
1107     public void setParameterName_Wildcard(String parameterName) {
1108         setParameterName_Wildcard(parameterName, null);
1109     }
1110 
1111     public void setParameterName_Wildcard(String parameterName, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
1112         WildcardQueryBuilder builder = regWildcardQ("parameter_name", parameterName);
1113         if (opLambda != null) {
1114             opLambda.callback(builder);
1115         }
1116     }
1117 
1118     public void setParameterName_Regexp(String parameterName) {
1119         setParameterName_Regexp(parameterName, null);
1120     }
1121 
1122     public void setParameterName_Regexp(String parameterName, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
1123         RegexpQueryBuilder builder = regRegexpQ("parameter_name", parameterName);
1124         if (opLambda != null) {
1125             opLambda.callback(builder);
1126         }
1127     }
1128 
1129     public void setParameterName_SpanTerm(String parameterName) {
1130         setParameterName_SpanTerm("parameter_name", null);
1131     }
1132 
1133     public void setParameterName_SpanTerm(String parameterName, ConditionOptionCall<SpanTermQueryBuilder> opLambda) {
1134         SpanTermQueryBuilder builder = regSpanTermQ("parameter_name", parameterName);
1135         if (opLambda != null) {
1136             opLambda.callback(builder);
1137         }
1138     }
1139 
1140     public void setParameterName_GreaterThan(String parameterName) {
1141         setParameterName_GreaterThan(parameterName, null);
1142     }
1143 
1144     public void setParameterName_GreaterThan(String parameterName, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1145         final Object _value = parameterName;
1146         RangeQueryBuilder builder = regRangeQ("parameter_name", ConditionKey.CK_GREATER_THAN, _value);
1147         if (opLambda != null) {
1148             opLambda.callback(builder);
1149         }
1150     }
1151 
1152     public void setParameterName_LessThan(String parameterName) {
1153         setParameterName_LessThan(parameterName, null);
1154     }
1155 
1156     public void setParameterName_LessThan(String parameterName, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1157         final Object _value = parameterName;
1158         RangeQueryBuilder builder = regRangeQ("parameter_name", ConditionKey.CK_LESS_THAN, _value);
1159         if (opLambda != null) {
1160             opLambda.callback(builder);
1161         }
1162     }
1163 
1164     public void setParameterName_GreaterEqual(String parameterName) {
1165         setParameterName_GreaterEqual(parameterName, null);
1166     }
1167 
1168     public void setParameterName_GreaterEqual(String parameterName, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1169         final Object _value = parameterName;
1170         RangeQueryBuilder builder = regRangeQ("parameter_name", ConditionKey.CK_GREATER_EQUAL, _value);
1171         if (opLambda != null) {
1172             opLambda.callback(builder);
1173         }
1174     }
1175 
1176     public void setParameterName_LessEqual(String parameterName) {
1177         setParameterName_LessEqual(parameterName, null);
1178     }
1179 
1180     public void setParameterName_LessEqual(String parameterName, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1181         final Object _value = parameterName;
1182         RangeQueryBuilder builder = regRangeQ("parameter_name", ConditionKey.CK_LESS_EQUAL, _value);
1183         if (opLambda != null) {
1184             opLambda.callback(builder);
1185         }
1186     }
1187 
1188     public void setParameterName_Exists() {
1189         setParameterName_Exists(null);
1190     }
1191 
1192     public void setParameterName_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
1193         ExistsQueryBuilder builder = regExistsQ("parameter_name");
1194         if (opLambda != null) {
1195             opLambda.callback(builder);
1196         }
1197     }
1198 
1199     @Deprecated
1200     public void setParameterName_CommonTerms(String parameterName) {
1201         setParameterName_CommonTerms(parameterName, null);
1202     }
1203 
1204     @Deprecated
1205     public void setParameterName_CommonTerms(String parameterName, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
1206         CommonTermsQueryBuilder builder = regCommonTermsQ("parameter_name", parameterName);
1207         if (opLambda != null) {
1208             opLambda.callback(builder);
1209         }
1210     }
1211 
1212     public BsAccessTokenCQ addOrderBy_ParameterName_Asc() {
1213         regOBA("parameter_name");
1214         return this;
1215     }
1216 
1217     public BsAccessTokenCQ addOrderBy_ParameterName_Desc() {
1218         regOBD("parameter_name");
1219         return this;
1220     }
1221 
1222     public void setPermissions_Equal(String permissions) {
1223         setPermissions_Term(permissions, null);
1224     }
1225 
1226     public void setPermissions_Equal(String permissions, ConditionOptionCall<TermQueryBuilder> opLambda) {
1227         setPermissions_Term(permissions, opLambda);
1228     }
1229 
1230     public void setPermissions_Term(String permissions) {
1231         setPermissions_Term(permissions, null);
1232     }
1233 
1234     public void setPermissions_Term(String permissions, ConditionOptionCall<TermQueryBuilder> opLambda) {
1235         TermQueryBuilder builder = regTermQ("permissions", permissions);
1236         if (opLambda != null) {
1237             opLambda.callback(builder);
1238         }
1239     }
1240 
1241     public void setPermissions_NotEqual(String permissions) {
1242         setPermissions_NotTerm(permissions, null);
1243     }
1244 
1245     public void setPermissions_NotTerm(String permissions) {
1246         setPermissions_NotTerm(permissions, null);
1247     }
1248 
1249     public void setPermissions_NotEqual(String permissions, ConditionOptionCall<BoolQueryBuilder> opLambda) {
1250         setPermissions_NotTerm(permissions, opLambda);
1251     }
1252 
1253     public void setPermissions_NotTerm(String permissions, ConditionOptionCall<BoolQueryBuilder> opLambda) {
1254         not(not -> not.setPermissions_Term(permissions), opLambda);
1255     }
1256 
1257     public void setPermissions_Terms(Collection<String> permissionsList) {
1258         setPermissions_Terms(permissionsList, null);
1259     }
1260 
1261     public void setPermissions_Terms(Collection<String> permissionsList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
1262         TermsQueryBuilder builder = regTermsQ("permissions", permissionsList);
1263         if (opLambda != null) {
1264             opLambda.callback(builder);
1265         }
1266     }
1267 
1268     public void setPermissions_InScope(Collection<String> permissionsList) {
1269         setPermissions_Terms(permissionsList, null);
1270     }
1271 
1272     public void setPermissions_InScope(Collection<String> permissionsList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
1273         setPermissions_Terms(permissionsList, opLambda);
1274     }
1275 
1276     public void setPermissions_Match(String permissions) {
1277         setPermissions_Match(permissions, null);
1278     }
1279 
1280     public void setPermissions_Match(String permissions, ConditionOptionCall<MatchQueryBuilder> opLambda) {
1281         MatchQueryBuilder builder = regMatchQ("permissions", permissions);
1282         if (opLambda != null) {
1283             opLambda.callback(builder);
1284         }
1285     }
1286 
1287     public void setPermissions_MatchPhrase(String permissions) {
1288         setPermissions_MatchPhrase(permissions, null);
1289     }
1290 
1291     public void setPermissions_MatchPhrase(String permissions, ConditionOptionCall<MatchPhraseQueryBuilder> opLambda) {
1292         MatchPhraseQueryBuilder builder = regMatchPhraseQ("permissions", permissions);
1293         if (opLambda != null) {
1294             opLambda.callback(builder);
1295         }
1296     }
1297 
1298     public void setPermissions_MatchPhrasePrefix(String permissions) {
1299         setPermissions_MatchPhrasePrefix(permissions, null);
1300     }
1301 
1302     public void setPermissions_MatchPhrasePrefix(String permissions, ConditionOptionCall<MatchPhrasePrefixQueryBuilder> opLambda) {
1303         MatchPhrasePrefixQueryBuilder builder = regMatchPhrasePrefixQ("permissions", permissions);
1304         if (opLambda != null) {
1305             opLambda.callback(builder);
1306         }
1307     }
1308 
1309     public void setPermissions_Fuzzy(String permissions) {
1310         setPermissions_Fuzzy(permissions, null);
1311     }
1312 
1313     public void setPermissions_Fuzzy(String permissions, ConditionOptionCall<MatchQueryBuilder> opLambda) {
1314         MatchQueryBuilder builder = regFuzzyQ("permissions", permissions);
1315         if (opLambda != null) {
1316             opLambda.callback(builder);
1317         }
1318     }
1319 
1320     public void setPermissions_Prefix(String permissions) {
1321         setPermissions_Prefix(permissions, null);
1322     }
1323 
1324     public void setPermissions_Prefix(String permissions, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
1325         PrefixQueryBuilder builder = regPrefixQ("permissions", permissions);
1326         if (opLambda != null) {
1327             opLambda.callback(builder);
1328         }
1329     }
1330 
1331     public void setPermissions_Wildcard(String permissions) {
1332         setPermissions_Wildcard(permissions, null);
1333     }
1334 
1335     public void setPermissions_Wildcard(String permissions, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
1336         WildcardQueryBuilder builder = regWildcardQ("permissions", permissions);
1337         if (opLambda != null) {
1338             opLambda.callback(builder);
1339         }
1340     }
1341 
1342     public void setPermissions_Regexp(String permissions) {
1343         setPermissions_Regexp(permissions, null);
1344     }
1345 
1346     public void setPermissions_Regexp(String permissions, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
1347         RegexpQueryBuilder builder = regRegexpQ("permissions", permissions);
1348         if (opLambda != null) {
1349             opLambda.callback(builder);
1350         }
1351     }
1352 
1353     public void setPermissions_SpanTerm(String permissions) {
1354         setPermissions_SpanTerm("permissions", null);
1355     }
1356 
1357     public void setPermissions_SpanTerm(String permissions, ConditionOptionCall<SpanTermQueryBuilder> opLambda) {
1358         SpanTermQueryBuilder builder = regSpanTermQ("permissions", permissions);
1359         if (opLambda != null) {
1360             opLambda.callback(builder);
1361         }
1362     }
1363 
1364     public void setPermissions_GreaterThan(String permissions) {
1365         setPermissions_GreaterThan(permissions, null);
1366     }
1367 
1368     public void setPermissions_GreaterThan(String permissions, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1369         final Object _value = permissions;
1370         RangeQueryBuilder builder = regRangeQ("permissions", ConditionKey.CK_GREATER_THAN, _value);
1371         if (opLambda != null) {
1372             opLambda.callback(builder);
1373         }
1374     }
1375 
1376     public void setPermissions_LessThan(String permissions) {
1377         setPermissions_LessThan(permissions, null);
1378     }
1379 
1380     public void setPermissions_LessThan(String permissions, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1381         final Object _value = permissions;
1382         RangeQueryBuilder builder = regRangeQ("permissions", ConditionKey.CK_LESS_THAN, _value);
1383         if (opLambda != null) {
1384             opLambda.callback(builder);
1385         }
1386     }
1387 
1388     public void setPermissions_GreaterEqual(String permissions) {
1389         setPermissions_GreaterEqual(permissions, null);
1390     }
1391 
1392     public void setPermissions_GreaterEqual(String permissions, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1393         final Object _value = permissions;
1394         RangeQueryBuilder builder = regRangeQ("permissions", ConditionKey.CK_GREATER_EQUAL, _value);
1395         if (opLambda != null) {
1396             opLambda.callback(builder);
1397         }
1398     }
1399 
1400     public void setPermissions_LessEqual(String permissions) {
1401         setPermissions_LessEqual(permissions, null);
1402     }
1403 
1404     public void setPermissions_LessEqual(String permissions, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1405         final Object _value = permissions;
1406         RangeQueryBuilder builder = regRangeQ("permissions", ConditionKey.CK_LESS_EQUAL, _value);
1407         if (opLambda != null) {
1408             opLambda.callback(builder);
1409         }
1410     }
1411 
1412     public void setPermissions_Exists() {
1413         setPermissions_Exists(null);
1414     }
1415 
1416     public void setPermissions_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
1417         ExistsQueryBuilder builder = regExistsQ("permissions");
1418         if (opLambda != null) {
1419             opLambda.callback(builder);
1420         }
1421     }
1422 
1423     @Deprecated
1424     public void setPermissions_CommonTerms(String permissions) {
1425         setPermissions_CommonTerms(permissions, null);
1426     }
1427 
1428     @Deprecated
1429     public void setPermissions_CommonTerms(String permissions, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
1430         CommonTermsQueryBuilder builder = regCommonTermsQ("permissions", permissions);
1431         if (opLambda != null) {
1432             opLambda.callback(builder);
1433         }
1434     }
1435 
1436     public BsAccessTokenCQ addOrderBy_Permissions_Asc() {
1437         regOBA("permissions");
1438         return this;
1439     }
1440 
1441     public BsAccessTokenCQ addOrderBy_Permissions_Desc() {
1442         regOBD("permissions");
1443         return this;
1444     }
1445 
1446     public void setToken_Equal(String token) {
1447         setToken_Term(token, null);
1448     }
1449 
1450     public void setToken_Equal(String token, ConditionOptionCall<TermQueryBuilder> opLambda) {
1451         setToken_Term(token, opLambda);
1452     }
1453 
1454     public void setToken_Term(String token) {
1455         setToken_Term(token, null);
1456     }
1457 
1458     public void setToken_Term(String token, ConditionOptionCall<TermQueryBuilder> opLambda) {
1459         TermQueryBuilder builder = regTermQ("token", token);
1460         if (opLambda != null) {
1461             opLambda.callback(builder);
1462         }
1463     }
1464 
1465     public void setToken_NotEqual(String token) {
1466         setToken_NotTerm(token, null);
1467     }
1468 
1469     public void setToken_NotTerm(String token) {
1470         setToken_NotTerm(token, null);
1471     }
1472 
1473     public void setToken_NotEqual(String token, ConditionOptionCall<BoolQueryBuilder> opLambda) {
1474         setToken_NotTerm(token, opLambda);
1475     }
1476 
1477     public void setToken_NotTerm(String token, ConditionOptionCall<BoolQueryBuilder> opLambda) {
1478         not(not -> not.setToken_Term(token), opLambda);
1479     }
1480 
1481     public void setToken_Terms(Collection<String> tokenList) {
1482         setToken_Terms(tokenList, null);
1483     }
1484 
1485     public void setToken_Terms(Collection<String> tokenList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
1486         TermsQueryBuilder builder = regTermsQ("token", tokenList);
1487         if (opLambda != null) {
1488             opLambda.callback(builder);
1489         }
1490     }
1491 
1492     public void setToken_InScope(Collection<String> tokenList) {
1493         setToken_Terms(tokenList, null);
1494     }
1495 
1496     public void setToken_InScope(Collection<String> tokenList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
1497         setToken_Terms(tokenList, opLambda);
1498     }
1499 
1500     public void setToken_Match(String token) {
1501         setToken_Match(token, null);
1502     }
1503 
1504     public void setToken_Match(String token, ConditionOptionCall<MatchQueryBuilder> opLambda) {
1505         MatchQueryBuilder builder = regMatchQ("token", token);
1506         if (opLambda != null) {
1507             opLambda.callback(builder);
1508         }
1509     }
1510 
1511     public void setToken_MatchPhrase(String token) {
1512         setToken_MatchPhrase(token, null);
1513     }
1514 
1515     public void setToken_MatchPhrase(String token, ConditionOptionCall<MatchPhraseQueryBuilder> opLambda) {
1516         MatchPhraseQueryBuilder builder = regMatchPhraseQ("token", token);
1517         if (opLambda != null) {
1518             opLambda.callback(builder);
1519         }
1520     }
1521 
1522     public void setToken_MatchPhrasePrefix(String token) {
1523         setToken_MatchPhrasePrefix(token, null);
1524     }
1525 
1526     public void setToken_MatchPhrasePrefix(String token, ConditionOptionCall<MatchPhrasePrefixQueryBuilder> opLambda) {
1527         MatchPhrasePrefixQueryBuilder builder = regMatchPhrasePrefixQ("token", token);
1528         if (opLambda != null) {
1529             opLambda.callback(builder);
1530         }
1531     }
1532 
1533     public void setToken_Fuzzy(String token) {
1534         setToken_Fuzzy(token, null);
1535     }
1536 
1537     public void setToken_Fuzzy(String token, ConditionOptionCall<MatchQueryBuilder> opLambda) {
1538         MatchQueryBuilder builder = regFuzzyQ("token", token);
1539         if (opLambda != null) {
1540             opLambda.callback(builder);
1541         }
1542     }
1543 
1544     public void setToken_Prefix(String token) {
1545         setToken_Prefix(token, null);
1546     }
1547 
1548     public void setToken_Prefix(String token, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
1549         PrefixQueryBuilder builder = regPrefixQ("token", token);
1550         if (opLambda != null) {
1551             opLambda.callback(builder);
1552         }
1553     }
1554 
1555     public void setToken_Wildcard(String token) {
1556         setToken_Wildcard(token, null);
1557     }
1558 
1559     public void setToken_Wildcard(String token, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
1560         WildcardQueryBuilder builder = regWildcardQ("token", token);
1561         if (opLambda != null) {
1562             opLambda.callback(builder);
1563         }
1564     }
1565 
1566     public void setToken_Regexp(String token) {
1567         setToken_Regexp(token, null);
1568     }
1569 
1570     public void setToken_Regexp(String token, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
1571         RegexpQueryBuilder builder = regRegexpQ("token", token);
1572         if (opLambda != null) {
1573             opLambda.callback(builder);
1574         }
1575     }
1576 
1577     public void setToken_SpanTerm(String token) {
1578         setToken_SpanTerm("token", null);
1579     }
1580 
1581     public void setToken_SpanTerm(String token, ConditionOptionCall<SpanTermQueryBuilder> opLambda) {
1582         SpanTermQueryBuilder builder = regSpanTermQ("token", token);
1583         if (opLambda != null) {
1584             opLambda.callback(builder);
1585         }
1586     }
1587 
1588     public void setToken_GreaterThan(String token) {
1589         setToken_GreaterThan(token, null);
1590     }
1591 
1592     public void setToken_GreaterThan(String token, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1593         final Object _value = token;
1594         RangeQueryBuilder builder = regRangeQ("token", ConditionKey.CK_GREATER_THAN, _value);
1595         if (opLambda != null) {
1596             opLambda.callback(builder);
1597         }
1598     }
1599 
1600     public void setToken_LessThan(String token) {
1601         setToken_LessThan(token, null);
1602     }
1603 
1604     public void setToken_LessThan(String token, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1605         final Object _value = token;
1606         RangeQueryBuilder builder = regRangeQ("token", ConditionKey.CK_LESS_THAN, _value);
1607         if (opLambda != null) {
1608             opLambda.callback(builder);
1609         }
1610     }
1611 
1612     public void setToken_GreaterEqual(String token) {
1613         setToken_GreaterEqual(token, null);
1614     }
1615 
1616     public void setToken_GreaterEqual(String token, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1617         final Object _value = token;
1618         RangeQueryBuilder builder = regRangeQ("token", ConditionKey.CK_GREATER_EQUAL, _value);
1619         if (opLambda != null) {
1620             opLambda.callback(builder);
1621         }
1622     }
1623 
1624     public void setToken_LessEqual(String token) {
1625         setToken_LessEqual(token, null);
1626     }
1627 
1628     public void setToken_LessEqual(String token, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1629         final Object _value = token;
1630         RangeQueryBuilder builder = regRangeQ("token", ConditionKey.CK_LESS_EQUAL, _value);
1631         if (opLambda != null) {
1632             opLambda.callback(builder);
1633         }
1634     }
1635 
1636     public void setToken_Exists() {
1637         setToken_Exists(null);
1638     }
1639 
1640     public void setToken_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
1641         ExistsQueryBuilder builder = regExistsQ("token");
1642         if (opLambda != null) {
1643             opLambda.callback(builder);
1644         }
1645     }
1646 
1647     @Deprecated
1648     public void setToken_CommonTerms(String token) {
1649         setToken_CommonTerms(token, null);
1650     }
1651 
1652     @Deprecated
1653     public void setToken_CommonTerms(String token, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
1654         CommonTermsQueryBuilder builder = regCommonTermsQ("token", token);
1655         if (opLambda != null) {
1656             opLambda.callback(builder);
1657         }
1658     }
1659 
1660     public BsAccessTokenCQ addOrderBy_Token_Asc() {
1661         regOBA("token");
1662         return this;
1663     }
1664 
1665     public BsAccessTokenCQ addOrderBy_Token_Desc() {
1666         regOBD("token");
1667         return this;
1668     }
1669 
1670     public void setUpdatedBy_Equal(String updatedBy) {
1671         setUpdatedBy_Term(updatedBy, null);
1672     }
1673 
1674     public void setUpdatedBy_Equal(String updatedBy, ConditionOptionCall<TermQueryBuilder> opLambda) {
1675         setUpdatedBy_Term(updatedBy, opLambda);
1676     }
1677 
1678     public void setUpdatedBy_Term(String updatedBy) {
1679         setUpdatedBy_Term(updatedBy, null);
1680     }
1681 
1682     public void setUpdatedBy_Term(String updatedBy, ConditionOptionCall<TermQueryBuilder> opLambda) {
1683         TermQueryBuilder builder = regTermQ("updatedBy", updatedBy);
1684         if (opLambda != null) {
1685             opLambda.callback(builder);
1686         }
1687     }
1688 
1689     public void setUpdatedBy_NotEqual(String updatedBy) {
1690         setUpdatedBy_NotTerm(updatedBy, null);
1691     }
1692 
1693     public void setUpdatedBy_NotTerm(String updatedBy) {
1694         setUpdatedBy_NotTerm(updatedBy, null);
1695     }
1696 
1697     public void setUpdatedBy_NotEqual(String updatedBy, ConditionOptionCall<BoolQueryBuilder> opLambda) {
1698         setUpdatedBy_NotTerm(updatedBy, opLambda);
1699     }
1700 
1701     public void setUpdatedBy_NotTerm(String updatedBy, ConditionOptionCall<BoolQueryBuilder> opLambda) {
1702         not(not -> not.setUpdatedBy_Term(updatedBy), opLambda);
1703     }
1704 
1705     public void setUpdatedBy_Terms(Collection<String> updatedByList) {
1706         setUpdatedBy_Terms(updatedByList, null);
1707     }
1708 
1709     public void setUpdatedBy_Terms(Collection<String> updatedByList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
1710         TermsQueryBuilder builder = regTermsQ("updatedBy", updatedByList);
1711         if (opLambda != null) {
1712             opLambda.callback(builder);
1713         }
1714     }
1715 
1716     public void setUpdatedBy_InScope(Collection<String> updatedByList) {
1717         setUpdatedBy_Terms(updatedByList, null);
1718     }
1719 
1720     public void setUpdatedBy_InScope(Collection<String> updatedByList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
1721         setUpdatedBy_Terms(updatedByList, opLambda);
1722     }
1723 
1724     public void setUpdatedBy_Match(String updatedBy) {
1725         setUpdatedBy_Match(updatedBy, null);
1726     }
1727 
1728     public void setUpdatedBy_Match(String updatedBy, ConditionOptionCall<MatchQueryBuilder> opLambda) {
1729         MatchQueryBuilder builder = regMatchQ("updatedBy", updatedBy);
1730         if (opLambda != null) {
1731             opLambda.callback(builder);
1732         }
1733     }
1734 
1735     public void setUpdatedBy_MatchPhrase(String updatedBy) {
1736         setUpdatedBy_MatchPhrase(updatedBy, null);
1737     }
1738 
1739     public void setUpdatedBy_MatchPhrase(String updatedBy, ConditionOptionCall<MatchPhraseQueryBuilder> opLambda) {
1740         MatchPhraseQueryBuilder builder = regMatchPhraseQ("updatedBy", updatedBy);
1741         if (opLambda != null) {
1742             opLambda.callback(builder);
1743         }
1744     }
1745 
1746     public void setUpdatedBy_MatchPhrasePrefix(String updatedBy) {
1747         setUpdatedBy_MatchPhrasePrefix(updatedBy, null);
1748     }
1749 
1750     public void setUpdatedBy_MatchPhrasePrefix(String updatedBy, ConditionOptionCall<MatchPhrasePrefixQueryBuilder> opLambda) {
1751         MatchPhrasePrefixQueryBuilder builder = regMatchPhrasePrefixQ("updatedBy", updatedBy);
1752         if (opLambda != null) {
1753             opLambda.callback(builder);
1754         }
1755     }
1756 
1757     public void setUpdatedBy_Fuzzy(String updatedBy) {
1758         setUpdatedBy_Fuzzy(updatedBy, null);
1759     }
1760 
1761     public void setUpdatedBy_Fuzzy(String updatedBy, ConditionOptionCall<MatchQueryBuilder> opLambda) {
1762         MatchQueryBuilder builder = regFuzzyQ("updatedBy", updatedBy);
1763         if (opLambda != null) {
1764             opLambda.callback(builder);
1765         }
1766     }
1767 
1768     public void setUpdatedBy_Prefix(String updatedBy) {
1769         setUpdatedBy_Prefix(updatedBy, null);
1770     }
1771 
1772     public void setUpdatedBy_Prefix(String updatedBy, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
1773         PrefixQueryBuilder builder = regPrefixQ("updatedBy", updatedBy);
1774         if (opLambda != null) {
1775             opLambda.callback(builder);
1776         }
1777     }
1778 
1779     public void setUpdatedBy_Wildcard(String updatedBy) {
1780         setUpdatedBy_Wildcard(updatedBy, null);
1781     }
1782 
1783     public void setUpdatedBy_Wildcard(String updatedBy, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
1784         WildcardQueryBuilder builder = regWildcardQ("updatedBy", updatedBy);
1785         if (opLambda != null) {
1786             opLambda.callback(builder);
1787         }
1788     }
1789 
1790     public void setUpdatedBy_Regexp(String updatedBy) {
1791         setUpdatedBy_Regexp(updatedBy, null);
1792     }
1793 
1794     public void setUpdatedBy_Regexp(String updatedBy, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
1795         RegexpQueryBuilder builder = regRegexpQ("updatedBy", updatedBy);
1796         if (opLambda != null) {
1797             opLambda.callback(builder);
1798         }
1799     }
1800 
1801     public void setUpdatedBy_SpanTerm(String updatedBy) {
1802         setUpdatedBy_SpanTerm("updatedBy", null);
1803     }
1804 
1805     public void setUpdatedBy_SpanTerm(String updatedBy, ConditionOptionCall<SpanTermQueryBuilder> opLambda) {
1806         SpanTermQueryBuilder builder = regSpanTermQ("updatedBy", updatedBy);
1807         if (opLambda != null) {
1808             opLambda.callback(builder);
1809         }
1810     }
1811 
1812     public void setUpdatedBy_GreaterThan(String updatedBy) {
1813         setUpdatedBy_GreaterThan(updatedBy, null);
1814     }
1815 
1816     public void setUpdatedBy_GreaterThan(String updatedBy, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1817         final Object _value = updatedBy;
1818         RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_GREATER_THAN, _value);
1819         if (opLambda != null) {
1820             opLambda.callback(builder);
1821         }
1822     }
1823 
1824     public void setUpdatedBy_LessThan(String updatedBy) {
1825         setUpdatedBy_LessThan(updatedBy, null);
1826     }
1827 
1828     public void setUpdatedBy_LessThan(String updatedBy, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1829         final Object _value = updatedBy;
1830         RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_LESS_THAN, _value);
1831         if (opLambda != null) {
1832             opLambda.callback(builder);
1833         }
1834     }
1835 
1836     public void setUpdatedBy_GreaterEqual(String updatedBy) {
1837         setUpdatedBy_GreaterEqual(updatedBy, null);
1838     }
1839 
1840     public void setUpdatedBy_GreaterEqual(String updatedBy, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1841         final Object _value = updatedBy;
1842         RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_GREATER_EQUAL, _value);
1843         if (opLambda != null) {
1844             opLambda.callback(builder);
1845         }
1846     }
1847 
1848     public void setUpdatedBy_LessEqual(String updatedBy) {
1849         setUpdatedBy_LessEqual(updatedBy, null);
1850     }
1851 
1852     public void setUpdatedBy_LessEqual(String updatedBy, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1853         final Object _value = updatedBy;
1854         RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_LESS_EQUAL, _value);
1855         if (opLambda != null) {
1856             opLambda.callback(builder);
1857         }
1858     }
1859 
1860     public void setUpdatedBy_Exists() {
1861         setUpdatedBy_Exists(null);
1862     }
1863 
1864     public void setUpdatedBy_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
1865         ExistsQueryBuilder builder = regExistsQ("updatedBy");
1866         if (opLambda != null) {
1867             opLambda.callback(builder);
1868         }
1869     }
1870 
1871     @Deprecated
1872     public void setUpdatedBy_CommonTerms(String updatedBy) {
1873         setUpdatedBy_CommonTerms(updatedBy, null);
1874     }
1875 
1876     @Deprecated
1877     public void setUpdatedBy_CommonTerms(String updatedBy, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
1878         CommonTermsQueryBuilder builder = regCommonTermsQ("updatedBy", updatedBy);
1879         if (opLambda != null) {
1880             opLambda.callback(builder);
1881         }
1882     }
1883 
1884     public BsAccessTokenCQ addOrderBy_UpdatedBy_Asc() {
1885         regOBA("updatedBy");
1886         return this;
1887     }
1888 
1889     public BsAccessTokenCQ addOrderBy_UpdatedBy_Desc() {
1890         regOBD("updatedBy");
1891         return this;
1892     }
1893 
1894     public void setUpdatedTime_Equal(Long updatedTime) {
1895         setUpdatedTime_Term(updatedTime, null);
1896     }
1897 
1898     public void setUpdatedTime_Equal(Long updatedTime, ConditionOptionCall<TermQueryBuilder> opLambda) {
1899         setUpdatedTime_Term(updatedTime, opLambda);
1900     }
1901 
1902     public void setUpdatedTime_Term(Long updatedTime) {
1903         setUpdatedTime_Term(updatedTime, null);
1904     }
1905 
1906     public void setUpdatedTime_Term(Long updatedTime, ConditionOptionCall<TermQueryBuilder> opLambda) {
1907         TermQueryBuilder builder = regTermQ("updatedTime", updatedTime);
1908         if (opLambda != null) {
1909             opLambda.callback(builder);
1910         }
1911     }
1912 
1913     public void setUpdatedTime_NotEqual(Long updatedTime) {
1914         setUpdatedTime_NotTerm(updatedTime, null);
1915     }
1916 
1917     public void setUpdatedTime_NotTerm(Long updatedTime) {
1918         setUpdatedTime_NotTerm(updatedTime, null);
1919     }
1920 
1921     public void setUpdatedTime_NotEqual(Long updatedTime, ConditionOptionCall<BoolQueryBuilder> opLambda) {
1922         setUpdatedTime_NotTerm(updatedTime, opLambda);
1923     }
1924 
1925     public void setUpdatedTime_NotTerm(Long updatedTime, ConditionOptionCall<BoolQueryBuilder> opLambda) {
1926         not(not -> not.setUpdatedTime_Term(updatedTime), opLambda);
1927     }
1928 
1929     public void setUpdatedTime_Terms(Collection<Long> updatedTimeList) {
1930         setUpdatedTime_Terms(updatedTimeList, null);
1931     }
1932 
1933     public void setUpdatedTime_Terms(Collection<Long> updatedTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
1934         TermsQueryBuilder builder = regTermsQ("updatedTime", updatedTimeList);
1935         if (opLambda != null) {
1936             opLambda.callback(builder);
1937         }
1938     }
1939 
1940     public void setUpdatedTime_InScope(Collection<Long> updatedTimeList) {
1941         setUpdatedTime_Terms(updatedTimeList, null);
1942     }
1943 
1944     public void setUpdatedTime_InScope(Collection<Long> updatedTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
1945         setUpdatedTime_Terms(updatedTimeList, opLambda);
1946     }
1947 
1948     public void setUpdatedTime_Match(Long updatedTime) {
1949         setUpdatedTime_Match(updatedTime, null);
1950     }
1951 
1952     public void setUpdatedTime_Match(Long updatedTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
1953         MatchQueryBuilder builder = regMatchQ("updatedTime", updatedTime);
1954         if (opLambda != null) {
1955             opLambda.callback(builder);
1956         }
1957     }
1958 
1959     public void setUpdatedTime_MatchPhrase(Long updatedTime) {
1960         setUpdatedTime_MatchPhrase(updatedTime, null);
1961     }
1962 
1963     public void setUpdatedTime_MatchPhrase(Long updatedTime, ConditionOptionCall<MatchPhraseQueryBuilder> opLambda) {
1964         MatchPhraseQueryBuilder builder = regMatchPhraseQ("updatedTime", updatedTime);
1965         if (opLambda != null) {
1966             opLambda.callback(builder);
1967         }
1968     }
1969 
1970     public void setUpdatedTime_MatchPhrasePrefix(Long updatedTime) {
1971         setUpdatedTime_MatchPhrasePrefix(updatedTime, null);
1972     }
1973 
1974     public void setUpdatedTime_MatchPhrasePrefix(Long updatedTime, ConditionOptionCall<MatchPhrasePrefixQueryBuilder> opLambda) {
1975         MatchPhrasePrefixQueryBuilder builder = regMatchPhrasePrefixQ("updatedTime", updatedTime);
1976         if (opLambda != null) {
1977             opLambda.callback(builder);
1978         }
1979     }
1980 
1981     public void setUpdatedTime_Fuzzy(Long updatedTime) {
1982         setUpdatedTime_Fuzzy(updatedTime, null);
1983     }
1984 
1985     public void setUpdatedTime_Fuzzy(Long updatedTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
1986         MatchQueryBuilder builder = regFuzzyQ("updatedTime", updatedTime);
1987         if (opLambda != null) {
1988             opLambda.callback(builder);
1989         }
1990     }
1991 
1992     public void setUpdatedTime_GreaterThan(Long updatedTime) {
1993         setUpdatedTime_GreaterThan(updatedTime, null);
1994     }
1995 
1996     public void setUpdatedTime_GreaterThan(Long updatedTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1997         final Object _value = updatedTime;
1998         RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_GREATER_THAN, _value);
1999         if (opLambda != null) {
2000             opLambda.callback(builder);
2001         }
2002     }
2003 
2004     public void setUpdatedTime_LessThan(Long updatedTime) {
2005         setUpdatedTime_LessThan(updatedTime, null);
2006     }
2007 
2008     public void setUpdatedTime_LessThan(Long updatedTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
2009         final Object _value = updatedTime;
2010         RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_LESS_THAN, _value);
2011         if (opLambda != null) {
2012             opLambda.callback(builder);
2013         }
2014     }
2015 
2016     public void setUpdatedTime_GreaterEqual(Long updatedTime) {
2017         setUpdatedTime_GreaterEqual(updatedTime, null);
2018     }
2019 
2020     public void setUpdatedTime_GreaterEqual(Long updatedTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
2021         final Object _value = updatedTime;
2022         RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_GREATER_EQUAL, _value);
2023         if (opLambda != null) {
2024             opLambda.callback(builder);
2025         }
2026     }
2027 
2028     public void setUpdatedTime_LessEqual(Long updatedTime) {
2029         setUpdatedTime_LessEqual(updatedTime, null);
2030     }
2031 
2032     public void setUpdatedTime_LessEqual(Long updatedTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
2033         final Object _value = updatedTime;
2034         RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_LESS_EQUAL, _value);
2035         if (opLambda != null) {
2036             opLambda.callback(builder);
2037         }
2038     }
2039 
2040     public void setUpdatedTime_Exists() {
2041         setUpdatedTime_Exists(null);
2042     }
2043 
2044     public void setUpdatedTime_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
2045         ExistsQueryBuilder builder = regExistsQ("updatedTime");
2046         if (opLambda != null) {
2047             opLambda.callback(builder);
2048         }
2049     }
2050 
2051     @Deprecated
2052     public void setUpdatedTime_CommonTerms(Long updatedTime) {
2053         setUpdatedTime_CommonTerms(updatedTime, null);
2054     }
2055 
2056     @Deprecated
2057     public void setUpdatedTime_CommonTerms(Long updatedTime, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
2058         CommonTermsQueryBuilder builder = regCommonTermsQ("updatedTime", updatedTime);
2059         if (opLambda != null) {
2060             opLambda.callback(builder);
2061         }
2062     }
2063 
2064     public BsAccessTokenCQ addOrderBy_UpdatedTime_Asc() {
2065         regOBA("updatedTime");
2066         return this;
2067     }
2068 
2069     public BsAccessTokenCQ addOrderBy_UpdatedTime_Desc() {
2070         regOBD("updatedTime");
2071         return this;
2072     }
2073 
2074 }