BsSearchLogCQ (Open Source Enterprise Search: Fess API)

java.lang.Object
- org.codelibs.fess.es.log.allcommon.EsAbstractConditionQuery
- - org.codelibs.fess.es.log.cbean.cq.bs.BsSearchLogCQ

All Implemented Interfaces:

org.dbflute.cbean.ConditionQuery

Direct Known Subclasses:

SearchLogCQ
```
public abstract class BsSearchLogCQ
extends EsAbstractConditionQuery
```
Author:

ESFlute (using FreeGen)

Nested Class Summary
- Nested classes/interfaces inherited from class org.codelibs.fess.es.log.allcommon.EsAbstractConditionQuery
  EsAbstractConditionQuery.BoolCall<CQ extends EsAbstractConditionQuery>, EsAbstractConditionQuery.ConditionOptionCall<OP extends org.elasticsearch.index.query.QueryBuilder>, EsAbstractConditionQuery.DocMetaCQ, EsAbstractConditionQuery.FilteredCall<CQ extends EsAbstractConditionQuery,CF extends EsAbstractConditionQuery>, EsAbstractConditionQuery.OperatorCall<CQ extends EsAbstractConditionQuery>, EsAbstractConditionQuery.ScoreFunctionCall<CC extends EsAbstractConditionQuery.ScoreFunctionCreator<?>>, EsAbstractConditionQuery.ScoreFunctionCreator<T extends EsAbstractConditionQuery>

Field Summary

Fields
Modifier and Type Field and Description

protected static Class<?> suppressUnusedImportLocalDateTime
- Fields inherited from class org.codelibs.fess.es.log.allcommon.EsAbstractConditionQuery
  CQ_PROPERTY, fieldSortBuilderList, queryBuilderList

Fields
Modifier and Type	Field and Description
`protected static Class<?>`	`suppressUnusedImportLocalDateTime`

Constructor Summary

Constructors
Constructor and Description

BsSearchLogCQ()

Constructors
Constructor and Description
`BsSearchLogCQ()`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`BsSearchLogCQ`	`addOrderBy_AccessType_Asc()`
`BsSearchLogCQ`	`addOrderBy_AccessType_Desc()`
`BsSearchLogCQ`	`addOrderBy_ClientIp_Asc()`
`BsSearchLogCQ`	`addOrderBy_ClientIp_Desc()`
`BsSearchLogCQ`	`addOrderBy_HitCount_Asc()`
`BsSearchLogCQ`	`addOrderBy_HitCount_Desc()`
`BsSearchLogCQ`	`addOrderBy_Id_Asc()`
`BsSearchLogCQ`	`addOrderBy_Id_Desc()`
`BsSearchLogCQ`	`addOrderBy_Languages_Asc()`
`BsSearchLogCQ`	`addOrderBy_Languages_Desc()`
`BsSearchLogCQ`	`addOrderBy_QueryId_Asc()`
`BsSearchLogCQ`	`addOrderBy_QueryId_Desc()`
`BsSearchLogCQ`	`addOrderBy_QueryOffset_Asc()`
`BsSearchLogCQ`	`addOrderBy_QueryOffset_Desc()`
`BsSearchLogCQ`	`addOrderBy_QueryPageSize_Asc()`
`BsSearchLogCQ`	`addOrderBy_QueryPageSize_Desc()`
`BsSearchLogCQ`	`addOrderBy_QueryTime_Asc()`
`BsSearchLogCQ`	`addOrderBy_QueryTime_Desc()`
`BsSearchLogCQ`	`addOrderBy_Referer_Asc()`
`BsSearchLogCQ`	`addOrderBy_Referer_Desc()`
`BsSearchLogCQ`	`addOrderBy_RequestedAt_Asc()`
`BsSearchLogCQ`	`addOrderBy_RequestedAt_Desc()`
`BsSearchLogCQ`	`addOrderBy_ResponseTime_Asc()`
`BsSearchLogCQ`	`addOrderBy_ResponseTime_Desc()`
`BsSearchLogCQ`	`addOrderBy_Roles_Asc()`
`BsSearchLogCQ`	`addOrderBy_Roles_Desc()`
`BsSearchLogCQ`	`addOrderBy_SearchWord_Asc()`
`BsSearchLogCQ`	`addOrderBy_SearchWord_Desc()`
`BsSearchLogCQ`	`addOrderBy_User_Asc()`
`BsSearchLogCQ`	`addOrderBy_User_Desc()`
`BsSearchLogCQ`	`addOrderBy_UserAgent_Asc()`
`BsSearchLogCQ`	`addOrderBy_UserAgent_Desc()`
`BsSearchLogCQ`	`addOrderBy_UserInfoId_Asc()`
`BsSearchLogCQ`	`addOrderBy_UserInfoId_Desc()`
`BsSearchLogCQ`	`addOrderBy_UserSessionId_Asc()`
`BsSearchLogCQ`	`addOrderBy_UserSessionId_Desc()`
`BsSearchLogCQ`	`addOrderBy_VirtualHost_Asc()`
`BsSearchLogCQ`	`addOrderBy_VirtualHost_Desc()`
`String`	`asTableDbName()`
`void`	`bool(EsAbstractConditionQuery.BoolCall<SearchLogCQ> boolLambda)`
`void`	`bool(EsAbstractConditionQuery.BoolCall<SearchLogCQ> boolLambda, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)`
`void`	`filtered(EsAbstractConditionQuery.FilteredCall<SearchLogCQ,SearchLogCQ> filteredLambda)`
`void`	`filtered(EsAbstractConditionQuery.FilteredCall<SearchLogCQ,SearchLogCQ> filteredLambda, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)`
`void`	`functionScore(EsAbstractConditionQuery.OperatorCall<SearchLogCQ> queryLambda, EsAbstractConditionQuery.ScoreFunctionCall<EsAbstractConditionQuery.ScoreFunctionCreator<SearchLogCQ>> functionsLambda, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.functionscore.FunctionScoreQueryBuilder> opLambda)`
`void`	`not(EsAbstractConditionQuery.OperatorCall<SearchLogCQ> notLambda)`
`void`	`not(EsAbstractConditionQuery.OperatorCall<SearchLogCQ> notLambda, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)`
`void`	`setAccessType_CommonTerms(String accessType)`
`void`	`setAccessType_CommonTerms(String accessType, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.CommonTermsQueryBuilder> opLambda)`
`void`	`setAccessType_Equal(String accessType)`
`void`	`setAccessType_Equal(String accessType, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)`
`void`	`setAccessType_Exists()`
`void`	`setAccessType_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.ExistsQueryBuilder> opLambda)`
`void`	`setAccessType_Fuzzy(String accessType)`
`void`	`setAccessType_Fuzzy(String accessType, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)`
`void`	`setAccessType_GreaterEqual(String accessType)`
`void`	`setAccessType_GreaterEqual(String accessType, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setAccessType_GreaterThan(String accessType)`
`void`	`setAccessType_GreaterThan(String accessType, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setAccessType_InScope(Collection<String> accessTypeList)`
`void`	`setAccessType_InScope(Collection<String> accessTypeList, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)`
`void`	`setAccessType_LessEqual(String accessType)`
`void`	`setAccessType_LessEqual(String accessType, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setAccessType_LessThan(String accessType)`
`void`	`setAccessType_LessThan(String accessType, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setAccessType_Match(String accessType)`
`void`	`setAccessType_Match(String accessType, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)`
`void`	`setAccessType_MatchPhrase(String accessType)`
`void`	`setAccessType_MatchPhrase(String accessType, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhraseQueryBuilder> opLambda)`
`void`	`setAccessType_MatchPhrasePrefix(String accessType)`
`void`	`setAccessType_MatchPhrasePrefix(String accessType, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhrasePrefixQueryBuilder> opLambda)`
`void`	`setAccessType_NotEqual(String accessType)`
`void`	`setAccessType_NotEqual(String accessType, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)`
`void`	`setAccessType_NotTerm(String accessType)`
`void`	`setAccessType_NotTerm(String accessType, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)`
`void`	`setAccessType_Prefix(String accessType)`
`void`	`setAccessType_Prefix(String accessType, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.PrefixQueryBuilder> opLambda)`
`void`	`setAccessType_Regexp(String accessType)`
`void`	`setAccessType_Regexp(String accessType, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RegexpQueryBuilder> opLambda)`
`void`	`setAccessType_SpanTerm(String accessType)`
`void`	`setAccessType_SpanTerm(String accessType, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.SpanTermQueryBuilder> opLambda)`
`void`	`setAccessType_Term(String accessType)`
`void`	`setAccessType_Term(String accessType, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)`
`void`	`setAccessType_Terms(Collection<String> accessTypeList)`
`void`	`setAccessType_Terms(Collection<String> accessTypeList, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)`
`void`	`setAccessType_Wildcard(String accessType)`
`void`	`setAccessType_Wildcard(String accessType, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.WildcardQueryBuilder> opLambda)`
`void`	`setClientIp_CommonTerms(String clientIp)`
`void`	`setClientIp_CommonTerms(String clientIp, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.CommonTermsQueryBuilder> opLambda)`
`void`	`setClientIp_Equal(String clientIp)`
`void`	`setClientIp_Equal(String clientIp, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)`
`void`	`setClientIp_Exists()`
`void`	`setClientIp_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.ExistsQueryBuilder> opLambda)`
`void`	`setClientIp_Fuzzy(String clientIp)`
`void`	`setClientIp_Fuzzy(String clientIp, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)`
`void`	`setClientIp_GreaterEqual(String clientIp)`
`void`	`setClientIp_GreaterEqual(String clientIp, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setClientIp_GreaterThan(String clientIp)`
`void`	`setClientIp_GreaterThan(String clientIp, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setClientIp_InScope(Collection<String> clientIpList)`
`void`	`setClientIp_InScope(Collection<String> clientIpList, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)`
`void`	`setClientIp_LessEqual(String clientIp)`
`void`	`setClientIp_LessEqual(String clientIp, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setClientIp_LessThan(String clientIp)`
`void`	`setClientIp_LessThan(String clientIp, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setClientIp_Match(String clientIp)`
`void`	`setClientIp_Match(String clientIp, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)`
`void`	`setClientIp_MatchPhrase(String clientIp)`
`void`	`setClientIp_MatchPhrase(String clientIp, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhraseQueryBuilder> opLambda)`
`void`	`setClientIp_MatchPhrasePrefix(String clientIp)`
`void`	`setClientIp_MatchPhrasePrefix(String clientIp, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhrasePrefixQueryBuilder> opLambda)`
`void`	`setClientIp_NotEqual(String clientIp)`
`void`	`setClientIp_NotEqual(String clientIp, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)`
`void`	`setClientIp_NotTerm(String clientIp)`
`void`	`setClientIp_NotTerm(String clientIp, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)`
`void`	`setClientIp_Prefix(String clientIp)`
`void`	`setClientIp_Prefix(String clientIp, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.PrefixQueryBuilder> opLambda)`
`void`	`setClientIp_Regexp(String clientIp)`
`void`	`setClientIp_Regexp(String clientIp, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RegexpQueryBuilder> opLambda)`
`void`	`setClientIp_SpanTerm(String clientIp)`
`void`	`setClientIp_SpanTerm(String clientIp, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.SpanTermQueryBuilder> opLambda)`
`void`	`setClientIp_Term(String clientIp)`
`void`	`setClientIp_Term(String clientIp, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)`
`void`	`setClientIp_Terms(Collection<String> clientIpList)`
`void`	`setClientIp_Terms(Collection<String> clientIpList, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)`
`void`	`setClientIp_Wildcard(String clientIp)`
`void`	`setClientIp_Wildcard(String clientIp, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.WildcardQueryBuilder> opLambda)`
`void`	`setHitCount_CommonTerms(Long hitCount)`
`void`	`setHitCount_CommonTerms(Long hitCount, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.CommonTermsQueryBuilder> opLambda)`
`void`	`setHitCount_Equal(Long hitCount)`
`void`	`setHitCount_Equal(Long hitCount, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)`
`void`	`setHitCount_Exists()`
`void`	`setHitCount_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.ExistsQueryBuilder> opLambda)`
`void`	`setHitCount_Fuzzy(Long hitCount)`
`void`	`setHitCount_Fuzzy(Long hitCount, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)`
`void`	`setHitCount_GreaterEqual(Long hitCount)`
`void`	`setHitCount_GreaterEqual(Long hitCount, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setHitCount_GreaterThan(Long hitCount)`
`void`	`setHitCount_GreaterThan(Long hitCount, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setHitCount_InScope(Collection<Long> hitCountList)`
`void`	`setHitCount_InScope(Collection<Long> hitCountList, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)`
`void`	`setHitCount_LessEqual(Long hitCount)`
`void`	`setHitCount_LessEqual(Long hitCount, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setHitCount_LessThan(Long hitCount)`
`void`	`setHitCount_LessThan(Long hitCount, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setHitCount_Match(Long hitCount)`
`void`	`setHitCount_Match(Long hitCount, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)`
`void`	`setHitCount_MatchPhrase(Long hitCount)`
`void`	`setHitCount_MatchPhrase(Long hitCount, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhraseQueryBuilder> opLambda)`
`void`	`setHitCount_MatchPhrasePrefix(Long hitCount)`
`void`	`setHitCount_MatchPhrasePrefix(Long hitCount, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhrasePrefixQueryBuilder> opLambda)`
`void`	`setHitCount_NotEqual(Long hitCount)`
`void`	`setHitCount_NotEqual(Long hitCount, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)`
`void`	`setHitCount_NotTerm(Long hitCount)`
`void`	`setHitCount_NotTerm(Long hitCount, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)`
`void`	`setHitCount_Term(Long hitCount)`
`void`	`setHitCount_Term(Long hitCount, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)`
`void`	`setHitCount_Terms(Collection<Long> hitCountList)`
`void`	`setHitCount_Terms(Collection<Long> hitCountList, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)`
`void`	`setId_Equal(String id)`
`void`	`setId_Equal(String id, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)`
`void`	`setId_InScope(Collection<String> idList)`
`void`	`setId_InScope(Collection<String> idList, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.IdsQueryBuilder> opLambda)`
`void`	`setId_NotEqual(String id)`
`void`	`setId_NotEqual(String id, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)`
`void`	`setId_NotTerm(String id)`
`void`	`setId_NotTerm(String id, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)`
`void`	`setId_Term(String id)`
`void`	`setId_Term(String id, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)`
`void`	`setId_Terms(Collection<String> idList)`
`void`	`setId_Terms(Collection<String> idList, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.IdsQueryBuilder> opLambda)`
`void`	`setLanguages_CommonTerms(String languages)`
`void`	`setLanguages_CommonTerms(String languages, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.CommonTermsQueryBuilder> opLambda)`
`void`	`setLanguages_Equal(String languages)`
`void`	`setLanguages_Equal(String languages, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)`
`void`	`setLanguages_Exists()`
`void`	`setLanguages_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.ExistsQueryBuilder> opLambda)`
`void`	`setLanguages_Fuzzy(String languages)`
`void`	`setLanguages_Fuzzy(String languages, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)`
`void`	`setLanguages_GreaterEqual(String languages)`
`void`	`setLanguages_GreaterEqual(String languages, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setLanguages_GreaterThan(String languages)`
`void`	`setLanguages_GreaterThan(String languages, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setLanguages_InScope(Collection<String> languagesList)`
`void`	`setLanguages_InScope(Collection<String> languagesList, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)`
`void`	`setLanguages_LessEqual(String languages)`
`void`	`setLanguages_LessEqual(String languages, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setLanguages_LessThan(String languages)`
`void`	`setLanguages_LessThan(String languages, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setLanguages_Match(String languages)`
`void`	`setLanguages_Match(String languages, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)`
`void`	`setLanguages_MatchPhrase(String languages)`
`void`	`setLanguages_MatchPhrase(String languages, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhraseQueryBuilder> opLambda)`
`void`	`setLanguages_MatchPhrasePrefix(String languages)`
`void`	`setLanguages_MatchPhrasePrefix(String languages, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhrasePrefixQueryBuilder> opLambda)`
`void`	`setLanguages_NotEqual(String languages)`
`void`	`setLanguages_NotEqual(String languages, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)`
`void`	`setLanguages_NotTerm(String languages)`
`void`	`setLanguages_NotTerm(String languages, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)`
`void`	`setLanguages_Prefix(String languages)`
`void`	`setLanguages_Prefix(String languages, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.PrefixQueryBuilder> opLambda)`
`void`	`setLanguages_Regexp(String languages)`
`void`	`setLanguages_Regexp(String languages, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RegexpQueryBuilder> opLambda)`
`void`	`setLanguages_SpanTerm(String languages)`
`void`	`setLanguages_SpanTerm(String languages, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.SpanTermQueryBuilder> opLambda)`
`void`	`setLanguages_Term(String languages)`
`void`	`setLanguages_Term(String languages, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)`
`void`	`setLanguages_Terms(Collection<String> languagesList)`
`void`	`setLanguages_Terms(Collection<String> languagesList, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)`
`void`	`setLanguages_Wildcard(String languages)`
`void`	`setLanguages_Wildcard(String languages, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.WildcardQueryBuilder> opLambda)`
`void`	`setQueryId_CommonTerms(String queryId)`
`void`	`setQueryId_CommonTerms(String queryId, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.CommonTermsQueryBuilder> opLambda)`
`void`	`setQueryId_Equal(String queryId)`
`void`	`setQueryId_Equal(String queryId, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)`
`void`	`setQueryId_Exists()`
`void`	`setQueryId_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.ExistsQueryBuilder> opLambda)`
`void`	`setQueryId_Fuzzy(String queryId)`
`void`	`setQueryId_Fuzzy(String queryId, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)`
`void`	`setQueryId_GreaterEqual(String queryId)`
`void`	`setQueryId_GreaterEqual(String queryId, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setQueryId_GreaterThan(String queryId)`
`void`	`setQueryId_GreaterThan(String queryId, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setQueryId_InScope(Collection<String> queryIdList)`
`void`	`setQueryId_InScope(Collection<String> queryIdList, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)`
`void`	`setQueryId_LessEqual(String queryId)`
`void`	`setQueryId_LessEqual(String queryId, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setQueryId_LessThan(String queryId)`
`void`	`setQueryId_LessThan(String queryId, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setQueryId_Match(String queryId)`
`void`	`setQueryId_Match(String queryId, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)`
`void`	`setQueryId_MatchPhrase(String queryId)`
`void`	`setQueryId_MatchPhrase(String queryId, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhraseQueryBuilder> opLambda)`
`void`	`setQueryId_MatchPhrasePrefix(String queryId)`
`void`	`setQueryId_MatchPhrasePrefix(String queryId, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhrasePrefixQueryBuilder> opLambda)`
`void`	`setQueryId_NotEqual(String queryId)`
`void`	`setQueryId_NotEqual(String queryId, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)`
`void`	`setQueryId_NotTerm(String queryId)`
`void`	`setQueryId_NotTerm(String queryId, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)`
`void`	`setQueryId_Prefix(String queryId)`
`void`	`setQueryId_Prefix(String queryId, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.PrefixQueryBuilder> opLambda)`
`void`	`setQueryId_Regexp(String queryId)`
`void`	`setQueryId_Regexp(String queryId, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RegexpQueryBuilder> opLambda)`
`void`	`setQueryId_SpanTerm(String queryId)`
`void`	`setQueryId_SpanTerm(String queryId, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.SpanTermQueryBuilder> opLambda)`
`void`	`setQueryId_Term(String queryId)`
`void`	`setQueryId_Term(String queryId, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)`
`void`	`setQueryId_Terms(Collection<String> queryIdList)`
`void`	`setQueryId_Terms(Collection<String> queryIdList, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)`
`void`	`setQueryId_Wildcard(String queryId)`
`void`	`setQueryId_Wildcard(String queryId, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.WildcardQueryBuilder> opLambda)`
`void`	`setQueryOffset_CommonTerms(Integer queryOffset)`
`void`	`setQueryOffset_CommonTerms(Integer queryOffset, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.CommonTermsQueryBuilder> opLambda)`
`void`	`setQueryOffset_Equal(Integer queryOffset)`
`void`	`setQueryOffset_Equal(Integer queryOffset, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)`
`void`	`setQueryOffset_Exists()`
`void`	`setQueryOffset_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.ExistsQueryBuilder> opLambda)`
`void`	`setQueryOffset_Fuzzy(Integer queryOffset)`
`void`	`setQueryOffset_Fuzzy(Integer queryOffset, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)`
`void`	`setQueryOffset_GreaterEqual(Integer queryOffset)`
`void`	`setQueryOffset_GreaterEqual(Integer queryOffset, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setQueryOffset_GreaterThan(Integer queryOffset)`
`void`	`setQueryOffset_GreaterThan(Integer queryOffset, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setQueryOffset_InScope(Collection<Integer> queryOffsetList)`
`void`	`setQueryOffset_InScope(Collection<Integer> queryOffsetList, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)`
`void`	`setQueryOffset_LessEqual(Integer queryOffset)`
`void`	`setQueryOffset_LessEqual(Integer queryOffset, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setQueryOffset_LessThan(Integer queryOffset)`
`void`	`setQueryOffset_LessThan(Integer queryOffset, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setQueryOffset_Match(Integer queryOffset)`
`void`	`setQueryOffset_Match(Integer queryOffset, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)`
`void`	`setQueryOffset_MatchPhrase(Integer queryOffset)`
`void`	`setQueryOffset_MatchPhrase(Integer queryOffset, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhraseQueryBuilder> opLambda)`
`void`	`setQueryOffset_MatchPhrasePrefix(Integer queryOffset)`
`void`	`setQueryOffset_MatchPhrasePrefix(Integer queryOffset, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhrasePrefixQueryBuilder> opLambda)`
`void`	`setQueryOffset_NotEqual(Integer queryOffset)`
`void`	`setQueryOffset_NotEqual(Integer queryOffset, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)`
`void`	`setQueryOffset_NotTerm(Integer queryOffset)`
`void`	`setQueryOffset_NotTerm(Integer queryOffset, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)`
`void`	`setQueryOffset_Term(Integer queryOffset)`
`void`	`setQueryOffset_Term(Integer queryOffset, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)`
`void`	`setQueryOffset_Terms(Collection<Integer> queryOffsetList)`
`void`	`setQueryOffset_Terms(Collection<Integer> queryOffsetList, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)`
`void`	`setQueryPageSize_CommonTerms(Integer queryPageSize)`
`void`	`setQueryPageSize_CommonTerms(Integer queryPageSize, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.CommonTermsQueryBuilder> opLambda)`
`void`	`setQueryPageSize_Equal(Integer queryPageSize)`
`void`	`setQueryPageSize_Equal(Integer queryPageSize, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)`
`void`	`setQueryPageSize_Exists()`
`void`	`setQueryPageSize_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.ExistsQueryBuilder> opLambda)`
`void`	`setQueryPageSize_Fuzzy(Integer queryPageSize)`
`void`	`setQueryPageSize_Fuzzy(Integer queryPageSize, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)`
`void`	`setQueryPageSize_GreaterEqual(Integer queryPageSize)`
`void`	`setQueryPageSize_GreaterEqual(Integer queryPageSize, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setQueryPageSize_GreaterThan(Integer queryPageSize)`
`void`	`setQueryPageSize_GreaterThan(Integer queryPageSize, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setQueryPageSize_InScope(Collection<Integer> queryPageSizeList)`
`void`	`setQueryPageSize_InScope(Collection<Integer> queryPageSizeList, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)`
`void`	`setQueryPageSize_LessEqual(Integer queryPageSize)`
`void`	`setQueryPageSize_LessEqual(Integer queryPageSize, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setQueryPageSize_LessThan(Integer queryPageSize)`
`void`	`setQueryPageSize_LessThan(Integer queryPageSize, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setQueryPageSize_Match(Integer queryPageSize)`
`void`	`setQueryPageSize_Match(Integer queryPageSize, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)`
`void`	`setQueryPageSize_MatchPhrase(Integer queryPageSize)`
`void`	`setQueryPageSize_MatchPhrase(Integer queryPageSize, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhraseQueryBuilder> opLambda)`
`void`	`setQueryPageSize_MatchPhrasePrefix(Integer queryPageSize)`
`void`	`setQueryPageSize_MatchPhrasePrefix(Integer queryPageSize, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhrasePrefixQueryBuilder> opLambda)`
`void`	`setQueryPageSize_NotEqual(Integer queryPageSize)`
`void`	`setQueryPageSize_NotEqual(Integer queryPageSize, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)`
`void`	`setQueryPageSize_NotTerm(Integer queryPageSize)`
`void`	`setQueryPageSize_NotTerm(Integer queryPageSize, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)`
`void`	`setQueryPageSize_Term(Integer queryPageSize)`
`void`	`setQueryPageSize_Term(Integer queryPageSize, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)`
`void`	`setQueryPageSize_Terms(Collection<Integer> queryPageSizeList)`
`void`	`setQueryPageSize_Terms(Collection<Integer> queryPageSizeList, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)`
`void`	`setQueryTime_CommonTerms(Long queryTime)`
`void`	`setQueryTime_CommonTerms(Long queryTime, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.CommonTermsQueryBuilder> opLambda)`
`void`	`setQueryTime_Equal(Long queryTime)`
`void`	`setQueryTime_Equal(Long queryTime, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)`
`void`	`setQueryTime_Exists()`
`void`	`setQueryTime_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.ExistsQueryBuilder> opLambda)`
`void`	`setQueryTime_Fuzzy(Long queryTime)`
`void`	`setQueryTime_Fuzzy(Long queryTime, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)`
`void`	`setQueryTime_GreaterEqual(Long queryTime)`
`void`	`setQueryTime_GreaterEqual(Long queryTime, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setQueryTime_GreaterThan(Long queryTime)`
`void`	`setQueryTime_GreaterThan(Long queryTime, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setQueryTime_InScope(Collection<Long> queryTimeList)`
`void`	`setQueryTime_InScope(Collection<Long> queryTimeList, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)`
`void`	`setQueryTime_LessEqual(Long queryTime)`
`void`	`setQueryTime_LessEqual(Long queryTime, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setQueryTime_LessThan(Long queryTime)`
`void`	`setQueryTime_LessThan(Long queryTime, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setQueryTime_Match(Long queryTime)`
`void`	`setQueryTime_Match(Long queryTime, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)`
`void`	`setQueryTime_MatchPhrase(Long queryTime)`
`void`	`setQueryTime_MatchPhrase(Long queryTime, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhraseQueryBuilder> opLambda)`
`void`	`setQueryTime_MatchPhrasePrefix(Long queryTime)`
`void`	`setQueryTime_MatchPhrasePrefix(Long queryTime, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhrasePrefixQueryBuilder> opLambda)`
`void`	`setQueryTime_NotEqual(Long queryTime)`
`void`	`setQueryTime_NotEqual(Long queryTime, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)`
`void`	`setQueryTime_NotTerm(Long queryTime)`
`void`	`setQueryTime_NotTerm(Long queryTime, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)`
`void`	`setQueryTime_Term(Long queryTime)`
`void`	`setQueryTime_Term(Long queryTime, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)`
`void`	`setQueryTime_Terms(Collection<Long> queryTimeList)`
`void`	`setQueryTime_Terms(Collection<Long> queryTimeList, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)`
`void`	`setReferer_CommonTerms(String referer)`
`void`	`setReferer_CommonTerms(String referer, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.CommonTermsQueryBuilder> opLambda)`
`void`	`setReferer_Equal(String referer)`
`void`	`setReferer_Equal(String referer, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)`
`void`	`setReferer_Exists()`
`void`	`setReferer_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.ExistsQueryBuilder> opLambda)`
`void`	`setReferer_Fuzzy(String referer)`
`void`	`setReferer_Fuzzy(String referer, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)`
`void`	`setReferer_GreaterEqual(String referer)`
`void`	`setReferer_GreaterEqual(String referer, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setReferer_GreaterThan(String referer)`
`void`	`setReferer_GreaterThan(String referer, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setReferer_InScope(Collection<String> refererList)`
`void`	`setReferer_InScope(Collection<String> refererList, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)`
`void`	`setReferer_LessEqual(String referer)`
`void`	`setReferer_LessEqual(String referer, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setReferer_LessThan(String referer)`
`void`	`setReferer_LessThan(String referer, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setReferer_Match(String referer)`
`void`	`setReferer_Match(String referer, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)`
`void`	`setReferer_MatchPhrase(String referer)`
`void`	`setReferer_MatchPhrase(String referer, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhraseQueryBuilder> opLambda)`
`void`	`setReferer_MatchPhrasePrefix(String referer)`
`void`	`setReferer_MatchPhrasePrefix(String referer, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhrasePrefixQueryBuilder> opLambda)`
`void`	`setReferer_NotEqual(String referer)`
`void`	`setReferer_NotEqual(String referer, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)`
`void`	`setReferer_NotTerm(String referer)`
`void`	`setReferer_NotTerm(String referer, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)`
`void`	`setReferer_Prefix(String referer)`
`void`	`setReferer_Prefix(String referer, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.PrefixQueryBuilder> opLambda)`
`void`	`setReferer_Regexp(String referer)`
`void`	`setReferer_Regexp(String referer, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RegexpQueryBuilder> opLambda)`
`void`	`setReferer_SpanTerm(String referer)`
`void`	`setReferer_SpanTerm(String referer, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.SpanTermQueryBuilder> opLambda)`
`void`	`setReferer_Term(String referer)`
`void`	`setReferer_Term(String referer, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)`
`void`	`setReferer_Terms(Collection<String> refererList)`
`void`	`setReferer_Terms(Collection<String> refererList, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)`
`void`	`setReferer_Wildcard(String referer)`
`void`	`setReferer_Wildcard(String referer, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.WildcardQueryBuilder> opLambda)`
`void`	`setRequestedAt_CommonTerms(LocalDateTime requestedAt)`
`void`	`setRequestedAt_CommonTerms(LocalDateTime requestedAt, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.CommonTermsQueryBuilder> opLambda)`
`void`	`setRequestedAt_Equal(LocalDateTime requestedAt)`
`void`	`setRequestedAt_Equal(LocalDateTime requestedAt, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)`
`void`	`setRequestedAt_Exists()`
`void`	`setRequestedAt_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.ExistsQueryBuilder> opLambda)`
`void`	`setRequestedAt_Fuzzy(LocalDateTime requestedAt)`
`void`	`setRequestedAt_Fuzzy(LocalDateTime requestedAt, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)`
`void`	`setRequestedAt_GreaterEqual(LocalDateTime requestedAt)`
`void`	`setRequestedAt_GreaterEqual(LocalDateTime requestedAt, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setRequestedAt_GreaterThan(LocalDateTime requestedAt)`
`void`	`setRequestedAt_GreaterThan(LocalDateTime requestedAt, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setRequestedAt_InScope(Collection<LocalDateTime> requestedAtList)`
`void`	`setRequestedAt_InScope(Collection<LocalDateTime> requestedAtList, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)`
`void`	`setRequestedAt_LessEqual(LocalDateTime requestedAt)`
`void`	`setRequestedAt_LessEqual(LocalDateTime requestedAt, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setRequestedAt_LessThan(LocalDateTime requestedAt)`
`void`	`setRequestedAt_LessThan(LocalDateTime requestedAt, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setRequestedAt_Match(LocalDateTime requestedAt)`
`void`	`setRequestedAt_Match(LocalDateTime requestedAt, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)`
`void`	`setRequestedAt_MatchPhrase(LocalDateTime requestedAt)`
`void`	`setRequestedAt_MatchPhrase(LocalDateTime requestedAt, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhraseQueryBuilder> opLambda)`
`void`	`setRequestedAt_MatchPhrasePrefix(LocalDateTime requestedAt)`
`void`	`setRequestedAt_MatchPhrasePrefix(LocalDateTime requestedAt, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhrasePrefixQueryBuilder> opLambda)`
`void`	`setRequestedAt_NotEqual(LocalDateTime requestedAt)`
`void`	`setRequestedAt_NotEqual(LocalDateTime requestedAt, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)`
`void`	`setRequestedAt_NotTerm(LocalDateTime requestedAt)`
`void`	`setRequestedAt_NotTerm(LocalDateTime requestedAt, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)`
`void`	`setRequestedAt_Term(LocalDateTime requestedAt)`
`void`	`setRequestedAt_Term(LocalDateTime requestedAt, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)`
`void`	`setRequestedAt_Terms(Collection<LocalDateTime> requestedAtList)`
`void`	`setRequestedAt_Terms(Collection<LocalDateTime> requestedAtList, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)`
`void`	`setResponseTime_CommonTerms(Long responseTime)`
`void`	`setResponseTime_CommonTerms(Long responseTime, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.CommonTermsQueryBuilder> opLambda)`
`void`	`setResponseTime_Equal(Long responseTime)`
`void`	`setResponseTime_Equal(Long responseTime, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)`
`void`	`setResponseTime_Exists()`
`void`	`setResponseTime_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.ExistsQueryBuilder> opLambda)`
`void`	`setResponseTime_Fuzzy(Long responseTime)`
`void`	`setResponseTime_Fuzzy(Long responseTime, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)`
`void`	`setResponseTime_GreaterEqual(Long responseTime)`
`void`	`setResponseTime_GreaterEqual(Long responseTime, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setResponseTime_GreaterThan(Long responseTime)`
`void`	`setResponseTime_GreaterThan(Long responseTime, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setResponseTime_InScope(Collection<Long> responseTimeList)`
`void`	`setResponseTime_InScope(Collection<Long> responseTimeList, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)`
`void`	`setResponseTime_LessEqual(Long responseTime)`
`void`	`setResponseTime_LessEqual(Long responseTime, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setResponseTime_LessThan(Long responseTime)`
`void`	`setResponseTime_LessThan(Long responseTime, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setResponseTime_Match(Long responseTime)`
`void`	`setResponseTime_Match(Long responseTime, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)`
`void`	`setResponseTime_MatchPhrase(Long responseTime)`
`void`	`setResponseTime_MatchPhrase(Long responseTime, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhraseQueryBuilder> opLambda)`
`void`	`setResponseTime_MatchPhrasePrefix(Long responseTime)`
`void`	`setResponseTime_MatchPhrasePrefix(Long responseTime, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhrasePrefixQueryBuilder> opLambda)`
`void`	`setResponseTime_NotEqual(Long responseTime)`
`void`	`setResponseTime_NotEqual(Long responseTime, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)`
`void`	`setResponseTime_NotTerm(Long responseTime)`
`void`	`setResponseTime_NotTerm(Long responseTime, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)`
`void`	`setResponseTime_Term(Long responseTime)`
`void`	`setResponseTime_Term(Long responseTime, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)`
`void`	`setResponseTime_Terms(Collection<Long> responseTimeList)`
`void`	`setResponseTime_Terms(Collection<Long> responseTimeList, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)`
`void`	`setRoles_CommonTerms(String roles)`
`void`	`setRoles_CommonTerms(String roles, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.CommonTermsQueryBuilder> opLambda)`
`void`	`setRoles_Equal(String roles)`
`void`	`setRoles_Equal(String roles, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)`
`void`	`setRoles_Exists()`
`void`	`setRoles_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.ExistsQueryBuilder> opLambda)`
`void`	`setRoles_Fuzzy(String roles)`
`void`	`setRoles_Fuzzy(String roles, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)`
`void`	`setRoles_GreaterEqual(String roles)`
`void`	`setRoles_GreaterEqual(String roles, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setRoles_GreaterThan(String roles)`
`void`	`setRoles_GreaterThan(String roles, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setRoles_InScope(Collection<String> rolesList)`
`void`	`setRoles_InScope(Collection<String> rolesList, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)`
`void`	`setRoles_LessEqual(String roles)`
`void`	`setRoles_LessEqual(String roles, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setRoles_LessThan(String roles)`
`void`	`setRoles_LessThan(String roles, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setRoles_Match(String roles)`
`void`	`setRoles_Match(String roles, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)`
`void`	`setRoles_MatchPhrase(String roles)`
`void`	`setRoles_MatchPhrase(String roles, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhraseQueryBuilder> opLambda)`
`void`	`setRoles_MatchPhrasePrefix(String roles)`
`void`	`setRoles_MatchPhrasePrefix(String roles, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhrasePrefixQueryBuilder> opLambda)`
`void`	`setRoles_NotEqual(String roles)`
`void`	`setRoles_NotEqual(String roles, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)`
`void`	`setRoles_NotTerm(String roles)`
`void`	`setRoles_NotTerm(String roles, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)`
`void`	`setRoles_Prefix(String roles)`
`void`	`setRoles_Prefix(String roles, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.PrefixQueryBuilder> opLambda)`
`void`	`setRoles_Regexp(String roles)`
`void`	`setRoles_Regexp(String roles, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RegexpQueryBuilder> opLambda)`
`void`	`setRoles_SpanTerm(String roles)`
`void`	`setRoles_SpanTerm(String roles, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.SpanTermQueryBuilder> opLambda)`
`void`	`setRoles_Term(String roles)`
`void`	`setRoles_Term(String roles, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)`
`void`	`setRoles_Terms(Collection<String> rolesList)`
`void`	`setRoles_Terms(Collection<String> rolesList, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)`
`void`	`setRoles_Wildcard(String roles)`
`void`	`setRoles_Wildcard(String roles, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.WildcardQueryBuilder> opLambda)`
`void`	`setSearchWord_CommonTerms(String searchWord)`
`void`	`setSearchWord_CommonTerms(String searchWord, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.CommonTermsQueryBuilder> opLambda)`
`void`	`setSearchWord_Equal(String searchWord)`
`void`	`setSearchWord_Equal(String searchWord, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)`
`void`	`setSearchWord_Exists()`
`void`	`setSearchWord_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.ExistsQueryBuilder> opLambda)`
`void`	`setSearchWord_Fuzzy(String searchWord)`
`void`	`setSearchWord_Fuzzy(String searchWord, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)`
`void`	`setSearchWord_GreaterEqual(String searchWord)`
`void`	`setSearchWord_GreaterEqual(String searchWord, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setSearchWord_GreaterThan(String searchWord)`
`void`	`setSearchWord_GreaterThan(String searchWord, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setSearchWord_InScope(Collection<String> searchWordList)`
`void`	`setSearchWord_InScope(Collection<String> searchWordList, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)`
`void`	`setSearchWord_LessEqual(String searchWord)`
`void`	`setSearchWord_LessEqual(String searchWord, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setSearchWord_LessThan(String searchWord)`
`void`	`setSearchWord_LessThan(String searchWord, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setSearchWord_Match(String searchWord)`
`void`	`setSearchWord_Match(String searchWord, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)`
`void`	`setSearchWord_MatchPhrase(String searchWord)`
`void`	`setSearchWord_MatchPhrase(String searchWord, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhraseQueryBuilder> opLambda)`
`void`	`setSearchWord_MatchPhrasePrefix(String searchWord)`
`void`	`setSearchWord_MatchPhrasePrefix(String searchWord, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhrasePrefixQueryBuilder> opLambda)`
`void`	`setSearchWord_NotEqual(String searchWord)`
`void`	`setSearchWord_NotEqual(String searchWord, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)`
`void`	`setSearchWord_NotTerm(String searchWord)`
`void`	`setSearchWord_NotTerm(String searchWord, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)`
`void`	`setSearchWord_Prefix(String searchWord)`
`void`	`setSearchWord_Prefix(String searchWord, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.PrefixQueryBuilder> opLambda)`
`void`	`setSearchWord_Regexp(String searchWord)`
`void`	`setSearchWord_Regexp(String searchWord, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RegexpQueryBuilder> opLambda)`
`void`	`setSearchWord_SpanTerm(String searchWord)`
`void`	`setSearchWord_SpanTerm(String searchWord, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.SpanTermQueryBuilder> opLambda)`
`void`	`setSearchWord_Term(String searchWord)`
`void`	`setSearchWord_Term(String searchWord, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)`
`void`	`setSearchWord_Terms(Collection<String> searchWordList)`
`void`	`setSearchWord_Terms(Collection<String> searchWordList, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)`
`void`	`setSearchWord_Wildcard(String searchWord)`
`void`	`setSearchWord_Wildcard(String searchWord, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.WildcardQueryBuilder> opLambda)`
`void`	`setUser_CommonTerms(String user)`
`void`	`setUser_CommonTerms(String user, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.CommonTermsQueryBuilder> opLambda)`
`void`	`setUser_Equal(String user)`
`void`	`setUser_Equal(String user, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)`
`void`	`setUser_Exists()`
`void`	`setUser_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.ExistsQueryBuilder> opLambda)`
`void`	`setUser_Fuzzy(String user)`
`void`	`setUser_Fuzzy(String user, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)`
`void`	`setUser_GreaterEqual(String user)`
`void`	`setUser_GreaterEqual(String user, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setUser_GreaterThan(String user)`
`void`	`setUser_GreaterThan(String user, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setUser_InScope(Collection<String> userList)`
`void`	`setUser_InScope(Collection<String> userList, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)`
`void`	`setUser_LessEqual(String user)`
`void`	`setUser_LessEqual(String user, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setUser_LessThan(String user)`
`void`	`setUser_LessThan(String user, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setUser_Match(String user)`
`void`	`setUser_Match(String user, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)`
`void`	`setUser_MatchPhrase(String user)`
`void`	`setUser_MatchPhrase(String user, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhraseQueryBuilder> opLambda)`
`void`	`setUser_MatchPhrasePrefix(String user)`
`void`	`setUser_MatchPhrasePrefix(String user, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhrasePrefixQueryBuilder> opLambda)`
`void`	`setUser_NotEqual(String user)`
`void`	`setUser_NotEqual(String user, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)`
`void`	`setUser_NotTerm(String user)`
`void`	`setUser_NotTerm(String user, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)`
`void`	`setUser_Prefix(String user)`
`void`	`setUser_Prefix(String user, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.PrefixQueryBuilder> opLambda)`
`void`	`setUser_Regexp(String user)`
`void`	`setUser_Regexp(String user, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RegexpQueryBuilder> opLambda)`
`void`	`setUser_SpanTerm(String user)`
`void`	`setUser_SpanTerm(String user, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.SpanTermQueryBuilder> opLambda)`
`void`	`setUser_Term(String user)`
`void`	`setUser_Term(String user, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)`
`void`	`setUser_Terms(Collection<String> userList)`
`void`	`setUser_Terms(Collection<String> userList, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)`
`void`	`setUser_Wildcard(String user)`
`void`	`setUser_Wildcard(String user, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.WildcardQueryBuilder> opLambda)`
`void`	`setUserAgent_CommonTerms(String userAgent)`
`void`	`setUserAgent_CommonTerms(String userAgent, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.CommonTermsQueryBuilder> opLambda)`
`void`	`setUserAgent_Equal(String userAgent)`
`void`	`setUserAgent_Equal(String userAgent, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)`
`void`	`setUserAgent_Exists()`
`void`	`setUserAgent_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.ExistsQueryBuilder> opLambda)`
`void`	`setUserAgent_Fuzzy(String userAgent)`
`void`	`setUserAgent_Fuzzy(String userAgent, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)`
`void`	`setUserAgent_GreaterEqual(String userAgent)`
`void`	`setUserAgent_GreaterEqual(String userAgent, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setUserAgent_GreaterThan(String userAgent)`
`void`	`setUserAgent_GreaterThan(String userAgent, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setUserAgent_InScope(Collection<String> userAgentList)`
`void`	`setUserAgent_InScope(Collection<String> userAgentList, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)`
`void`	`setUserAgent_LessEqual(String userAgent)`
`void`	`setUserAgent_LessEqual(String userAgent, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setUserAgent_LessThan(String userAgent)`
`void`	`setUserAgent_LessThan(String userAgent, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setUserAgent_Match(String userAgent)`
`void`	`setUserAgent_Match(String userAgent, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)`
`void`	`setUserAgent_MatchPhrase(String userAgent)`
`void`	`setUserAgent_MatchPhrase(String userAgent, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhraseQueryBuilder> opLambda)`
`void`	`setUserAgent_MatchPhrasePrefix(String userAgent)`
`void`	`setUserAgent_MatchPhrasePrefix(String userAgent, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhrasePrefixQueryBuilder> opLambda)`
`void`	`setUserAgent_NotEqual(String userAgent)`
`void`	`setUserAgent_NotEqual(String userAgent, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)`
`void`	`setUserAgent_NotTerm(String userAgent)`
`void`	`setUserAgent_NotTerm(String userAgent, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)`
`void`	`setUserAgent_Prefix(String userAgent)`
`void`	`setUserAgent_Prefix(String userAgent, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.PrefixQueryBuilder> opLambda)`
`void`	`setUserAgent_Regexp(String userAgent)`
`void`	`setUserAgent_Regexp(String userAgent, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RegexpQueryBuilder> opLambda)`
`void`	`setUserAgent_SpanTerm(String userAgent)`
`void`	`setUserAgent_SpanTerm(String userAgent, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.SpanTermQueryBuilder> opLambda)`
`void`	`setUserAgent_Term(String userAgent)`
`void`	`setUserAgent_Term(String userAgent, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)`
`void`	`setUserAgent_Terms(Collection<String> userAgentList)`
`void`	`setUserAgent_Terms(Collection<String> userAgentList, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)`
`void`	`setUserAgent_Wildcard(String userAgent)`
`void`	`setUserAgent_Wildcard(String userAgent, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.WildcardQueryBuilder> opLambda)`
`void`	`setUserInfoId_CommonTerms(String userInfoId)`
`void`	`setUserInfoId_CommonTerms(String userInfoId, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.CommonTermsQueryBuilder> opLambda)`
`void`	`setUserInfoId_Equal(String userInfoId)`
`void`	`setUserInfoId_Equal(String userInfoId, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)`
`void`	`setUserInfoId_Exists()`
`void`	`setUserInfoId_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.ExistsQueryBuilder> opLambda)`
`void`	`setUserInfoId_Fuzzy(String userInfoId)`
`void`	`setUserInfoId_Fuzzy(String userInfoId, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)`
`void`	`setUserInfoId_GreaterEqual(String userInfoId)`
`void`	`setUserInfoId_GreaterEqual(String userInfoId, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setUserInfoId_GreaterThan(String userInfoId)`
`void`	`setUserInfoId_GreaterThan(String userInfoId, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setUserInfoId_InScope(Collection<String> userInfoIdList)`
`void`	`setUserInfoId_InScope(Collection<String> userInfoIdList, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)`
`void`	`setUserInfoId_LessEqual(String userInfoId)`
`void`	`setUserInfoId_LessEqual(String userInfoId, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setUserInfoId_LessThan(String userInfoId)`
`void`	`setUserInfoId_LessThan(String userInfoId, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setUserInfoId_Match(String userInfoId)`
`void`	`setUserInfoId_Match(String userInfoId, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)`
`void`	`setUserInfoId_MatchPhrase(String userInfoId)`
`void`	`setUserInfoId_MatchPhrase(String userInfoId, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhraseQueryBuilder> opLambda)`
`void`	`setUserInfoId_MatchPhrasePrefix(String userInfoId)`
`void`	`setUserInfoId_MatchPhrasePrefix(String userInfoId, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhrasePrefixQueryBuilder> opLambda)`
`void`	`setUserInfoId_NotEqual(String userInfoId)`
`void`	`setUserInfoId_NotEqual(String userInfoId, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)`
`void`	`setUserInfoId_NotTerm(String userInfoId)`
`void`	`setUserInfoId_NotTerm(String userInfoId, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)`
`void`	`setUserInfoId_Prefix(String userInfoId)`
`void`	`setUserInfoId_Prefix(String userInfoId, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.PrefixQueryBuilder> opLambda)`
`void`	`setUserInfoId_Regexp(String userInfoId)`
`void`	`setUserInfoId_Regexp(String userInfoId, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RegexpQueryBuilder> opLambda)`
`void`	`setUserInfoId_SpanTerm(String userInfoId)`
`void`	`setUserInfoId_SpanTerm(String userInfoId, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.SpanTermQueryBuilder> opLambda)`
`void`	`setUserInfoId_Term(String userInfoId)`
`void`	`setUserInfoId_Term(String userInfoId, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)`
`void`	`setUserInfoId_Terms(Collection<String> userInfoIdList)`
`void`	`setUserInfoId_Terms(Collection<String> userInfoIdList, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)`
`void`	`setUserInfoId_Wildcard(String userInfoId)`
`void`	`setUserInfoId_Wildcard(String userInfoId, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.WildcardQueryBuilder> opLambda)`
`void`	`setUserSessionId_CommonTerms(String userSessionId)`
`void`	`setUserSessionId_CommonTerms(String userSessionId, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.CommonTermsQueryBuilder> opLambda)`
`void`	`setUserSessionId_Equal(String userSessionId)`
`void`	`setUserSessionId_Equal(String userSessionId, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)`
`void`	`setUserSessionId_Exists()`
`void`	`setUserSessionId_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.ExistsQueryBuilder> opLambda)`
`void`	`setUserSessionId_Fuzzy(String userSessionId)`
`void`	`setUserSessionId_Fuzzy(String userSessionId, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)`
`void`	`setUserSessionId_GreaterEqual(String userSessionId)`
`void`	`setUserSessionId_GreaterEqual(String userSessionId, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setUserSessionId_GreaterThan(String userSessionId)`
`void`	`setUserSessionId_GreaterThan(String userSessionId, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setUserSessionId_InScope(Collection<String> userSessionIdList)`
`void`	`setUserSessionId_InScope(Collection<String> userSessionIdList, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)`
`void`	`setUserSessionId_LessEqual(String userSessionId)`
`void`	`setUserSessionId_LessEqual(String userSessionId, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setUserSessionId_LessThan(String userSessionId)`
`void`	`setUserSessionId_LessThan(String userSessionId, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setUserSessionId_Match(String userSessionId)`
`void`	`setUserSessionId_Match(String userSessionId, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)`
`void`	`setUserSessionId_MatchPhrase(String userSessionId)`
`void`	`setUserSessionId_MatchPhrase(String userSessionId, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhraseQueryBuilder> opLambda)`
`void`	`setUserSessionId_MatchPhrasePrefix(String userSessionId)`
`void`	`setUserSessionId_MatchPhrasePrefix(String userSessionId, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhrasePrefixQueryBuilder> opLambda)`
`void`	`setUserSessionId_NotEqual(String userSessionId)`
`void`	`setUserSessionId_NotEqual(String userSessionId, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)`
`void`	`setUserSessionId_NotTerm(String userSessionId)`
`void`	`setUserSessionId_NotTerm(String userSessionId, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)`
`void`	`setUserSessionId_Prefix(String userSessionId)`
`void`	`setUserSessionId_Prefix(String userSessionId, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.PrefixQueryBuilder> opLambda)`
`void`	`setUserSessionId_Regexp(String userSessionId)`
`void`	`setUserSessionId_Regexp(String userSessionId, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RegexpQueryBuilder> opLambda)`
`void`	`setUserSessionId_SpanTerm(String userSessionId)`
`void`	`setUserSessionId_SpanTerm(String userSessionId, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.SpanTermQueryBuilder> opLambda)`
`void`	`setUserSessionId_Term(String userSessionId)`
`void`	`setUserSessionId_Term(String userSessionId, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)`
`void`	`setUserSessionId_Terms(Collection<String> userSessionIdList)`
`void`	`setUserSessionId_Terms(Collection<String> userSessionIdList, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)`
`void`	`setUserSessionId_Wildcard(String userSessionId)`
`void`	`setUserSessionId_Wildcard(String userSessionId, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.WildcardQueryBuilder> opLambda)`
`void`	`setVirtualHost_CommonTerms(String virtualHost)`
`void`	`setVirtualHost_CommonTerms(String virtualHost, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.CommonTermsQueryBuilder> opLambda)`
`void`	`setVirtualHost_Equal(String virtualHost)`
`void`	`setVirtualHost_Equal(String virtualHost, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)`
`void`	`setVirtualHost_Exists()`
`void`	`setVirtualHost_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.ExistsQueryBuilder> opLambda)`
`void`	`setVirtualHost_Fuzzy(String virtualHost)`
`void`	`setVirtualHost_Fuzzy(String virtualHost, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)`
`void`	`setVirtualHost_GreaterEqual(String virtualHost)`
`void`	`setVirtualHost_GreaterEqual(String virtualHost, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setVirtualHost_GreaterThan(String virtualHost)`
`void`	`setVirtualHost_GreaterThan(String virtualHost, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setVirtualHost_InScope(Collection<String> virtualHostList)`
`void`	`setVirtualHost_InScope(Collection<String> virtualHostList, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)`
`void`	`setVirtualHost_LessEqual(String virtualHost)`
`void`	`setVirtualHost_LessEqual(String virtualHost, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setVirtualHost_LessThan(String virtualHost)`
`void`	`setVirtualHost_LessThan(String virtualHost, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)`
`void`	`setVirtualHost_Match(String virtualHost)`
`void`	`setVirtualHost_Match(String virtualHost, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)`
`void`	`setVirtualHost_MatchPhrase(String virtualHost)`
`void`	`setVirtualHost_MatchPhrase(String virtualHost, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhraseQueryBuilder> opLambda)`
`void`	`setVirtualHost_MatchPhrasePrefix(String virtualHost)`
`void`	`setVirtualHost_MatchPhrasePrefix(String virtualHost, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhrasePrefixQueryBuilder> opLambda)`
`void`	`setVirtualHost_NotEqual(String virtualHost)`
`void`	`setVirtualHost_NotEqual(String virtualHost, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)`
`void`	`setVirtualHost_NotTerm(String virtualHost)`
`void`	`setVirtualHost_NotTerm(String virtualHost, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)`
`void`	`setVirtualHost_Prefix(String virtualHost)`
`void`	`setVirtualHost_Prefix(String virtualHost, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.PrefixQueryBuilder> opLambda)`
`void`	`setVirtualHost_Regexp(String virtualHost)`
`void`	`setVirtualHost_Regexp(String virtualHost, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RegexpQueryBuilder> opLambda)`
`void`	`setVirtualHost_SpanTerm(String virtualHost)`
`void`	`setVirtualHost_SpanTerm(String virtualHost, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.SpanTermQueryBuilder> opLambda)`
`void`	`setVirtualHost_Term(String virtualHost)`
`void`	`setVirtualHost_Term(String virtualHost, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)`
`void`	`setVirtualHost_Terms(Collection<String> virtualHostList)`
`void`	`setVirtualHost_Terms(Collection<String> virtualHostList, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)`
`void`	`setVirtualHost_Wildcard(String virtualHost)`
`void`	`setVirtualHost_Wildcard(String virtualHost, EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.WildcardQueryBuilder> opLambda)`
`String`	`xgetAliasName()`

Methods inherited from class org.codelibs.fess.es.log.allcommon.EsAbstractConditionQuery
addQuery, addRangeC, assertObjectNotNull, checkEsInvalidQuery, checkEsInvalidQueryCollection, docMeta, doMatchAll, doQueryString, getFieldSortBuilderList, getQuery, getQueryBuilderList, hasQueries, invokeForeignCQ, invokeHasForeignCQ, invokeOrderBy, invokeQuery, invokeQuery, invokeQueryEqual, invokeQueryNotEqual, invokeValue, isBaseQuery, matchAll, matchAll, queryString, queryString, regBoolCQ, regCommonTermsQ, regExistsQ, regFunctionScoreQ, regFuzzyQ, regIdsQ, registerOrderBy, regMatchPhrasePrefixQ, regMatchPhraseQ, regMatchQ, regMoreLikeThisQueryQ, regOBA, regOBD, regPrefixQ, regQ, regRangeQ, regRegexpQ, regSpanTermQ, regTermQ, regTermsQ, regWildcardQ, toColumnRealName, toColumnRealName, toColumnSqlName, toRangeDateString, toRangeLocalDateTimeString, xgetBaseCB, xgetBaseQuery, xgetForeignPropertyName, xgetLocationBase, xgetNestLevel, xgetNextNestLevel, xgetReferrerQuery, xgetRelationPath, xgetSqlClause, xregisterParameterOption

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

suppressUnusedImportLocalDateTime

protected static final Class<?> suppressUnusedImportLocalDateTime

Constructor Detail
- BsSearchLogCQ
```
public BsSearchLogCQ()
```

Method Detail

asTableDbName
```
public String asTableDbName()
```

xgetAliasName
```
public String xgetAliasName()
```

functionScore

public void functionScore(EsAbstractConditionQuery.OperatorCall<SearchLogCQ> queryLambda,
                          EsAbstractConditionQuery.ScoreFunctionCall<EsAbstractConditionQuery.ScoreFunctionCreator<SearchLogCQ>> functionsLambda,
                          EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.functionscore.FunctionScoreQueryBuilder> opLambda)

filtered

public void filtered(EsAbstractConditionQuery.FilteredCall<SearchLogCQ,SearchLogCQ> filteredLambda)

filtered

public void filtered(EsAbstractConditionQuery.FilteredCall<SearchLogCQ,SearchLogCQ> filteredLambda,
                     EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)

not

public void not(EsAbstractConditionQuery.OperatorCall<SearchLogCQ> notLambda)

not

public void not(EsAbstractConditionQuery.OperatorCall<SearchLogCQ> notLambda,
                EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)

bool

public void bool(EsAbstractConditionQuery.BoolCall<SearchLogCQ> boolLambda)

bool

public void bool(EsAbstractConditionQuery.BoolCall<SearchLogCQ> boolLambda,
                 EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)

setId_Equal
```
public void setId_Equal(String id)
```

setId_Equal

public void setId_Equal(String id,
                        EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)

setId_Term
```
public void setId_Term(String id)
```

setId_Term

public void setId_Term(String id,
                       EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)

setId_NotEqual

public void setId_NotEqual(String id)

setId_NotTerm
```
public void setId_NotTerm(String id)
```

setId_NotEqual

public void setId_NotEqual(String id,
                           EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)

setId_NotTerm

public void setId_NotTerm(String id,
                          EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)

setId_Terms

public void setId_Terms(Collection<String> idList)

setId_Terms

public void setId_Terms(Collection<String> idList,
                        EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.IdsQueryBuilder> opLambda)

setId_InScope

public void setId_InScope(Collection<String> idList)

setId_InScope

public void setId_InScope(Collection<String> idList,
                          EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.IdsQueryBuilder> opLambda)

addOrderBy_Id_Asc

public BsSearchLogCQ addOrderBy_Id_Asc()

addOrderBy_Id_Desc

public BsSearchLogCQ addOrderBy_Id_Desc()

setAccessType_Equal

public void setAccessType_Equal(String accessType)

setAccessType_Equal

public void setAccessType_Equal(String accessType,
                                EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)

setAccessType_Term

public void setAccessType_Term(String accessType)

setAccessType_Term

public void setAccessType_Term(String accessType,
                               EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)

setAccessType_NotEqual

public void setAccessType_NotEqual(String accessType)

setAccessType_NotTerm

public void setAccessType_NotTerm(String accessType)

setAccessType_NotEqual

public void setAccessType_NotEqual(String accessType,
                                   EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)

setAccessType_NotTerm

public void setAccessType_NotTerm(String accessType,
                                  EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)

setAccessType_Terms

public void setAccessType_Terms(Collection<String> accessTypeList)

setAccessType_Terms

public void setAccessType_Terms(Collection<String> accessTypeList,
                                EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)

setAccessType_InScope

public void setAccessType_InScope(Collection<String> accessTypeList)

setAccessType_InScope

public void setAccessType_InScope(Collection<String> accessTypeList,
                                  EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)

setAccessType_Match

public void setAccessType_Match(String accessType)

setAccessType_Match

public void setAccessType_Match(String accessType,
                                EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)

setAccessType_MatchPhrase

public void setAccessType_MatchPhrase(String accessType)

setAccessType_MatchPhrase

public void setAccessType_MatchPhrase(String accessType,
                                      EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhraseQueryBuilder> opLambda)

setAccessType_MatchPhrasePrefix

public void setAccessType_MatchPhrasePrefix(String accessType)

setAccessType_MatchPhrasePrefix

public void setAccessType_MatchPhrasePrefix(String accessType,
                                            EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhrasePrefixQueryBuilder> opLambda)

setAccessType_Fuzzy

public void setAccessType_Fuzzy(String accessType)

setAccessType_Fuzzy

public void setAccessType_Fuzzy(String accessType,
                                EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)

setAccessType_Prefix

public void setAccessType_Prefix(String accessType)

setAccessType_Prefix

public void setAccessType_Prefix(String accessType,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.PrefixQueryBuilder> opLambda)

setAccessType_Wildcard

public void setAccessType_Wildcard(String accessType)

setAccessType_Wildcard

public void setAccessType_Wildcard(String accessType,
                                   EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.WildcardQueryBuilder> opLambda)

setAccessType_Regexp

public void setAccessType_Regexp(String accessType)

setAccessType_Regexp

public void setAccessType_Regexp(String accessType,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RegexpQueryBuilder> opLambda)

setAccessType_SpanTerm

public void setAccessType_SpanTerm(String accessType)

setAccessType_SpanTerm

public void setAccessType_SpanTerm(String accessType,
                                   EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.SpanTermQueryBuilder> opLambda)

setAccessType_GreaterThan

public void setAccessType_GreaterThan(String accessType)

setAccessType_GreaterThan

public void setAccessType_GreaterThan(String accessType,
                                      EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setAccessType_LessThan

public void setAccessType_LessThan(String accessType)

setAccessType_LessThan

public void setAccessType_LessThan(String accessType,
                                   EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setAccessType_GreaterEqual

public void setAccessType_GreaterEqual(String accessType)

setAccessType_GreaterEqual

public void setAccessType_GreaterEqual(String accessType,
                                       EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setAccessType_LessEqual

public void setAccessType_LessEqual(String accessType)

setAccessType_LessEqual

public void setAccessType_LessEqual(String accessType,
                                    EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setAccessType_Exists
```
public void setAccessType_Exists()
```

setAccessType_Exists

public void setAccessType_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.ExistsQueryBuilder> opLambda)

setAccessType_CommonTerms

public void setAccessType_CommonTerms(String accessType)

setAccessType_CommonTerms

public void setAccessType_CommonTerms(String accessType,
                                      EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.CommonTermsQueryBuilder> opLambda)

addOrderBy_AccessType_Asc

public BsSearchLogCQ addOrderBy_AccessType_Asc()

addOrderBy_AccessType_Desc

public BsSearchLogCQ addOrderBy_AccessType_Desc()

setUser_Equal

public void setUser_Equal(String user)

setUser_Equal

public void setUser_Equal(String user,
                          EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)

setUser_Term

public void setUser_Term(String user)

setUser_Term

public void setUser_Term(String user,
                         EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)

setUser_NotEqual

public void setUser_NotEqual(String user)

setUser_NotTerm

public void setUser_NotTerm(String user)

setUser_NotEqual

public void setUser_NotEqual(String user,
                             EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)

setUser_NotTerm

public void setUser_NotTerm(String user,
                            EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)

setUser_Terms

public void setUser_Terms(Collection<String> userList)

setUser_Terms

public void setUser_Terms(Collection<String> userList,
                          EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)

setUser_InScope

public void setUser_InScope(Collection<String> userList)

setUser_InScope

public void setUser_InScope(Collection<String> userList,
                            EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)

setUser_Match

public void setUser_Match(String user)

setUser_Match

public void setUser_Match(String user,
                          EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)

setUser_MatchPhrase

public void setUser_MatchPhrase(String user)

setUser_MatchPhrase

public void setUser_MatchPhrase(String user,
                                EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhraseQueryBuilder> opLambda)

setUser_MatchPhrasePrefix

public void setUser_MatchPhrasePrefix(String user)

setUser_MatchPhrasePrefix

public void setUser_MatchPhrasePrefix(String user,
                                      EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhrasePrefixQueryBuilder> opLambda)

setUser_Fuzzy

public void setUser_Fuzzy(String user)

setUser_Fuzzy

public void setUser_Fuzzy(String user,
                          EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)

setUser_Prefix

public void setUser_Prefix(String user)

setUser_Prefix

public void setUser_Prefix(String user,
                           EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.PrefixQueryBuilder> opLambda)

setUser_Wildcard

public void setUser_Wildcard(String user)

setUser_Wildcard

public void setUser_Wildcard(String user,
                             EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.WildcardQueryBuilder> opLambda)

setUser_Regexp

public void setUser_Regexp(String user)

setUser_Regexp

public void setUser_Regexp(String user,
                           EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RegexpQueryBuilder> opLambda)

setUser_SpanTerm

public void setUser_SpanTerm(String user)

setUser_SpanTerm

public void setUser_SpanTerm(String user,
                             EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.SpanTermQueryBuilder> opLambda)

setUser_GreaterThan

public void setUser_GreaterThan(String user)

setUser_GreaterThan

public void setUser_GreaterThan(String user,
                                EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setUser_LessThan

public void setUser_LessThan(String user)

setUser_LessThan

public void setUser_LessThan(String user,
                             EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setUser_GreaterEqual

public void setUser_GreaterEqual(String user)

setUser_GreaterEqual

public void setUser_GreaterEqual(String user,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setUser_LessEqual

public void setUser_LessEqual(String user)

setUser_LessEqual

public void setUser_LessEqual(String user,
                              EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setUser_Exists
```
public void setUser_Exists()
```

setUser_Exists

public void setUser_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.ExistsQueryBuilder> opLambda)

setUser_CommonTerms

public void setUser_CommonTerms(String user)

setUser_CommonTerms

public void setUser_CommonTerms(String user,
                                EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.CommonTermsQueryBuilder> opLambda)

addOrderBy_User_Asc

public BsSearchLogCQ addOrderBy_User_Asc()

addOrderBy_User_Desc

public BsSearchLogCQ addOrderBy_User_Desc()

setRoles_Equal

public void setRoles_Equal(String roles)

setRoles_Equal

public void setRoles_Equal(String roles,
                           EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)

setRoles_Term

public void setRoles_Term(String roles)

setRoles_Term

public void setRoles_Term(String roles,
                          EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)

setRoles_NotEqual

public void setRoles_NotEqual(String roles)

setRoles_NotTerm

public void setRoles_NotTerm(String roles)

setRoles_NotEqual

public void setRoles_NotEqual(String roles,
                              EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)

setRoles_NotTerm

public void setRoles_NotTerm(String roles,
                             EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)

setRoles_Terms

public void setRoles_Terms(Collection<String> rolesList)

setRoles_Terms

public void setRoles_Terms(Collection<String> rolesList,
                           EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)

setRoles_InScope

public void setRoles_InScope(Collection<String> rolesList)

setRoles_InScope

public void setRoles_InScope(Collection<String> rolesList,
                             EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)

setRoles_Match

public void setRoles_Match(String roles)

setRoles_Match

public void setRoles_Match(String roles,
                           EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)

setRoles_MatchPhrase

public void setRoles_MatchPhrase(String roles)

setRoles_MatchPhrase

public void setRoles_MatchPhrase(String roles,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhraseQueryBuilder> opLambda)

setRoles_MatchPhrasePrefix

public void setRoles_MatchPhrasePrefix(String roles)

setRoles_MatchPhrasePrefix

public void setRoles_MatchPhrasePrefix(String roles,
                                       EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhrasePrefixQueryBuilder> opLambda)

setRoles_Fuzzy

public void setRoles_Fuzzy(String roles)

setRoles_Fuzzy

public void setRoles_Fuzzy(String roles,
                           EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)

setRoles_Prefix

public void setRoles_Prefix(String roles)

setRoles_Prefix

public void setRoles_Prefix(String roles,
                            EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.PrefixQueryBuilder> opLambda)

setRoles_Wildcard

public void setRoles_Wildcard(String roles)

setRoles_Wildcard

public void setRoles_Wildcard(String roles,
                              EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.WildcardQueryBuilder> opLambda)

setRoles_Regexp

public void setRoles_Regexp(String roles)

setRoles_Regexp

public void setRoles_Regexp(String roles,
                            EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RegexpQueryBuilder> opLambda)

setRoles_SpanTerm

public void setRoles_SpanTerm(String roles)

setRoles_SpanTerm

public void setRoles_SpanTerm(String roles,
                              EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.SpanTermQueryBuilder> opLambda)

setRoles_GreaterThan

public void setRoles_GreaterThan(String roles)

setRoles_GreaterThan

public void setRoles_GreaterThan(String roles,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setRoles_LessThan

public void setRoles_LessThan(String roles)

setRoles_LessThan

public void setRoles_LessThan(String roles,
                              EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setRoles_GreaterEqual

public void setRoles_GreaterEqual(String roles)

setRoles_GreaterEqual

public void setRoles_GreaterEqual(String roles,
                                  EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setRoles_LessEqual

public void setRoles_LessEqual(String roles)

setRoles_LessEqual

public void setRoles_LessEqual(String roles,
                               EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setRoles_Exists
```
public void setRoles_Exists()
```

setRoles_Exists

public void setRoles_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.ExistsQueryBuilder> opLambda)

setRoles_CommonTerms

public void setRoles_CommonTerms(String roles)

setRoles_CommonTerms

public void setRoles_CommonTerms(String roles,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.CommonTermsQueryBuilder> opLambda)

addOrderBy_Roles_Asc

public BsSearchLogCQ addOrderBy_Roles_Asc()

addOrderBy_Roles_Desc

public BsSearchLogCQ addOrderBy_Roles_Desc()

setQueryId_Equal

public void setQueryId_Equal(String queryId)

setQueryId_Equal

public void setQueryId_Equal(String queryId,
                             EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)

setQueryId_Term

public void setQueryId_Term(String queryId)

setQueryId_Term

public void setQueryId_Term(String queryId,
                            EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)

setQueryId_NotEqual

public void setQueryId_NotEqual(String queryId)

setQueryId_NotTerm

public void setQueryId_NotTerm(String queryId)

setQueryId_NotEqual

public void setQueryId_NotEqual(String queryId,
                                EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)

setQueryId_NotTerm

public void setQueryId_NotTerm(String queryId,
                               EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)

setQueryId_Terms

public void setQueryId_Terms(Collection<String> queryIdList)

setQueryId_Terms

public void setQueryId_Terms(Collection<String> queryIdList,
                             EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)

setQueryId_InScope

public void setQueryId_InScope(Collection<String> queryIdList)

setQueryId_InScope

public void setQueryId_InScope(Collection<String> queryIdList,
                               EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)

setQueryId_Match

public void setQueryId_Match(String queryId)

setQueryId_Match

public void setQueryId_Match(String queryId,
                             EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)

setQueryId_MatchPhrase

public void setQueryId_MatchPhrase(String queryId)

setQueryId_MatchPhrase

public void setQueryId_MatchPhrase(String queryId,
                                   EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhraseQueryBuilder> opLambda)

setQueryId_MatchPhrasePrefix

public void setQueryId_MatchPhrasePrefix(String queryId)

setQueryId_MatchPhrasePrefix

public void setQueryId_MatchPhrasePrefix(String queryId,
                                         EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhrasePrefixQueryBuilder> opLambda)

setQueryId_Fuzzy

public void setQueryId_Fuzzy(String queryId)

setQueryId_Fuzzy

public void setQueryId_Fuzzy(String queryId,
                             EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)

setQueryId_Prefix

public void setQueryId_Prefix(String queryId)

setQueryId_Prefix

public void setQueryId_Prefix(String queryId,
                              EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.PrefixQueryBuilder> opLambda)

setQueryId_Wildcard

public void setQueryId_Wildcard(String queryId)

setQueryId_Wildcard

public void setQueryId_Wildcard(String queryId,
                                EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.WildcardQueryBuilder> opLambda)

setQueryId_Regexp

public void setQueryId_Regexp(String queryId)

setQueryId_Regexp

public void setQueryId_Regexp(String queryId,
                              EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RegexpQueryBuilder> opLambda)

setQueryId_SpanTerm

public void setQueryId_SpanTerm(String queryId)

setQueryId_SpanTerm

public void setQueryId_SpanTerm(String queryId,
                                EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.SpanTermQueryBuilder> opLambda)

setQueryId_GreaterThan

public void setQueryId_GreaterThan(String queryId)

setQueryId_GreaterThan

public void setQueryId_GreaterThan(String queryId,
                                   EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setQueryId_LessThan

public void setQueryId_LessThan(String queryId)

setQueryId_LessThan

public void setQueryId_LessThan(String queryId,
                                EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setQueryId_GreaterEqual

public void setQueryId_GreaterEqual(String queryId)

setQueryId_GreaterEqual

public void setQueryId_GreaterEqual(String queryId,
                                    EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setQueryId_LessEqual

public void setQueryId_LessEqual(String queryId)

setQueryId_LessEqual

public void setQueryId_LessEqual(String queryId,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setQueryId_Exists
```
public void setQueryId_Exists()
```

setQueryId_Exists

public void setQueryId_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.ExistsQueryBuilder> opLambda)

setQueryId_CommonTerms

public void setQueryId_CommonTerms(String queryId)

setQueryId_CommonTerms

public void setQueryId_CommonTerms(String queryId,
                                   EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.CommonTermsQueryBuilder> opLambda)

addOrderBy_QueryId_Asc

public BsSearchLogCQ addOrderBy_QueryId_Asc()

addOrderBy_QueryId_Desc

public BsSearchLogCQ addOrderBy_QueryId_Desc()

setClientIp_Equal

public void setClientIp_Equal(String clientIp)

setClientIp_Equal

public void setClientIp_Equal(String clientIp,
                              EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)

setClientIp_Term

public void setClientIp_Term(String clientIp)

setClientIp_Term

public void setClientIp_Term(String clientIp,
                             EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)

setClientIp_NotEqual

public void setClientIp_NotEqual(String clientIp)

setClientIp_NotTerm

public void setClientIp_NotTerm(String clientIp)

setClientIp_NotEqual

public void setClientIp_NotEqual(String clientIp,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)

setClientIp_NotTerm

public void setClientIp_NotTerm(String clientIp,
                                EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)

setClientIp_Terms

public void setClientIp_Terms(Collection<String> clientIpList)

setClientIp_Terms

public void setClientIp_Terms(Collection<String> clientIpList,
                              EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)

setClientIp_InScope

public void setClientIp_InScope(Collection<String> clientIpList)

setClientIp_InScope

public void setClientIp_InScope(Collection<String> clientIpList,
                                EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)

setClientIp_Match

public void setClientIp_Match(String clientIp)

setClientIp_Match

public void setClientIp_Match(String clientIp,
                              EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)

setClientIp_MatchPhrase

public void setClientIp_MatchPhrase(String clientIp)

setClientIp_MatchPhrase

public void setClientIp_MatchPhrase(String clientIp,
                                    EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhraseQueryBuilder> opLambda)

setClientIp_MatchPhrasePrefix

public void setClientIp_MatchPhrasePrefix(String clientIp)

setClientIp_MatchPhrasePrefix

public void setClientIp_MatchPhrasePrefix(String clientIp,
                                          EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhrasePrefixQueryBuilder> opLambda)

setClientIp_Fuzzy

public void setClientIp_Fuzzy(String clientIp)

setClientIp_Fuzzy

public void setClientIp_Fuzzy(String clientIp,
                              EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)

setClientIp_Prefix

public void setClientIp_Prefix(String clientIp)

setClientIp_Prefix

public void setClientIp_Prefix(String clientIp,
                               EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.PrefixQueryBuilder> opLambda)

setClientIp_Wildcard

public void setClientIp_Wildcard(String clientIp)

setClientIp_Wildcard

public void setClientIp_Wildcard(String clientIp,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.WildcardQueryBuilder> opLambda)

setClientIp_Regexp

public void setClientIp_Regexp(String clientIp)

setClientIp_Regexp

public void setClientIp_Regexp(String clientIp,
                               EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RegexpQueryBuilder> opLambda)

setClientIp_SpanTerm

public void setClientIp_SpanTerm(String clientIp)

setClientIp_SpanTerm

public void setClientIp_SpanTerm(String clientIp,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.SpanTermQueryBuilder> opLambda)

setClientIp_GreaterThan

public void setClientIp_GreaterThan(String clientIp)

setClientIp_GreaterThan

public void setClientIp_GreaterThan(String clientIp,
                                    EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setClientIp_LessThan

public void setClientIp_LessThan(String clientIp)

setClientIp_LessThan

public void setClientIp_LessThan(String clientIp,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setClientIp_GreaterEqual

public void setClientIp_GreaterEqual(String clientIp)

setClientIp_GreaterEqual

public void setClientIp_GreaterEqual(String clientIp,
                                     EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setClientIp_LessEqual

public void setClientIp_LessEqual(String clientIp)

setClientIp_LessEqual

public void setClientIp_LessEqual(String clientIp,
                                  EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setClientIp_Exists
```
public void setClientIp_Exists()
```

setClientIp_Exists

public void setClientIp_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.ExistsQueryBuilder> opLambda)

setClientIp_CommonTerms

public void setClientIp_CommonTerms(String clientIp)

setClientIp_CommonTerms

public void setClientIp_CommonTerms(String clientIp,
                                    EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.CommonTermsQueryBuilder> opLambda)

addOrderBy_ClientIp_Asc

public BsSearchLogCQ addOrderBy_ClientIp_Asc()

addOrderBy_ClientIp_Desc

public BsSearchLogCQ addOrderBy_ClientIp_Desc()

setHitCount_Equal

public void setHitCount_Equal(Long hitCount)

setHitCount_Equal

public void setHitCount_Equal(Long hitCount,
                              EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)

setHitCount_Term

public void setHitCount_Term(Long hitCount)

setHitCount_Term

public void setHitCount_Term(Long hitCount,
                             EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)

setHitCount_NotEqual

public void setHitCount_NotEqual(Long hitCount)

setHitCount_NotTerm

public void setHitCount_NotTerm(Long hitCount)

setHitCount_NotEqual

public void setHitCount_NotEqual(Long hitCount,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)

setHitCount_NotTerm

public void setHitCount_NotTerm(Long hitCount,
                                EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)

setHitCount_Terms

public void setHitCount_Terms(Collection<Long> hitCountList)

setHitCount_Terms

public void setHitCount_Terms(Collection<Long> hitCountList,
                              EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)

setHitCount_InScope

public void setHitCount_InScope(Collection<Long> hitCountList)

setHitCount_InScope

public void setHitCount_InScope(Collection<Long> hitCountList,
                                EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)

setHitCount_Match

public void setHitCount_Match(Long hitCount)

setHitCount_Match

public void setHitCount_Match(Long hitCount,
                              EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)

setHitCount_MatchPhrase

public void setHitCount_MatchPhrase(Long hitCount)

setHitCount_MatchPhrase

public void setHitCount_MatchPhrase(Long hitCount,
                                    EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhraseQueryBuilder> opLambda)

setHitCount_MatchPhrasePrefix

public void setHitCount_MatchPhrasePrefix(Long hitCount)

setHitCount_MatchPhrasePrefix

public void setHitCount_MatchPhrasePrefix(Long hitCount,
                                          EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhrasePrefixQueryBuilder> opLambda)

setHitCount_Fuzzy

public void setHitCount_Fuzzy(Long hitCount)

setHitCount_Fuzzy

public void setHitCount_Fuzzy(Long hitCount,
                              EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)

setHitCount_GreaterThan

public void setHitCount_GreaterThan(Long hitCount)

setHitCount_GreaterThan

public void setHitCount_GreaterThan(Long hitCount,
                                    EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setHitCount_LessThan

public void setHitCount_LessThan(Long hitCount)

setHitCount_LessThan

public void setHitCount_LessThan(Long hitCount,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setHitCount_GreaterEqual

public void setHitCount_GreaterEqual(Long hitCount)

setHitCount_GreaterEqual

public void setHitCount_GreaterEqual(Long hitCount,
                                     EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setHitCount_LessEqual

public void setHitCount_LessEqual(Long hitCount)

setHitCount_LessEqual

public void setHitCount_LessEqual(Long hitCount,
                                  EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setHitCount_Exists
```
public void setHitCount_Exists()
```

setHitCount_Exists

public void setHitCount_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.ExistsQueryBuilder> opLambda)

setHitCount_CommonTerms

public void setHitCount_CommonTerms(Long hitCount)

setHitCount_CommonTerms

public void setHitCount_CommonTerms(Long hitCount,
                                    EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.CommonTermsQueryBuilder> opLambda)

addOrderBy_HitCount_Asc

public BsSearchLogCQ addOrderBy_HitCount_Asc()

addOrderBy_HitCount_Desc

public BsSearchLogCQ addOrderBy_HitCount_Desc()

setQueryOffset_Equal

public void setQueryOffset_Equal(Integer queryOffset)

setQueryOffset_Equal

public void setQueryOffset_Equal(Integer queryOffset,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)

setQueryOffset_Term

public void setQueryOffset_Term(Integer queryOffset)

setQueryOffset_Term

public void setQueryOffset_Term(Integer queryOffset,
                                EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)

setQueryOffset_NotEqual

public void setQueryOffset_NotEqual(Integer queryOffset)

setQueryOffset_NotTerm

public void setQueryOffset_NotTerm(Integer queryOffset)

setQueryOffset_NotEqual

public void setQueryOffset_NotEqual(Integer queryOffset,
                                    EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)

setQueryOffset_NotTerm

public void setQueryOffset_NotTerm(Integer queryOffset,
                                   EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)

setQueryOffset_Terms

public void setQueryOffset_Terms(Collection<Integer> queryOffsetList)

setQueryOffset_Terms

public void setQueryOffset_Terms(Collection<Integer> queryOffsetList,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)

setQueryOffset_InScope

public void setQueryOffset_InScope(Collection<Integer> queryOffsetList)

setQueryOffset_InScope

public void setQueryOffset_InScope(Collection<Integer> queryOffsetList,
                                   EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)

setQueryOffset_Match

public void setQueryOffset_Match(Integer queryOffset)

setQueryOffset_Match

public void setQueryOffset_Match(Integer queryOffset,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)

setQueryOffset_MatchPhrase

public void setQueryOffset_MatchPhrase(Integer queryOffset)

setQueryOffset_MatchPhrase

public void setQueryOffset_MatchPhrase(Integer queryOffset,
                                       EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhraseQueryBuilder> opLambda)

setQueryOffset_MatchPhrasePrefix

public void setQueryOffset_MatchPhrasePrefix(Integer queryOffset)

setQueryOffset_MatchPhrasePrefix

public void setQueryOffset_MatchPhrasePrefix(Integer queryOffset,
                                             EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhrasePrefixQueryBuilder> opLambda)

setQueryOffset_Fuzzy

public void setQueryOffset_Fuzzy(Integer queryOffset)

setQueryOffset_Fuzzy

public void setQueryOffset_Fuzzy(Integer queryOffset,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)

setQueryOffset_GreaterThan

public void setQueryOffset_GreaterThan(Integer queryOffset)

setQueryOffset_GreaterThan

public void setQueryOffset_GreaterThan(Integer queryOffset,
                                       EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setQueryOffset_LessThan

public void setQueryOffset_LessThan(Integer queryOffset)

setQueryOffset_LessThan

public void setQueryOffset_LessThan(Integer queryOffset,
                                    EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setQueryOffset_GreaterEqual

public void setQueryOffset_GreaterEqual(Integer queryOffset)

setQueryOffset_GreaterEqual

public void setQueryOffset_GreaterEqual(Integer queryOffset,
                                        EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setQueryOffset_LessEqual

public void setQueryOffset_LessEqual(Integer queryOffset)

setQueryOffset_LessEqual

public void setQueryOffset_LessEqual(Integer queryOffset,
                                     EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setQueryOffset_Exists
```
public void setQueryOffset_Exists()
```

setQueryOffset_Exists

public void setQueryOffset_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.ExistsQueryBuilder> opLambda)

setQueryOffset_CommonTerms

public void setQueryOffset_CommonTerms(Integer queryOffset)

setQueryOffset_CommonTerms

public void setQueryOffset_CommonTerms(Integer queryOffset,
                                       EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.CommonTermsQueryBuilder> opLambda)

addOrderBy_QueryOffset_Asc

public BsSearchLogCQ addOrderBy_QueryOffset_Asc()

addOrderBy_QueryOffset_Desc

public BsSearchLogCQ addOrderBy_QueryOffset_Desc()

setQueryPageSize_Equal

public void setQueryPageSize_Equal(Integer queryPageSize)

setQueryPageSize_Equal

public void setQueryPageSize_Equal(Integer queryPageSize,
                                   EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)

setQueryPageSize_Term

public void setQueryPageSize_Term(Integer queryPageSize)

setQueryPageSize_Term

public void setQueryPageSize_Term(Integer queryPageSize,
                                  EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)

setQueryPageSize_NotEqual

public void setQueryPageSize_NotEqual(Integer queryPageSize)

setQueryPageSize_NotTerm

public void setQueryPageSize_NotTerm(Integer queryPageSize)

setQueryPageSize_NotEqual

public void setQueryPageSize_NotEqual(Integer queryPageSize,
                                      EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)

setQueryPageSize_NotTerm

public void setQueryPageSize_NotTerm(Integer queryPageSize,
                                     EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)

setQueryPageSize_Terms

public void setQueryPageSize_Terms(Collection<Integer> queryPageSizeList)

setQueryPageSize_Terms

public void setQueryPageSize_Terms(Collection<Integer> queryPageSizeList,
                                   EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)

setQueryPageSize_InScope

public void setQueryPageSize_InScope(Collection<Integer> queryPageSizeList)

setQueryPageSize_InScope

public void setQueryPageSize_InScope(Collection<Integer> queryPageSizeList,
                                     EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)

setQueryPageSize_Match

public void setQueryPageSize_Match(Integer queryPageSize)

setQueryPageSize_Match

public void setQueryPageSize_Match(Integer queryPageSize,
                                   EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)

setQueryPageSize_MatchPhrase

public void setQueryPageSize_MatchPhrase(Integer queryPageSize)

setQueryPageSize_MatchPhrase

public void setQueryPageSize_MatchPhrase(Integer queryPageSize,
                                         EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhraseQueryBuilder> opLambda)

setQueryPageSize_MatchPhrasePrefix

public void setQueryPageSize_MatchPhrasePrefix(Integer queryPageSize)

setQueryPageSize_MatchPhrasePrefix

public void setQueryPageSize_MatchPhrasePrefix(Integer queryPageSize,
                                               EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhrasePrefixQueryBuilder> opLambda)

setQueryPageSize_Fuzzy

public void setQueryPageSize_Fuzzy(Integer queryPageSize)

setQueryPageSize_Fuzzy

public void setQueryPageSize_Fuzzy(Integer queryPageSize,
                                   EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)

setQueryPageSize_GreaterThan

public void setQueryPageSize_GreaterThan(Integer queryPageSize)

setQueryPageSize_GreaterThan

public void setQueryPageSize_GreaterThan(Integer queryPageSize,
                                         EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setQueryPageSize_LessThan

public void setQueryPageSize_LessThan(Integer queryPageSize)

setQueryPageSize_LessThan

public void setQueryPageSize_LessThan(Integer queryPageSize,
                                      EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setQueryPageSize_GreaterEqual

public void setQueryPageSize_GreaterEqual(Integer queryPageSize)

setQueryPageSize_GreaterEqual

public void setQueryPageSize_GreaterEqual(Integer queryPageSize,
                                          EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setQueryPageSize_LessEqual

public void setQueryPageSize_LessEqual(Integer queryPageSize)

setQueryPageSize_LessEqual

public void setQueryPageSize_LessEqual(Integer queryPageSize,
                                       EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setQueryPageSize_Exists
```
public void setQueryPageSize_Exists()
```

setQueryPageSize_Exists

public void setQueryPageSize_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.ExistsQueryBuilder> opLambda)

setQueryPageSize_CommonTerms

public void setQueryPageSize_CommonTerms(Integer queryPageSize)

setQueryPageSize_CommonTerms

public void setQueryPageSize_CommonTerms(Integer queryPageSize,
                                         EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.CommonTermsQueryBuilder> opLambda)

addOrderBy_QueryPageSize_Asc

public BsSearchLogCQ addOrderBy_QueryPageSize_Asc()

addOrderBy_QueryPageSize_Desc

public BsSearchLogCQ addOrderBy_QueryPageSize_Desc()

setReferer_Equal

public void setReferer_Equal(String referer)

setReferer_Equal

public void setReferer_Equal(String referer,
                             EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)

setReferer_Term

public void setReferer_Term(String referer)

setReferer_Term

public void setReferer_Term(String referer,
                            EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)

setReferer_NotEqual

public void setReferer_NotEqual(String referer)

setReferer_NotTerm

public void setReferer_NotTerm(String referer)

setReferer_NotEqual

public void setReferer_NotEqual(String referer,
                                EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)

setReferer_NotTerm

public void setReferer_NotTerm(String referer,
                               EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)

setReferer_Terms

public void setReferer_Terms(Collection<String> refererList)

setReferer_Terms

public void setReferer_Terms(Collection<String> refererList,
                             EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)

setReferer_InScope

public void setReferer_InScope(Collection<String> refererList)

setReferer_InScope

public void setReferer_InScope(Collection<String> refererList,
                               EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)

setReferer_Match

public void setReferer_Match(String referer)

setReferer_Match

public void setReferer_Match(String referer,
                             EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)

setReferer_MatchPhrase

public void setReferer_MatchPhrase(String referer)

setReferer_MatchPhrase

public void setReferer_MatchPhrase(String referer,
                                   EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhraseQueryBuilder> opLambda)

setReferer_MatchPhrasePrefix

public void setReferer_MatchPhrasePrefix(String referer)

setReferer_MatchPhrasePrefix

public void setReferer_MatchPhrasePrefix(String referer,
                                         EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhrasePrefixQueryBuilder> opLambda)

setReferer_Fuzzy

public void setReferer_Fuzzy(String referer)

setReferer_Fuzzy

public void setReferer_Fuzzy(String referer,
                             EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)

setReferer_Prefix

public void setReferer_Prefix(String referer)

setReferer_Prefix

public void setReferer_Prefix(String referer,
                              EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.PrefixQueryBuilder> opLambda)

setReferer_Wildcard

public void setReferer_Wildcard(String referer)

setReferer_Wildcard

public void setReferer_Wildcard(String referer,
                                EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.WildcardQueryBuilder> opLambda)

setReferer_Regexp

public void setReferer_Regexp(String referer)

setReferer_Regexp

public void setReferer_Regexp(String referer,
                              EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RegexpQueryBuilder> opLambda)

setReferer_SpanTerm

public void setReferer_SpanTerm(String referer)

setReferer_SpanTerm

public void setReferer_SpanTerm(String referer,
                                EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.SpanTermQueryBuilder> opLambda)

setReferer_GreaterThan

public void setReferer_GreaterThan(String referer)

setReferer_GreaterThan

public void setReferer_GreaterThan(String referer,
                                   EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setReferer_LessThan

public void setReferer_LessThan(String referer)

setReferer_LessThan

public void setReferer_LessThan(String referer,
                                EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setReferer_GreaterEqual

public void setReferer_GreaterEqual(String referer)

setReferer_GreaterEqual

public void setReferer_GreaterEqual(String referer,
                                    EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setReferer_LessEqual

public void setReferer_LessEqual(String referer)

setReferer_LessEqual

public void setReferer_LessEqual(String referer,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setReferer_Exists
```
public void setReferer_Exists()
```

setReferer_Exists

public void setReferer_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.ExistsQueryBuilder> opLambda)

setReferer_CommonTerms

public void setReferer_CommonTerms(String referer)

setReferer_CommonTerms

public void setReferer_CommonTerms(String referer,
                                   EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.CommonTermsQueryBuilder> opLambda)

addOrderBy_Referer_Asc

public BsSearchLogCQ addOrderBy_Referer_Asc()

addOrderBy_Referer_Desc

public BsSearchLogCQ addOrderBy_Referer_Desc()

setRequestedAt_Equal

public void setRequestedAt_Equal(LocalDateTime requestedAt)

setRequestedAt_Equal

public void setRequestedAt_Equal(LocalDateTime requestedAt,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)

setRequestedAt_Term

public void setRequestedAt_Term(LocalDateTime requestedAt)

setRequestedAt_Term

public void setRequestedAt_Term(LocalDateTime requestedAt,
                                EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)

setRequestedAt_NotEqual

public void setRequestedAt_NotEqual(LocalDateTime requestedAt)

setRequestedAt_NotTerm

public void setRequestedAt_NotTerm(LocalDateTime requestedAt)

setRequestedAt_NotEqual

public void setRequestedAt_NotEqual(LocalDateTime requestedAt,
                                    EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)

setRequestedAt_NotTerm

public void setRequestedAt_NotTerm(LocalDateTime requestedAt,
                                   EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)

setRequestedAt_Terms

public void setRequestedAt_Terms(Collection<LocalDateTime> requestedAtList)

setRequestedAt_Terms

public void setRequestedAt_Terms(Collection<LocalDateTime> requestedAtList,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)

setRequestedAt_InScope

public void setRequestedAt_InScope(Collection<LocalDateTime> requestedAtList)

setRequestedAt_InScope

public void setRequestedAt_InScope(Collection<LocalDateTime> requestedAtList,
                                   EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)

setRequestedAt_Match

public void setRequestedAt_Match(LocalDateTime requestedAt)

setRequestedAt_Match

public void setRequestedAt_Match(LocalDateTime requestedAt,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)

setRequestedAt_MatchPhrase

public void setRequestedAt_MatchPhrase(LocalDateTime requestedAt)

setRequestedAt_MatchPhrase

public void setRequestedAt_MatchPhrase(LocalDateTime requestedAt,
                                       EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhraseQueryBuilder> opLambda)

setRequestedAt_MatchPhrasePrefix

public void setRequestedAt_MatchPhrasePrefix(LocalDateTime requestedAt)

setRequestedAt_MatchPhrasePrefix

public void setRequestedAt_MatchPhrasePrefix(LocalDateTime requestedAt,
                                             EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhrasePrefixQueryBuilder> opLambda)

setRequestedAt_Fuzzy

public void setRequestedAt_Fuzzy(LocalDateTime requestedAt)

setRequestedAt_Fuzzy

public void setRequestedAt_Fuzzy(LocalDateTime requestedAt,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)

setRequestedAt_GreaterThan

public void setRequestedAt_GreaterThan(LocalDateTime requestedAt)

setRequestedAt_GreaterThan

public void setRequestedAt_GreaterThan(LocalDateTime requestedAt,
                                       EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setRequestedAt_LessThan

public void setRequestedAt_LessThan(LocalDateTime requestedAt)

setRequestedAt_LessThan

public void setRequestedAt_LessThan(LocalDateTime requestedAt,
                                    EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setRequestedAt_GreaterEqual

public void setRequestedAt_GreaterEqual(LocalDateTime requestedAt)

setRequestedAt_GreaterEqual

public void setRequestedAt_GreaterEqual(LocalDateTime requestedAt,
                                        EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setRequestedAt_LessEqual

public void setRequestedAt_LessEqual(LocalDateTime requestedAt)

setRequestedAt_LessEqual

public void setRequestedAt_LessEqual(LocalDateTime requestedAt,
                                     EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setRequestedAt_Exists
```
public void setRequestedAt_Exists()
```

setRequestedAt_Exists

public void setRequestedAt_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.ExistsQueryBuilder> opLambda)

setRequestedAt_CommonTerms

public void setRequestedAt_CommonTerms(LocalDateTime requestedAt)

setRequestedAt_CommonTerms

public void setRequestedAt_CommonTerms(LocalDateTime requestedAt,
                                       EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.CommonTermsQueryBuilder> opLambda)

addOrderBy_RequestedAt_Asc

public BsSearchLogCQ addOrderBy_RequestedAt_Asc()

addOrderBy_RequestedAt_Desc

public BsSearchLogCQ addOrderBy_RequestedAt_Desc()

setResponseTime_Equal

public void setResponseTime_Equal(Long responseTime)

setResponseTime_Equal

public void setResponseTime_Equal(Long responseTime,
                                  EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)

setResponseTime_Term

public void setResponseTime_Term(Long responseTime)

setResponseTime_Term

public void setResponseTime_Term(Long responseTime,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)

setResponseTime_NotEqual

public void setResponseTime_NotEqual(Long responseTime)

setResponseTime_NotTerm

public void setResponseTime_NotTerm(Long responseTime)

setResponseTime_NotEqual

public void setResponseTime_NotEqual(Long responseTime,
                                     EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)

setResponseTime_NotTerm

public void setResponseTime_NotTerm(Long responseTime,
                                    EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)

setResponseTime_Terms

public void setResponseTime_Terms(Collection<Long> responseTimeList)

setResponseTime_Terms

public void setResponseTime_Terms(Collection<Long> responseTimeList,
                                  EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)

setResponseTime_InScope

public void setResponseTime_InScope(Collection<Long> responseTimeList)

setResponseTime_InScope

public void setResponseTime_InScope(Collection<Long> responseTimeList,
                                    EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)

setResponseTime_Match

public void setResponseTime_Match(Long responseTime)

setResponseTime_Match

public void setResponseTime_Match(Long responseTime,
                                  EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)

setResponseTime_MatchPhrase

public void setResponseTime_MatchPhrase(Long responseTime)

setResponseTime_MatchPhrase

public void setResponseTime_MatchPhrase(Long responseTime,
                                        EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhraseQueryBuilder> opLambda)

setResponseTime_MatchPhrasePrefix

public void setResponseTime_MatchPhrasePrefix(Long responseTime)

setResponseTime_MatchPhrasePrefix

public void setResponseTime_MatchPhrasePrefix(Long responseTime,
                                              EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhrasePrefixQueryBuilder> opLambda)

setResponseTime_Fuzzy

public void setResponseTime_Fuzzy(Long responseTime)

setResponseTime_Fuzzy

public void setResponseTime_Fuzzy(Long responseTime,
                                  EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)

setResponseTime_GreaterThan

public void setResponseTime_GreaterThan(Long responseTime)

setResponseTime_GreaterThan

public void setResponseTime_GreaterThan(Long responseTime,
                                        EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setResponseTime_LessThan

public void setResponseTime_LessThan(Long responseTime)

setResponseTime_LessThan

public void setResponseTime_LessThan(Long responseTime,
                                     EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setResponseTime_GreaterEqual

public void setResponseTime_GreaterEqual(Long responseTime)

setResponseTime_GreaterEqual

public void setResponseTime_GreaterEqual(Long responseTime,
                                         EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setResponseTime_LessEqual

public void setResponseTime_LessEqual(Long responseTime)

setResponseTime_LessEqual

public void setResponseTime_LessEqual(Long responseTime,
                                      EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setResponseTime_Exists
```
public void setResponseTime_Exists()
```

setResponseTime_Exists

public void setResponseTime_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.ExistsQueryBuilder> opLambda)

setResponseTime_CommonTerms

public void setResponseTime_CommonTerms(Long responseTime)

setResponseTime_CommonTerms

public void setResponseTime_CommonTerms(Long responseTime,
                                        EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.CommonTermsQueryBuilder> opLambda)

addOrderBy_ResponseTime_Asc

public BsSearchLogCQ addOrderBy_ResponseTime_Asc()

addOrderBy_ResponseTime_Desc

public BsSearchLogCQ addOrderBy_ResponseTime_Desc()

setQueryTime_Equal

public void setQueryTime_Equal(Long queryTime)

setQueryTime_Equal

public void setQueryTime_Equal(Long queryTime,
                               EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)

setQueryTime_Term

public void setQueryTime_Term(Long queryTime)

setQueryTime_Term

public void setQueryTime_Term(Long queryTime,
                              EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)

setQueryTime_NotEqual

public void setQueryTime_NotEqual(Long queryTime)

setQueryTime_NotTerm

public void setQueryTime_NotTerm(Long queryTime)

setQueryTime_NotEqual

public void setQueryTime_NotEqual(Long queryTime,
                                  EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)

setQueryTime_NotTerm

public void setQueryTime_NotTerm(Long queryTime,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)

setQueryTime_Terms

public void setQueryTime_Terms(Collection<Long> queryTimeList)

setQueryTime_Terms

public void setQueryTime_Terms(Collection<Long> queryTimeList,
                               EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)

setQueryTime_InScope

public void setQueryTime_InScope(Collection<Long> queryTimeList)

setQueryTime_InScope

public void setQueryTime_InScope(Collection<Long> queryTimeList,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)

setQueryTime_Match

public void setQueryTime_Match(Long queryTime)

setQueryTime_Match

public void setQueryTime_Match(Long queryTime,
                               EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)

setQueryTime_MatchPhrase

public void setQueryTime_MatchPhrase(Long queryTime)

setQueryTime_MatchPhrase

public void setQueryTime_MatchPhrase(Long queryTime,
                                     EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhraseQueryBuilder> opLambda)

setQueryTime_MatchPhrasePrefix

public void setQueryTime_MatchPhrasePrefix(Long queryTime)

setQueryTime_MatchPhrasePrefix

public void setQueryTime_MatchPhrasePrefix(Long queryTime,
                                           EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhrasePrefixQueryBuilder> opLambda)

setQueryTime_Fuzzy

public void setQueryTime_Fuzzy(Long queryTime)

setQueryTime_Fuzzy

public void setQueryTime_Fuzzy(Long queryTime,
                               EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)

setQueryTime_GreaterThan

public void setQueryTime_GreaterThan(Long queryTime)

setQueryTime_GreaterThan

public void setQueryTime_GreaterThan(Long queryTime,
                                     EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setQueryTime_LessThan

public void setQueryTime_LessThan(Long queryTime)

setQueryTime_LessThan

public void setQueryTime_LessThan(Long queryTime,
                                  EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setQueryTime_GreaterEqual

public void setQueryTime_GreaterEqual(Long queryTime)

setQueryTime_GreaterEqual

public void setQueryTime_GreaterEqual(Long queryTime,
                                      EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setQueryTime_LessEqual

public void setQueryTime_LessEqual(Long queryTime)

setQueryTime_LessEqual

public void setQueryTime_LessEqual(Long queryTime,
                                   EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setQueryTime_Exists
```
public void setQueryTime_Exists()
```

setQueryTime_Exists

public void setQueryTime_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.ExistsQueryBuilder> opLambda)

setQueryTime_CommonTerms

public void setQueryTime_CommonTerms(Long queryTime)

setQueryTime_CommonTerms

public void setQueryTime_CommonTerms(Long queryTime,
                                     EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.CommonTermsQueryBuilder> opLambda)

addOrderBy_QueryTime_Asc

public BsSearchLogCQ addOrderBy_QueryTime_Asc()

addOrderBy_QueryTime_Desc

public BsSearchLogCQ addOrderBy_QueryTime_Desc()

setSearchWord_Equal

public void setSearchWord_Equal(String searchWord)

setSearchWord_Equal

public void setSearchWord_Equal(String searchWord,
                                EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)

setSearchWord_Term

public void setSearchWord_Term(String searchWord)

setSearchWord_Term

public void setSearchWord_Term(String searchWord,
                               EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)

setSearchWord_NotEqual

public void setSearchWord_NotEqual(String searchWord)

setSearchWord_NotTerm

public void setSearchWord_NotTerm(String searchWord)

setSearchWord_NotEqual

public void setSearchWord_NotEqual(String searchWord,
                                   EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)

setSearchWord_NotTerm

public void setSearchWord_NotTerm(String searchWord,
                                  EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)

setSearchWord_Terms

public void setSearchWord_Terms(Collection<String> searchWordList)

setSearchWord_Terms

public void setSearchWord_Terms(Collection<String> searchWordList,
                                EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)

setSearchWord_InScope

public void setSearchWord_InScope(Collection<String> searchWordList)

setSearchWord_InScope

public void setSearchWord_InScope(Collection<String> searchWordList,
                                  EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)

setSearchWord_Match

public void setSearchWord_Match(String searchWord)

setSearchWord_Match

public void setSearchWord_Match(String searchWord,
                                EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)

setSearchWord_MatchPhrase

public void setSearchWord_MatchPhrase(String searchWord)

setSearchWord_MatchPhrase

public void setSearchWord_MatchPhrase(String searchWord,
                                      EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhraseQueryBuilder> opLambda)

setSearchWord_MatchPhrasePrefix

public void setSearchWord_MatchPhrasePrefix(String searchWord)

setSearchWord_MatchPhrasePrefix

public void setSearchWord_MatchPhrasePrefix(String searchWord,
                                            EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhrasePrefixQueryBuilder> opLambda)

setSearchWord_Fuzzy

public void setSearchWord_Fuzzy(String searchWord)

setSearchWord_Fuzzy

public void setSearchWord_Fuzzy(String searchWord,
                                EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)

setSearchWord_Prefix

public void setSearchWord_Prefix(String searchWord)

setSearchWord_Prefix

public void setSearchWord_Prefix(String searchWord,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.PrefixQueryBuilder> opLambda)

setSearchWord_Wildcard

public void setSearchWord_Wildcard(String searchWord)

setSearchWord_Wildcard

public void setSearchWord_Wildcard(String searchWord,
                                   EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.WildcardQueryBuilder> opLambda)

setSearchWord_Regexp

public void setSearchWord_Regexp(String searchWord)

setSearchWord_Regexp

public void setSearchWord_Regexp(String searchWord,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RegexpQueryBuilder> opLambda)

setSearchWord_SpanTerm

public void setSearchWord_SpanTerm(String searchWord)

setSearchWord_SpanTerm

public void setSearchWord_SpanTerm(String searchWord,
                                   EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.SpanTermQueryBuilder> opLambda)

setSearchWord_GreaterThan

public void setSearchWord_GreaterThan(String searchWord)

setSearchWord_GreaterThan

public void setSearchWord_GreaterThan(String searchWord,
                                      EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setSearchWord_LessThan

public void setSearchWord_LessThan(String searchWord)

setSearchWord_LessThan

public void setSearchWord_LessThan(String searchWord,
                                   EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setSearchWord_GreaterEqual

public void setSearchWord_GreaterEqual(String searchWord)

setSearchWord_GreaterEqual

public void setSearchWord_GreaterEqual(String searchWord,
                                       EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setSearchWord_LessEqual

public void setSearchWord_LessEqual(String searchWord)

setSearchWord_LessEqual

public void setSearchWord_LessEqual(String searchWord,
                                    EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setSearchWord_Exists
```
public void setSearchWord_Exists()
```

setSearchWord_Exists

public void setSearchWord_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.ExistsQueryBuilder> opLambda)

setSearchWord_CommonTerms

public void setSearchWord_CommonTerms(String searchWord)

setSearchWord_CommonTerms

public void setSearchWord_CommonTerms(String searchWord,
                                      EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.CommonTermsQueryBuilder> opLambda)

addOrderBy_SearchWord_Asc

public BsSearchLogCQ addOrderBy_SearchWord_Asc()

addOrderBy_SearchWord_Desc

public BsSearchLogCQ addOrderBy_SearchWord_Desc()

setUserAgent_Equal

public void setUserAgent_Equal(String userAgent)

setUserAgent_Equal

public void setUserAgent_Equal(String userAgent,
                               EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)

setUserAgent_Term

public void setUserAgent_Term(String userAgent)

setUserAgent_Term

public void setUserAgent_Term(String userAgent,
                              EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)

setUserAgent_NotEqual

public void setUserAgent_NotEqual(String userAgent)

setUserAgent_NotTerm

public void setUserAgent_NotTerm(String userAgent)

setUserAgent_NotEqual

public void setUserAgent_NotEqual(String userAgent,
                                  EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)

setUserAgent_NotTerm

public void setUserAgent_NotTerm(String userAgent,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)

setUserAgent_Terms

public void setUserAgent_Terms(Collection<String> userAgentList)

setUserAgent_Terms

public void setUserAgent_Terms(Collection<String> userAgentList,
                               EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)

setUserAgent_InScope

public void setUserAgent_InScope(Collection<String> userAgentList)

setUserAgent_InScope

public void setUserAgent_InScope(Collection<String> userAgentList,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)

setUserAgent_Match

public void setUserAgent_Match(String userAgent)

setUserAgent_Match

public void setUserAgent_Match(String userAgent,
                               EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)

setUserAgent_MatchPhrase

public void setUserAgent_MatchPhrase(String userAgent)

setUserAgent_MatchPhrase

public void setUserAgent_MatchPhrase(String userAgent,
                                     EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhraseQueryBuilder> opLambda)

setUserAgent_MatchPhrasePrefix

public void setUserAgent_MatchPhrasePrefix(String userAgent)

setUserAgent_MatchPhrasePrefix

public void setUserAgent_MatchPhrasePrefix(String userAgent,
                                           EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhrasePrefixQueryBuilder> opLambda)

setUserAgent_Fuzzy

public void setUserAgent_Fuzzy(String userAgent)

setUserAgent_Fuzzy

public void setUserAgent_Fuzzy(String userAgent,
                               EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)

setUserAgent_Prefix

public void setUserAgent_Prefix(String userAgent)

setUserAgent_Prefix

public void setUserAgent_Prefix(String userAgent,
                                EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.PrefixQueryBuilder> opLambda)

setUserAgent_Wildcard

public void setUserAgent_Wildcard(String userAgent)

setUserAgent_Wildcard

public void setUserAgent_Wildcard(String userAgent,
                                  EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.WildcardQueryBuilder> opLambda)

setUserAgent_Regexp

public void setUserAgent_Regexp(String userAgent)

setUserAgent_Regexp

public void setUserAgent_Regexp(String userAgent,
                                EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RegexpQueryBuilder> opLambda)

setUserAgent_SpanTerm

public void setUserAgent_SpanTerm(String userAgent)

setUserAgent_SpanTerm

public void setUserAgent_SpanTerm(String userAgent,
                                  EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.SpanTermQueryBuilder> opLambda)

setUserAgent_GreaterThan

public void setUserAgent_GreaterThan(String userAgent)

setUserAgent_GreaterThan

public void setUserAgent_GreaterThan(String userAgent,
                                     EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setUserAgent_LessThan

public void setUserAgent_LessThan(String userAgent)

setUserAgent_LessThan

public void setUserAgent_LessThan(String userAgent,
                                  EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setUserAgent_GreaterEqual

public void setUserAgent_GreaterEqual(String userAgent)

setUserAgent_GreaterEqual

public void setUserAgent_GreaterEqual(String userAgent,
                                      EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setUserAgent_LessEqual

public void setUserAgent_LessEqual(String userAgent)

setUserAgent_LessEqual

public void setUserAgent_LessEqual(String userAgent,
                                   EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setUserAgent_Exists
```
public void setUserAgent_Exists()
```

setUserAgent_Exists

public void setUserAgent_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.ExistsQueryBuilder> opLambda)

setUserAgent_CommonTerms

public void setUserAgent_CommonTerms(String userAgent)

setUserAgent_CommonTerms

public void setUserAgent_CommonTerms(String userAgent,
                                     EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.CommonTermsQueryBuilder> opLambda)

addOrderBy_UserAgent_Asc

public BsSearchLogCQ addOrderBy_UserAgent_Asc()

addOrderBy_UserAgent_Desc

public BsSearchLogCQ addOrderBy_UserAgent_Desc()

setUserInfoId_Equal

public void setUserInfoId_Equal(String userInfoId)

setUserInfoId_Equal

public void setUserInfoId_Equal(String userInfoId,
                                EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)

setUserInfoId_Term

public void setUserInfoId_Term(String userInfoId)

setUserInfoId_Term

public void setUserInfoId_Term(String userInfoId,
                               EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)

setUserInfoId_NotEqual

public void setUserInfoId_NotEqual(String userInfoId)

setUserInfoId_NotTerm

public void setUserInfoId_NotTerm(String userInfoId)

setUserInfoId_NotEqual

public void setUserInfoId_NotEqual(String userInfoId,
                                   EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)

setUserInfoId_NotTerm

public void setUserInfoId_NotTerm(String userInfoId,
                                  EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)

setUserInfoId_Terms

public void setUserInfoId_Terms(Collection<String> userInfoIdList)

setUserInfoId_Terms

public void setUserInfoId_Terms(Collection<String> userInfoIdList,
                                EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)

setUserInfoId_InScope

public void setUserInfoId_InScope(Collection<String> userInfoIdList)

setUserInfoId_InScope

public void setUserInfoId_InScope(Collection<String> userInfoIdList,
                                  EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)

setUserInfoId_Match

public void setUserInfoId_Match(String userInfoId)

setUserInfoId_Match

public void setUserInfoId_Match(String userInfoId,
                                EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)

setUserInfoId_MatchPhrase

public void setUserInfoId_MatchPhrase(String userInfoId)

setUserInfoId_MatchPhrase

public void setUserInfoId_MatchPhrase(String userInfoId,
                                      EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhraseQueryBuilder> opLambda)

setUserInfoId_MatchPhrasePrefix

public void setUserInfoId_MatchPhrasePrefix(String userInfoId)

setUserInfoId_MatchPhrasePrefix

public void setUserInfoId_MatchPhrasePrefix(String userInfoId,
                                            EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhrasePrefixQueryBuilder> opLambda)

setUserInfoId_Fuzzy

public void setUserInfoId_Fuzzy(String userInfoId)

setUserInfoId_Fuzzy

public void setUserInfoId_Fuzzy(String userInfoId,
                                EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)

setUserInfoId_Prefix

public void setUserInfoId_Prefix(String userInfoId)

setUserInfoId_Prefix

public void setUserInfoId_Prefix(String userInfoId,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.PrefixQueryBuilder> opLambda)

setUserInfoId_Wildcard

public void setUserInfoId_Wildcard(String userInfoId)

setUserInfoId_Wildcard

public void setUserInfoId_Wildcard(String userInfoId,
                                   EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.WildcardQueryBuilder> opLambda)

setUserInfoId_Regexp

public void setUserInfoId_Regexp(String userInfoId)

setUserInfoId_Regexp

public void setUserInfoId_Regexp(String userInfoId,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RegexpQueryBuilder> opLambda)

setUserInfoId_SpanTerm

public void setUserInfoId_SpanTerm(String userInfoId)

setUserInfoId_SpanTerm

public void setUserInfoId_SpanTerm(String userInfoId,
                                   EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.SpanTermQueryBuilder> opLambda)

setUserInfoId_GreaterThan

public void setUserInfoId_GreaterThan(String userInfoId)

setUserInfoId_GreaterThan

public void setUserInfoId_GreaterThan(String userInfoId,
                                      EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setUserInfoId_LessThan

public void setUserInfoId_LessThan(String userInfoId)

setUserInfoId_LessThan

public void setUserInfoId_LessThan(String userInfoId,
                                   EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setUserInfoId_GreaterEqual

public void setUserInfoId_GreaterEqual(String userInfoId)

setUserInfoId_GreaterEqual

public void setUserInfoId_GreaterEqual(String userInfoId,
                                       EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setUserInfoId_LessEqual

public void setUserInfoId_LessEqual(String userInfoId)

setUserInfoId_LessEqual

public void setUserInfoId_LessEqual(String userInfoId,
                                    EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setUserInfoId_Exists
```
public void setUserInfoId_Exists()
```

setUserInfoId_Exists

public void setUserInfoId_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.ExistsQueryBuilder> opLambda)

setUserInfoId_CommonTerms

public void setUserInfoId_CommonTerms(String userInfoId)

setUserInfoId_CommonTerms

public void setUserInfoId_CommonTerms(String userInfoId,
                                      EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.CommonTermsQueryBuilder> opLambda)

addOrderBy_UserInfoId_Asc

public BsSearchLogCQ addOrderBy_UserInfoId_Asc()

addOrderBy_UserInfoId_Desc

public BsSearchLogCQ addOrderBy_UserInfoId_Desc()

setUserSessionId_Equal

public void setUserSessionId_Equal(String userSessionId)

setUserSessionId_Equal

public void setUserSessionId_Equal(String userSessionId,
                                   EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)

setUserSessionId_Term

public void setUserSessionId_Term(String userSessionId)

setUserSessionId_Term

public void setUserSessionId_Term(String userSessionId,
                                  EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)

setUserSessionId_NotEqual

public void setUserSessionId_NotEqual(String userSessionId)

setUserSessionId_NotTerm

public void setUserSessionId_NotTerm(String userSessionId)

setUserSessionId_NotEqual

public void setUserSessionId_NotEqual(String userSessionId,
                                      EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)

setUserSessionId_NotTerm

public void setUserSessionId_NotTerm(String userSessionId,
                                     EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)

setUserSessionId_Terms

public void setUserSessionId_Terms(Collection<String> userSessionIdList)

setUserSessionId_Terms

public void setUserSessionId_Terms(Collection<String> userSessionIdList,
                                   EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)

setUserSessionId_InScope

public void setUserSessionId_InScope(Collection<String> userSessionIdList)

setUserSessionId_InScope

public void setUserSessionId_InScope(Collection<String> userSessionIdList,
                                     EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)

setUserSessionId_Match

public void setUserSessionId_Match(String userSessionId)

setUserSessionId_Match

public void setUserSessionId_Match(String userSessionId,
                                   EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)

setUserSessionId_MatchPhrase

public void setUserSessionId_MatchPhrase(String userSessionId)

setUserSessionId_MatchPhrase

public void setUserSessionId_MatchPhrase(String userSessionId,
                                         EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhraseQueryBuilder> opLambda)

setUserSessionId_MatchPhrasePrefix

public void setUserSessionId_MatchPhrasePrefix(String userSessionId)

setUserSessionId_MatchPhrasePrefix

public void setUserSessionId_MatchPhrasePrefix(String userSessionId,
                                               EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhrasePrefixQueryBuilder> opLambda)

setUserSessionId_Fuzzy

public void setUserSessionId_Fuzzy(String userSessionId)

setUserSessionId_Fuzzy

public void setUserSessionId_Fuzzy(String userSessionId,
                                   EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)

setUserSessionId_Prefix

public void setUserSessionId_Prefix(String userSessionId)

setUserSessionId_Prefix

public void setUserSessionId_Prefix(String userSessionId,
                                    EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.PrefixQueryBuilder> opLambda)

setUserSessionId_Wildcard

public void setUserSessionId_Wildcard(String userSessionId)

setUserSessionId_Wildcard

public void setUserSessionId_Wildcard(String userSessionId,
                                      EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.WildcardQueryBuilder> opLambda)

setUserSessionId_Regexp

public void setUserSessionId_Regexp(String userSessionId)

setUserSessionId_Regexp

public void setUserSessionId_Regexp(String userSessionId,
                                    EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RegexpQueryBuilder> opLambda)

setUserSessionId_SpanTerm

public void setUserSessionId_SpanTerm(String userSessionId)

setUserSessionId_SpanTerm

public void setUserSessionId_SpanTerm(String userSessionId,
                                      EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.SpanTermQueryBuilder> opLambda)

setUserSessionId_GreaterThan

public void setUserSessionId_GreaterThan(String userSessionId)

setUserSessionId_GreaterThan

public void setUserSessionId_GreaterThan(String userSessionId,
                                         EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setUserSessionId_LessThan

public void setUserSessionId_LessThan(String userSessionId)

setUserSessionId_LessThan

public void setUserSessionId_LessThan(String userSessionId,
                                      EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setUserSessionId_GreaterEqual

public void setUserSessionId_GreaterEqual(String userSessionId)

setUserSessionId_GreaterEqual

public void setUserSessionId_GreaterEqual(String userSessionId,
                                          EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setUserSessionId_LessEqual

public void setUserSessionId_LessEqual(String userSessionId)

setUserSessionId_LessEqual

public void setUserSessionId_LessEqual(String userSessionId,
                                       EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setUserSessionId_Exists
```
public void setUserSessionId_Exists()
```

setUserSessionId_Exists

public void setUserSessionId_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.ExistsQueryBuilder> opLambda)

setUserSessionId_CommonTerms

public void setUserSessionId_CommonTerms(String userSessionId)

setUserSessionId_CommonTerms

public void setUserSessionId_CommonTerms(String userSessionId,
                                         EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.CommonTermsQueryBuilder> opLambda)

addOrderBy_UserSessionId_Asc

public BsSearchLogCQ addOrderBy_UserSessionId_Asc()

addOrderBy_UserSessionId_Desc

public BsSearchLogCQ addOrderBy_UserSessionId_Desc()

setLanguages_Equal

public void setLanguages_Equal(String languages)

setLanguages_Equal

public void setLanguages_Equal(String languages,
                               EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)

setLanguages_Term

public void setLanguages_Term(String languages)

setLanguages_Term

public void setLanguages_Term(String languages,
                              EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)

setLanguages_NotEqual

public void setLanguages_NotEqual(String languages)

setLanguages_NotTerm

public void setLanguages_NotTerm(String languages)

setLanguages_NotEqual

public void setLanguages_NotEqual(String languages,
                                  EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)

setLanguages_NotTerm

public void setLanguages_NotTerm(String languages,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)

setLanguages_Terms

public void setLanguages_Terms(Collection<String> languagesList)

setLanguages_Terms

public void setLanguages_Terms(Collection<String> languagesList,
                               EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)

setLanguages_InScope

public void setLanguages_InScope(Collection<String> languagesList)

setLanguages_InScope

public void setLanguages_InScope(Collection<String> languagesList,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)

setLanguages_Match

public void setLanguages_Match(String languages)

setLanguages_Match

public void setLanguages_Match(String languages,
                               EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)

setLanguages_MatchPhrase

public void setLanguages_MatchPhrase(String languages)

setLanguages_MatchPhrase

public void setLanguages_MatchPhrase(String languages,
                                     EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhraseQueryBuilder> opLambda)

setLanguages_MatchPhrasePrefix

public void setLanguages_MatchPhrasePrefix(String languages)

setLanguages_MatchPhrasePrefix

public void setLanguages_MatchPhrasePrefix(String languages,
                                           EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhrasePrefixQueryBuilder> opLambda)

setLanguages_Fuzzy

public void setLanguages_Fuzzy(String languages)

setLanguages_Fuzzy

public void setLanguages_Fuzzy(String languages,
                               EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)

setLanguages_Prefix

public void setLanguages_Prefix(String languages)

setLanguages_Prefix

public void setLanguages_Prefix(String languages,
                                EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.PrefixQueryBuilder> opLambda)

setLanguages_Wildcard

public void setLanguages_Wildcard(String languages)

setLanguages_Wildcard

public void setLanguages_Wildcard(String languages,
                                  EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.WildcardQueryBuilder> opLambda)

setLanguages_Regexp

public void setLanguages_Regexp(String languages)

setLanguages_Regexp

public void setLanguages_Regexp(String languages,
                                EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RegexpQueryBuilder> opLambda)

setLanguages_SpanTerm

public void setLanguages_SpanTerm(String languages)

setLanguages_SpanTerm

public void setLanguages_SpanTerm(String languages,
                                  EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.SpanTermQueryBuilder> opLambda)

setLanguages_GreaterThan

public void setLanguages_GreaterThan(String languages)

setLanguages_GreaterThan

public void setLanguages_GreaterThan(String languages,
                                     EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setLanguages_LessThan

public void setLanguages_LessThan(String languages)

setLanguages_LessThan

public void setLanguages_LessThan(String languages,
                                  EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setLanguages_GreaterEqual

public void setLanguages_GreaterEqual(String languages)

setLanguages_GreaterEqual

public void setLanguages_GreaterEqual(String languages,
                                      EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setLanguages_LessEqual

public void setLanguages_LessEqual(String languages)

setLanguages_LessEqual

public void setLanguages_LessEqual(String languages,
                                   EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setLanguages_Exists
```
public void setLanguages_Exists()
```

setLanguages_Exists

public void setLanguages_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.ExistsQueryBuilder> opLambda)

setLanguages_CommonTerms

public void setLanguages_CommonTerms(String languages)

setLanguages_CommonTerms

public void setLanguages_CommonTerms(String languages,
                                     EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.CommonTermsQueryBuilder> opLambda)

addOrderBy_Languages_Asc

public BsSearchLogCQ addOrderBy_Languages_Asc()

addOrderBy_Languages_Desc

public BsSearchLogCQ addOrderBy_Languages_Desc()

setVirtualHost_Equal

public void setVirtualHost_Equal(String virtualHost)

setVirtualHost_Equal

public void setVirtualHost_Equal(String virtualHost,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)

setVirtualHost_Term

public void setVirtualHost_Term(String virtualHost)

setVirtualHost_Term

public void setVirtualHost_Term(String virtualHost,
                                EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermQueryBuilder> opLambda)

setVirtualHost_NotEqual

public void setVirtualHost_NotEqual(String virtualHost)

setVirtualHost_NotTerm

public void setVirtualHost_NotTerm(String virtualHost)

setVirtualHost_NotEqual

public void setVirtualHost_NotEqual(String virtualHost,
                                    EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)

setVirtualHost_NotTerm

public void setVirtualHost_NotTerm(String virtualHost,
                                   EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.BoolQueryBuilder> opLambda)

setVirtualHost_Terms

public void setVirtualHost_Terms(Collection<String> virtualHostList)

setVirtualHost_Terms

public void setVirtualHost_Terms(Collection<String> virtualHostList,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)

setVirtualHost_InScope

public void setVirtualHost_InScope(Collection<String> virtualHostList)

setVirtualHost_InScope

public void setVirtualHost_InScope(Collection<String> virtualHostList,
                                   EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.TermsQueryBuilder> opLambda)

setVirtualHost_Match

public void setVirtualHost_Match(String virtualHost)

setVirtualHost_Match

public void setVirtualHost_Match(String virtualHost,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)

setVirtualHost_MatchPhrase

public void setVirtualHost_MatchPhrase(String virtualHost)

setVirtualHost_MatchPhrase

public void setVirtualHost_MatchPhrase(String virtualHost,
                                       EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhraseQueryBuilder> opLambda)

setVirtualHost_MatchPhrasePrefix

public void setVirtualHost_MatchPhrasePrefix(String virtualHost)

setVirtualHost_MatchPhrasePrefix

public void setVirtualHost_MatchPhrasePrefix(String virtualHost,
                                             EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchPhrasePrefixQueryBuilder> opLambda)

setVirtualHost_Fuzzy

public void setVirtualHost_Fuzzy(String virtualHost)

setVirtualHost_Fuzzy

public void setVirtualHost_Fuzzy(String virtualHost,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.MatchQueryBuilder> opLambda)

setVirtualHost_Prefix

public void setVirtualHost_Prefix(String virtualHost)

setVirtualHost_Prefix

public void setVirtualHost_Prefix(String virtualHost,
                                  EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.PrefixQueryBuilder> opLambda)

setVirtualHost_Wildcard

public void setVirtualHost_Wildcard(String virtualHost)

setVirtualHost_Wildcard

public void setVirtualHost_Wildcard(String virtualHost,
                                    EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.WildcardQueryBuilder> opLambda)

setVirtualHost_Regexp

public void setVirtualHost_Regexp(String virtualHost)

setVirtualHost_Regexp

public void setVirtualHost_Regexp(String virtualHost,
                                  EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RegexpQueryBuilder> opLambda)

setVirtualHost_SpanTerm

public void setVirtualHost_SpanTerm(String virtualHost)

setVirtualHost_SpanTerm

public void setVirtualHost_SpanTerm(String virtualHost,
                                    EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.SpanTermQueryBuilder> opLambda)

setVirtualHost_GreaterThan

public void setVirtualHost_GreaterThan(String virtualHost)

setVirtualHost_GreaterThan

public void setVirtualHost_GreaterThan(String virtualHost,
                                       EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setVirtualHost_LessThan

public void setVirtualHost_LessThan(String virtualHost)

setVirtualHost_LessThan

public void setVirtualHost_LessThan(String virtualHost,
                                    EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setVirtualHost_GreaterEqual

public void setVirtualHost_GreaterEqual(String virtualHost)

setVirtualHost_GreaterEqual

public void setVirtualHost_GreaterEqual(String virtualHost,
                                        EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setVirtualHost_LessEqual

public void setVirtualHost_LessEqual(String virtualHost)

setVirtualHost_LessEqual

public void setVirtualHost_LessEqual(String virtualHost,
                                     EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.RangeQueryBuilder> opLambda)

setVirtualHost_Exists
```
public void setVirtualHost_Exists()
```

setVirtualHost_Exists

public void setVirtualHost_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.ExistsQueryBuilder> opLambda)

setVirtualHost_CommonTerms

public void setVirtualHost_CommonTerms(String virtualHost)

setVirtualHost_CommonTerms

public void setVirtualHost_CommonTerms(String virtualHost,
                                       EsAbstractConditionQuery.ConditionOptionCall<org.elasticsearch.index.query.CommonTermsQueryBuilder> opLambda)

addOrderBy_VirtualHost_Asc

public BsSearchLogCQ addOrderBy_VirtualHost_Asc()

addOrderBy_VirtualHost_Desc

public BsSearchLogCQ addOrderBy_VirtualHost_Desc()

Class BsSearchLogCQ

Nested Class Summary

Nested classes/interfaces inherited from class org.codelibs.fess.es.log.allcommon.EsAbstractConditionQuery

Field Summary

Fields inherited from class org.codelibs.fess.es.log.allcommon.EsAbstractConditionQuery

Constructor Summary

Method Summary

Methods inherited from class org.codelibs.fess.es.log.allcommon.EsAbstractConditionQuery

Methods inherited from class java.lang.Object

Field Detail

suppressUnusedImportLocalDateTime

Constructor Detail

BsSearchLogCQ

Method Detail

asTableDbName

xgetAliasName

functionScore

filtered

filtered

not

not

bool

bool

setId_Equal

setId_Equal

setId_Term

setId_Term

setId_NotEqual

setId_NotTerm

setId_NotEqual

setId_NotTerm

setId_Terms

setId_Terms

setId_InScope

setId_InScope

addOrderBy_Id_Asc

addOrderBy_Id_Desc

setAccessType_Equal

setAccessType_Equal

setAccessType_Term

setAccessType_Term

setAccessType_NotEqual

setAccessType_NotTerm

setAccessType_NotEqual

setAccessType_NotTerm

setAccessType_Terms

setAccessType_Terms

setAccessType_InScope

setAccessType_InScope

setAccessType_Match

setAccessType_Match

setAccessType_MatchPhrase

setAccessType_MatchPhrase

setAccessType_MatchPhrasePrefix

setAccessType_MatchPhrasePrefix

setAccessType_Fuzzy

setAccessType_Fuzzy

setAccessType_Prefix

setAccessType_Prefix

setAccessType_Wildcard

setAccessType_Wildcard

setAccessType_Regexp

setAccessType_Regexp

setAccessType_SpanTerm

setAccessType_SpanTerm

setAccessType_GreaterThan

setAccessType_GreaterThan

setAccessType_LessThan

setAccessType_LessThan

setAccessType_GreaterEqual

setAccessType_GreaterEqual

setAccessType_LessEqual

setAccessType_LessEqual

setAccessType_Exists

setAccessType_Exists

setAccessType_CommonTerms

setAccessType_CommonTerms

addOrderBy_AccessType_Asc

addOrderBy_AccessType_Desc

setUser_Equal