java.lang.Object
- org.codelibs.fess.es.config.allcommon.EsAbstractConditionQuery
- - org.codelibs.fess.es.config.cbean.cq.bs.BsWebConfigCQ

All Implemented Interfaces:

org.dbflute.cbean.ConditionQuery

Direct Known Subclasses:

WebConfigCQ
```
public abstract class BsWebConfigCQ
extends EsAbstractConditionQuery
```
Author:

ESFlute (using FreeGen)

Nested Class Summary
- Nested classes/interfaces inherited from class org.codelibs.fess.es.config.allcommon.EsAbstractConditionQuery
  EsAbstractConditionQuery.BoolCall<CQ extends EsAbstractConditionQuery>, EsAbstractConditionQuery.ConditionOptionCall<OP extends org.codelibs.fesen.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 Description

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

Constructor Summary

Constructors
Constructor Description

BsWebConfigCQ()

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`BsWebConfigCQ`	`addOrderBy_Available_Asc()`
`BsWebConfigCQ`	`addOrderBy_Available_Desc()`
`BsWebConfigCQ`	`addOrderBy_Boost_Asc()`
`BsWebConfigCQ`	`addOrderBy_Boost_Desc()`
`BsWebConfigCQ`	`addOrderBy_ConfigParameter_Asc()`
`BsWebConfigCQ`	`addOrderBy_ConfigParameter_Desc()`
`BsWebConfigCQ`	`addOrderBy_CreatedBy_Asc()`
`BsWebConfigCQ`	`addOrderBy_CreatedBy_Desc()`
`BsWebConfigCQ`	`addOrderBy_CreatedTime_Asc()`
`BsWebConfigCQ`	`addOrderBy_CreatedTime_Desc()`
`BsWebConfigCQ`	`addOrderBy_Depth_Asc()`
`BsWebConfigCQ`	`addOrderBy_Depth_Desc()`
`BsWebConfigCQ`	`addOrderBy_ExcludedDocUrls_Asc()`
`BsWebConfigCQ`	`addOrderBy_ExcludedDocUrls_Desc()`
`BsWebConfigCQ`	`addOrderBy_ExcludedUrls_Asc()`
`BsWebConfigCQ`	`addOrderBy_ExcludedUrls_Desc()`
`BsWebConfigCQ`	`addOrderBy_Id_Asc()`
`BsWebConfigCQ`	`addOrderBy_Id_Desc()`
`BsWebConfigCQ`	`addOrderBy_IncludedDocUrls_Asc()`
`BsWebConfigCQ`	`addOrderBy_IncludedDocUrls_Desc()`
`BsWebConfigCQ`	`addOrderBy_IncludedUrls_Asc()`
`BsWebConfigCQ`	`addOrderBy_IncludedUrls_Desc()`
`BsWebConfigCQ`	`addOrderBy_IntervalTime_Asc()`
`BsWebConfigCQ`	`addOrderBy_IntervalTime_Desc()`
`BsWebConfigCQ`	`addOrderBy_MaxAccessCount_Asc()`
`BsWebConfigCQ`	`addOrderBy_MaxAccessCount_Desc()`
`BsWebConfigCQ`	`addOrderBy_Name_Asc()`
`BsWebConfigCQ`	`addOrderBy_Name_Desc()`
`BsWebConfigCQ`	`addOrderBy_NumOfThread_Asc()`
`BsWebConfigCQ`	`addOrderBy_NumOfThread_Desc()`
`BsWebConfigCQ`	`addOrderBy_Permissions_Asc()`
`BsWebConfigCQ`	`addOrderBy_Permissions_Desc()`
`BsWebConfigCQ`	`addOrderBy_SortOrder_Asc()`
`BsWebConfigCQ`	`addOrderBy_SortOrder_Desc()`
`BsWebConfigCQ`	`addOrderBy_TimeToLive_Asc()`
`BsWebConfigCQ`	`addOrderBy_TimeToLive_Desc()`
`BsWebConfigCQ`	`addOrderBy_UpdatedBy_Asc()`
`BsWebConfigCQ`	`addOrderBy_UpdatedBy_Desc()`
`BsWebConfigCQ`	`addOrderBy_UpdatedTime_Asc()`
`BsWebConfigCQ`	`addOrderBy_UpdatedTime_Desc()`
`BsWebConfigCQ`	`addOrderBy_Urls_Asc()`
`BsWebConfigCQ`	`addOrderBy_Urls_Desc()`
`BsWebConfigCQ`	`addOrderBy_UserAgent_Asc()`
`BsWebConfigCQ`	`addOrderBy_UserAgent_Desc()`
`BsWebConfigCQ`	`addOrderBy_VirtualHosts_Asc()`
`BsWebConfigCQ`	`addOrderBy_VirtualHosts_Desc()`
`String`	`asTableDbName()`
`void`	`bool(EsAbstractConditionQuery.BoolCall<WebConfigCQ> boolLambda)`
`void`	`bool(EsAbstractConditionQuery.BoolCall<WebConfigCQ> boolLambda, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)`
`void`	`filtered(EsAbstractConditionQuery.FilteredCall<WebConfigCQ,WebConfigCQ> filteredLambda)`
`void`	`filtered(EsAbstractConditionQuery.FilteredCall<WebConfigCQ,WebConfigCQ> filteredLambda, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)`
`void`	`functionScore(EsAbstractConditionQuery.OperatorCall<WebConfigCQ> queryLambda, EsAbstractConditionQuery.ScoreFunctionCall<EsAbstractConditionQuery.ScoreFunctionCreator<WebConfigCQ>> functionsLambda, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.functionscore.FunctionScoreQueryBuilder> opLambda)`
`void`	`not(EsAbstractConditionQuery.OperatorCall<WebConfigCQ> notLambda)`
`void`	`not(EsAbstractConditionQuery.OperatorCall<WebConfigCQ> notLambda, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)`
`void`	`setAvailable_CommonTerms(Boolean available)`
`void`	`setAvailable_CommonTerms(Boolean available, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.CommonTermsQueryBuilder> opLambda)`
`void`	`setAvailable_Equal(Boolean available)`
`void`	`setAvailable_Equal(Boolean available, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)`
`void`	`setAvailable_Exists()`
`void`	`setAvailable_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.ExistsQueryBuilder> opLambda)`
`void`	`setAvailable_Fuzzy(Boolean available)`
`void`	`setAvailable_Fuzzy(Boolean available, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)`
`void`	`setAvailable_GreaterEqual(Boolean available)`
`void`	`setAvailable_GreaterEqual(Boolean available, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setAvailable_GreaterThan(Boolean available)`
`void`	`setAvailable_GreaterThan(Boolean available, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setAvailable_InScope(Collection<Boolean> availableList)`
`void`	`setAvailable_InScope(Collection<Boolean> availableList, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)`
`void`	`setAvailable_LessEqual(Boolean available)`
`void`	`setAvailable_LessEqual(Boolean available, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setAvailable_LessThan(Boolean available)`
`void`	`setAvailable_LessThan(Boolean available, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setAvailable_Match(Boolean available)`
`void`	`setAvailable_Match(Boolean available, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)`
`void`	`setAvailable_MatchPhrase(Boolean available)`
`void`	`setAvailable_MatchPhrase(Boolean available, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhraseQueryBuilder> opLambda)`
`void`	`setAvailable_MatchPhrasePrefix(Boolean available)`
`void`	`setAvailable_MatchPhrasePrefix(Boolean available, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhrasePrefixQueryBuilder> opLambda)`
`void`	`setAvailable_NotEqual(Boolean available)`
`void`	`setAvailable_NotEqual(Boolean available, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)`
`void`	`setAvailable_NotTerm(Boolean available)`
`void`	`setAvailable_NotTerm(Boolean available, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)`
`void`	`setAvailable_Term(Boolean available)`
`void`	`setAvailable_Term(Boolean available, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)`
`void`	`setAvailable_Terms(Collection<Boolean> availableList)`
`void`	`setAvailable_Terms(Collection<Boolean> availableList, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)`
`void`	`setBoost_CommonTerms(Float boost)`
`void`	`setBoost_CommonTerms(Float boost, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.CommonTermsQueryBuilder> opLambda)`
`void`	`setBoost_Equal(Float boost)`
`void`	`setBoost_Equal(Float boost, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)`
`void`	`setBoost_Exists()`
`void`	`setBoost_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.ExistsQueryBuilder> opLambda)`
`void`	`setBoost_Fuzzy(Float boost)`
`void`	`setBoost_Fuzzy(Float boost, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)`
`void`	`setBoost_GreaterEqual(Float boost)`
`void`	`setBoost_GreaterEqual(Float boost, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setBoost_GreaterThan(Float boost)`
`void`	`setBoost_GreaterThan(Float boost, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setBoost_InScope(Collection<Float> boostList)`
`void`	`setBoost_InScope(Collection<Float> boostList, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)`
`void`	`setBoost_LessEqual(Float boost)`
`void`	`setBoost_LessEqual(Float boost, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setBoost_LessThan(Float boost)`
`void`	`setBoost_LessThan(Float boost, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setBoost_Match(Float boost)`
`void`	`setBoost_Match(Float boost, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)`
`void`	`setBoost_MatchPhrase(Float boost)`
`void`	`setBoost_MatchPhrase(Float boost, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhraseQueryBuilder> opLambda)`
`void`	`setBoost_MatchPhrasePrefix(Float boost)`
`void`	`setBoost_MatchPhrasePrefix(Float boost, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhrasePrefixQueryBuilder> opLambda)`
`void`	`setBoost_NotEqual(Float boost)`
`void`	`setBoost_NotEqual(Float boost, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)`
`void`	`setBoost_NotTerm(Float boost)`
`void`	`setBoost_NotTerm(Float boost, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)`
`void`	`setBoost_Term(Float boost)`
`void`	`setBoost_Term(Float boost, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)`
`void`	`setBoost_Terms(Collection<Float> boostList)`
`void`	`setBoost_Terms(Collection<Float> boostList, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)`
`void`	`setConfigParameter_CommonTerms(String configParameter)`
`void`	`setConfigParameter_CommonTerms(String configParameter, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.CommonTermsQueryBuilder> opLambda)`
`void`	`setConfigParameter_Equal(String configParameter)`
`void`	`setConfigParameter_Equal(String configParameter, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)`
`void`	`setConfigParameter_Exists()`
`void`	`setConfigParameter_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.ExistsQueryBuilder> opLambda)`
`void`	`setConfigParameter_Fuzzy(String configParameter)`
`void`	`setConfigParameter_Fuzzy(String configParameter, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)`
`void`	`setConfigParameter_GreaterEqual(String configParameter)`
`void`	`setConfigParameter_GreaterEqual(String configParameter, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setConfigParameter_GreaterThan(String configParameter)`
`void`	`setConfigParameter_GreaterThan(String configParameter, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setConfigParameter_InScope(Collection<String> configParameterList)`
`void`	`setConfigParameter_InScope(Collection<String> configParameterList, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)`
`void`	`setConfigParameter_LessEqual(String configParameter)`
`void`	`setConfigParameter_LessEqual(String configParameter, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setConfigParameter_LessThan(String configParameter)`
`void`	`setConfigParameter_LessThan(String configParameter, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setConfigParameter_Match(String configParameter)`
`void`	`setConfigParameter_Match(String configParameter, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)`
`void`	`setConfigParameter_MatchPhrase(String configParameter)`
`void`	`setConfigParameter_MatchPhrase(String configParameter, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhraseQueryBuilder> opLambda)`
`void`	`setConfigParameter_MatchPhrasePrefix(String configParameter)`
`void`	`setConfigParameter_MatchPhrasePrefix(String configParameter, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhrasePrefixQueryBuilder> opLambda)`
`void`	`setConfigParameter_NotEqual(String configParameter)`
`void`	`setConfigParameter_NotEqual(String configParameter, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)`
`void`	`setConfigParameter_NotTerm(String configParameter)`
`void`	`setConfigParameter_NotTerm(String configParameter, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)`
`void`	`setConfigParameter_Prefix(String configParameter)`
`void`	`setConfigParameter_Prefix(String configParameter, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.PrefixQueryBuilder> opLambda)`
`void`	`setConfigParameter_Regexp(String configParameter)`
`void`	`setConfigParameter_Regexp(String configParameter, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RegexpQueryBuilder> opLambda)`
`void`	`setConfigParameter_SpanTerm(String configParameter)`
`void`	`setConfigParameter_SpanTerm(String configParameter, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.SpanTermQueryBuilder> opLambda)`
`void`	`setConfigParameter_Term(String configParameter)`
`void`	`setConfigParameter_Term(String configParameter, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)`
`void`	`setConfigParameter_Terms(Collection<String> configParameterList)`
`void`	`setConfigParameter_Terms(Collection<String> configParameterList, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)`
`void`	`setConfigParameter_Wildcard(String configParameter)`
`void`	`setConfigParameter_Wildcard(String configParameter, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.WildcardQueryBuilder> opLambda)`
`void`	`setCreatedBy_CommonTerms(String createdBy)`
`void`	`setCreatedBy_CommonTerms(String createdBy, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.CommonTermsQueryBuilder> opLambda)`
`void`	`setCreatedBy_Equal(String createdBy)`
`void`	`setCreatedBy_Equal(String createdBy, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)`
`void`	`setCreatedBy_Exists()`
`void`	`setCreatedBy_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.ExistsQueryBuilder> opLambda)`
`void`	`setCreatedBy_Fuzzy(String createdBy)`
`void`	`setCreatedBy_Fuzzy(String createdBy, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)`
`void`	`setCreatedBy_GreaterEqual(String createdBy)`
`void`	`setCreatedBy_GreaterEqual(String createdBy, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setCreatedBy_GreaterThan(String createdBy)`
`void`	`setCreatedBy_GreaterThan(String createdBy, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setCreatedBy_InScope(Collection<String> createdByList)`
`void`	`setCreatedBy_InScope(Collection<String> createdByList, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)`
`void`	`setCreatedBy_LessEqual(String createdBy)`
`void`	`setCreatedBy_LessEqual(String createdBy, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setCreatedBy_LessThan(String createdBy)`
`void`	`setCreatedBy_LessThan(String createdBy, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setCreatedBy_Match(String createdBy)`
`void`	`setCreatedBy_Match(String createdBy, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)`
`void`	`setCreatedBy_MatchPhrase(String createdBy)`
`void`	`setCreatedBy_MatchPhrase(String createdBy, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhraseQueryBuilder> opLambda)`
`void`	`setCreatedBy_MatchPhrasePrefix(String createdBy)`
`void`	`setCreatedBy_MatchPhrasePrefix(String createdBy, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhrasePrefixQueryBuilder> opLambda)`
`void`	`setCreatedBy_NotEqual(String createdBy)`
`void`	`setCreatedBy_NotEqual(String createdBy, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)`
`void`	`setCreatedBy_NotTerm(String createdBy)`
`void`	`setCreatedBy_NotTerm(String createdBy, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)`
`void`	`setCreatedBy_Prefix(String createdBy)`
`void`	`setCreatedBy_Prefix(String createdBy, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.PrefixQueryBuilder> opLambda)`
`void`	`setCreatedBy_Regexp(String createdBy)`
`void`	`setCreatedBy_Regexp(String createdBy, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RegexpQueryBuilder> opLambda)`
`void`	`setCreatedBy_SpanTerm(String createdBy)`
`void`	`setCreatedBy_SpanTerm(String createdBy, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.SpanTermQueryBuilder> opLambda)`
`void`	`setCreatedBy_Term(String createdBy)`
`void`	`setCreatedBy_Term(String createdBy, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)`
`void`	`setCreatedBy_Terms(Collection<String> createdByList)`
`void`	`setCreatedBy_Terms(Collection<String> createdByList, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)`
`void`	`setCreatedBy_Wildcard(String createdBy)`
`void`	`setCreatedBy_Wildcard(String createdBy, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.WildcardQueryBuilder> opLambda)`
`void`	`setCreatedTime_CommonTerms(Long createdTime)`
`void`	`setCreatedTime_CommonTerms(Long createdTime, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.CommonTermsQueryBuilder> opLambda)`
`void`	`setCreatedTime_Equal(Long createdTime)`
`void`	`setCreatedTime_Equal(Long createdTime, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)`
`void`	`setCreatedTime_Exists()`
`void`	`setCreatedTime_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.ExistsQueryBuilder> opLambda)`
`void`	`setCreatedTime_Fuzzy(Long createdTime)`
`void`	`setCreatedTime_Fuzzy(Long createdTime, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)`
`void`	`setCreatedTime_GreaterEqual(Long createdTime)`
`void`	`setCreatedTime_GreaterEqual(Long createdTime, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setCreatedTime_GreaterThan(Long createdTime)`
`void`	`setCreatedTime_GreaterThan(Long createdTime, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setCreatedTime_InScope(Collection<Long> createdTimeList)`
`void`	`setCreatedTime_InScope(Collection<Long> createdTimeList, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)`
`void`	`setCreatedTime_LessEqual(Long createdTime)`
`void`	`setCreatedTime_LessEqual(Long createdTime, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setCreatedTime_LessThan(Long createdTime)`
`void`	`setCreatedTime_LessThan(Long createdTime, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setCreatedTime_Match(Long createdTime)`
`void`	`setCreatedTime_Match(Long createdTime, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)`
`void`	`setCreatedTime_MatchPhrase(Long createdTime)`
`void`	`setCreatedTime_MatchPhrase(Long createdTime, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhraseQueryBuilder> opLambda)`
`void`	`setCreatedTime_MatchPhrasePrefix(Long createdTime)`
`void`	`setCreatedTime_MatchPhrasePrefix(Long createdTime, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhrasePrefixQueryBuilder> opLambda)`
`void`	`setCreatedTime_NotEqual(Long createdTime)`
`void`	`setCreatedTime_NotEqual(Long createdTime, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)`
`void`	`setCreatedTime_NotTerm(Long createdTime)`
`void`	`setCreatedTime_NotTerm(Long createdTime, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)`
`void`	`setCreatedTime_Term(Long createdTime)`
`void`	`setCreatedTime_Term(Long createdTime, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)`
`void`	`setCreatedTime_Terms(Collection<Long> createdTimeList)`
`void`	`setCreatedTime_Terms(Collection<Long> createdTimeList, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)`
`void`	`setDepth_CommonTerms(Integer depth)`
`void`	`setDepth_CommonTerms(Integer depth, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.CommonTermsQueryBuilder> opLambda)`
`void`	`setDepth_Equal(Integer depth)`
`void`	`setDepth_Equal(Integer depth, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)`
`void`	`setDepth_Exists()`
`void`	`setDepth_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.ExistsQueryBuilder> opLambda)`
`void`	`setDepth_Fuzzy(Integer depth)`
`void`	`setDepth_Fuzzy(Integer depth, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)`
`void`	`setDepth_GreaterEqual(Integer depth)`
`void`	`setDepth_GreaterEqual(Integer depth, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setDepth_GreaterThan(Integer depth)`
`void`	`setDepth_GreaterThan(Integer depth, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setDepth_InScope(Collection<Integer> depthList)`
`void`	`setDepth_InScope(Collection<Integer> depthList, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)`
`void`	`setDepth_LessEqual(Integer depth)`
`void`	`setDepth_LessEqual(Integer depth, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setDepth_LessThan(Integer depth)`
`void`	`setDepth_LessThan(Integer depth, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setDepth_Match(Integer depth)`
`void`	`setDepth_Match(Integer depth, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)`
`void`	`setDepth_MatchPhrase(Integer depth)`
`void`	`setDepth_MatchPhrase(Integer depth, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhraseQueryBuilder> opLambda)`
`void`	`setDepth_MatchPhrasePrefix(Integer depth)`
`void`	`setDepth_MatchPhrasePrefix(Integer depth, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhrasePrefixQueryBuilder> opLambda)`
`void`	`setDepth_NotEqual(Integer depth)`
`void`	`setDepth_NotEqual(Integer depth, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)`
`void`	`setDepth_NotTerm(Integer depth)`
`void`	`setDepth_NotTerm(Integer depth, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)`
`void`	`setDepth_Term(Integer depth)`
`void`	`setDepth_Term(Integer depth, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)`
`void`	`setDepth_Terms(Collection<Integer> depthList)`
`void`	`setDepth_Terms(Collection<Integer> depthList, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)`
`void`	`setDescription_CommonTerms(String description)`
`void`	`setDescription_CommonTerms(String description, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.CommonTermsQueryBuilder> opLambda)`
`void`	`setDescription_Equal(String description)`
`void`	`setDescription_Equal(String description, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)`
`void`	`setDescription_Exists()`
`void`	`setDescription_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.ExistsQueryBuilder> opLambda)`
`void`	`setDescription_Fuzzy(String description)`
`void`	`setDescription_Fuzzy(String description, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)`
`void`	`setDescription_GreaterEqual(String description)`
`void`	`setDescription_GreaterEqual(String description, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setDescription_GreaterThan(String description)`
`void`	`setDescription_GreaterThan(String description, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setDescription_InScope(Collection<String> descriptionList)`
`void`	`setDescription_InScope(Collection<String> descriptionList, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)`
`void`	`setDescription_LessEqual(String description)`
`void`	`setDescription_LessEqual(String description, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setDescription_LessThan(String description)`
`void`	`setDescription_LessThan(String description, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setDescription_Match(String description)`
`void`	`setDescription_Match(String description, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)`
`void`	`setDescription_MatchPhrase(String description)`
`void`	`setDescription_MatchPhrase(String description, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhraseQueryBuilder> opLambda)`
`void`	`setDescription_MatchPhrasePrefix(String description)`
`void`	`setDescription_MatchPhrasePrefix(String description, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhrasePrefixQueryBuilder> opLambda)`
`void`	`setDescription_NotEqual(String description)`
`void`	`setDescription_NotEqual(String description, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)`
`void`	`setDescription_NotTerm(String description)`
`void`	`setDescription_NotTerm(String description, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)`
`void`	`setDescription_Prefix(String description)`
`void`	`setDescription_Prefix(String description, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.PrefixQueryBuilder> opLambda)`
`void`	`setDescription_Regexp(String description)`
`void`	`setDescription_Regexp(String description, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RegexpQueryBuilder> opLambda)`
`void`	`setDescription_SpanTerm(String description)`
`void`	`setDescription_SpanTerm(String description, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.SpanTermQueryBuilder> opLambda)`
`void`	`setDescription_Term(String description)`
`void`	`setDescription_Term(String description, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)`
`void`	`setDescription_Terms(Collection<String> descriptionList)`
`void`	`setDescription_Terms(Collection<String> descriptionList, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)`
`void`	`setDescription_Wildcard(String description)`
`void`	`setDescription_Wildcard(String description, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.WildcardQueryBuilder> opLambda)`
`void`	`setExcludedDocUrls_CommonTerms(String excludedDocUrls)`
`void`	`setExcludedDocUrls_CommonTerms(String excludedDocUrls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.CommonTermsQueryBuilder> opLambda)`
`void`	`setExcludedDocUrls_Equal(String excludedDocUrls)`
`void`	`setExcludedDocUrls_Equal(String excludedDocUrls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)`
`void`	`setExcludedDocUrls_Exists()`
`void`	`setExcludedDocUrls_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.ExistsQueryBuilder> opLambda)`
`void`	`setExcludedDocUrls_Fuzzy(String excludedDocUrls)`
`void`	`setExcludedDocUrls_Fuzzy(String excludedDocUrls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)`
`void`	`setExcludedDocUrls_GreaterEqual(String excludedDocUrls)`
`void`	`setExcludedDocUrls_GreaterEqual(String excludedDocUrls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setExcludedDocUrls_GreaterThan(String excludedDocUrls)`
`void`	`setExcludedDocUrls_GreaterThan(String excludedDocUrls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setExcludedDocUrls_InScope(Collection<String> excludedDocUrlsList)`
`void`	`setExcludedDocUrls_InScope(Collection<String> excludedDocUrlsList, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)`
`void`	`setExcludedDocUrls_LessEqual(String excludedDocUrls)`
`void`	`setExcludedDocUrls_LessEqual(String excludedDocUrls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setExcludedDocUrls_LessThan(String excludedDocUrls)`
`void`	`setExcludedDocUrls_LessThan(String excludedDocUrls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setExcludedDocUrls_Match(String excludedDocUrls)`
`void`	`setExcludedDocUrls_Match(String excludedDocUrls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)`
`void`	`setExcludedDocUrls_MatchPhrase(String excludedDocUrls)`
`void`	`setExcludedDocUrls_MatchPhrase(String excludedDocUrls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhraseQueryBuilder> opLambda)`
`void`	`setExcludedDocUrls_MatchPhrasePrefix(String excludedDocUrls)`
`void`	`setExcludedDocUrls_MatchPhrasePrefix(String excludedDocUrls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhrasePrefixQueryBuilder> opLambda)`
`void`	`setExcludedDocUrls_NotEqual(String excludedDocUrls)`
`void`	`setExcludedDocUrls_NotEqual(String excludedDocUrls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)`
`void`	`setExcludedDocUrls_NotTerm(String excludedDocUrls)`
`void`	`setExcludedDocUrls_NotTerm(String excludedDocUrls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)`
`void`	`setExcludedDocUrls_Prefix(String excludedDocUrls)`
`void`	`setExcludedDocUrls_Prefix(String excludedDocUrls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.PrefixQueryBuilder> opLambda)`
`void`	`setExcludedDocUrls_Regexp(String excludedDocUrls)`
`void`	`setExcludedDocUrls_Regexp(String excludedDocUrls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RegexpQueryBuilder> opLambda)`
`void`	`setExcludedDocUrls_SpanTerm(String excludedDocUrls)`
`void`	`setExcludedDocUrls_SpanTerm(String excludedDocUrls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.SpanTermQueryBuilder> opLambda)`
`void`	`setExcludedDocUrls_Term(String excludedDocUrls)`
`void`	`setExcludedDocUrls_Term(String excludedDocUrls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)`
`void`	`setExcludedDocUrls_Terms(Collection<String> excludedDocUrlsList)`
`void`	`setExcludedDocUrls_Terms(Collection<String> excludedDocUrlsList, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)`
`void`	`setExcludedDocUrls_Wildcard(String excludedDocUrls)`
`void`	`setExcludedDocUrls_Wildcard(String excludedDocUrls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.WildcardQueryBuilder> opLambda)`
`void`	`setExcludedUrls_CommonTerms(String excludedUrls)`
`void`	`setExcludedUrls_CommonTerms(String excludedUrls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.CommonTermsQueryBuilder> opLambda)`
`void`	`setExcludedUrls_Equal(String excludedUrls)`
`void`	`setExcludedUrls_Equal(String excludedUrls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)`
`void`	`setExcludedUrls_Exists()`
`void`	`setExcludedUrls_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.ExistsQueryBuilder> opLambda)`
`void`	`setExcludedUrls_Fuzzy(String excludedUrls)`
`void`	`setExcludedUrls_Fuzzy(String excludedUrls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)`
`void`	`setExcludedUrls_GreaterEqual(String excludedUrls)`
`void`	`setExcludedUrls_GreaterEqual(String excludedUrls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setExcludedUrls_GreaterThan(String excludedUrls)`
`void`	`setExcludedUrls_GreaterThan(String excludedUrls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setExcludedUrls_InScope(Collection<String> excludedUrlsList)`
`void`	`setExcludedUrls_InScope(Collection<String> excludedUrlsList, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)`
`void`	`setExcludedUrls_LessEqual(String excludedUrls)`
`void`	`setExcludedUrls_LessEqual(String excludedUrls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setExcludedUrls_LessThan(String excludedUrls)`
`void`	`setExcludedUrls_LessThan(String excludedUrls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setExcludedUrls_Match(String excludedUrls)`
`void`	`setExcludedUrls_Match(String excludedUrls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)`
`void`	`setExcludedUrls_MatchPhrase(String excludedUrls)`
`void`	`setExcludedUrls_MatchPhrase(String excludedUrls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhraseQueryBuilder> opLambda)`
`void`	`setExcludedUrls_MatchPhrasePrefix(String excludedUrls)`
`void`	`setExcludedUrls_MatchPhrasePrefix(String excludedUrls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhrasePrefixQueryBuilder> opLambda)`
`void`	`setExcludedUrls_NotEqual(String excludedUrls)`
`void`	`setExcludedUrls_NotEqual(String excludedUrls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)`
`void`	`setExcludedUrls_NotTerm(String excludedUrls)`
`void`	`setExcludedUrls_NotTerm(String excludedUrls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)`
`void`	`setExcludedUrls_Prefix(String excludedUrls)`
`void`	`setExcludedUrls_Prefix(String excludedUrls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.PrefixQueryBuilder> opLambda)`
`void`	`setExcludedUrls_Regexp(String excludedUrls)`
`void`	`setExcludedUrls_Regexp(String excludedUrls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RegexpQueryBuilder> opLambda)`
`void`	`setExcludedUrls_SpanTerm(String excludedUrls)`
`void`	`setExcludedUrls_SpanTerm(String excludedUrls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.SpanTermQueryBuilder> opLambda)`
`void`	`setExcludedUrls_Term(String excludedUrls)`
`void`	`setExcludedUrls_Term(String excludedUrls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)`
`void`	`setExcludedUrls_Terms(Collection<String> excludedUrlsList)`
`void`	`setExcludedUrls_Terms(Collection<String> excludedUrlsList, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)`
`void`	`setExcludedUrls_Wildcard(String excludedUrls)`
`void`	`setExcludedUrls_Wildcard(String excludedUrls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.WildcardQueryBuilder> opLambda)`
`void`	`setId_Equal(String id)`
`void`	`setId_Equal(String id, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)`
`void`	`setId_InScope(Collection<String> idList)`
`void`	`setId_InScope(Collection<String> idList, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.IdsQueryBuilder> opLambda)`
`void`	`setId_NotEqual(String id)`
`void`	`setId_NotEqual(String id, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)`
`void`	`setId_NotTerm(String id)`
`void`	`setId_NotTerm(String id, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)`
`void`	`setId_Term(String id)`
`void`	`setId_Term(String id, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)`
`void`	`setId_Terms(Collection<String> idList)`
`void`	`setId_Terms(Collection<String> idList, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.IdsQueryBuilder> opLambda)`
`void`	`setIncludedDocUrls_CommonTerms(String includedDocUrls)`
`void`	`setIncludedDocUrls_CommonTerms(String includedDocUrls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.CommonTermsQueryBuilder> opLambda)`
`void`	`setIncludedDocUrls_Equal(String includedDocUrls)`
`void`	`setIncludedDocUrls_Equal(String includedDocUrls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)`
`void`	`setIncludedDocUrls_Exists()`
`void`	`setIncludedDocUrls_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.ExistsQueryBuilder> opLambda)`
`void`	`setIncludedDocUrls_Fuzzy(String includedDocUrls)`
`void`	`setIncludedDocUrls_Fuzzy(String includedDocUrls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)`
`void`	`setIncludedDocUrls_GreaterEqual(String includedDocUrls)`
`void`	`setIncludedDocUrls_GreaterEqual(String includedDocUrls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setIncludedDocUrls_GreaterThan(String includedDocUrls)`
`void`	`setIncludedDocUrls_GreaterThan(String includedDocUrls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setIncludedDocUrls_InScope(Collection<String> includedDocUrlsList)`
`void`	`setIncludedDocUrls_InScope(Collection<String> includedDocUrlsList, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)`
`void`	`setIncludedDocUrls_LessEqual(String includedDocUrls)`
`void`	`setIncludedDocUrls_LessEqual(String includedDocUrls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setIncludedDocUrls_LessThan(String includedDocUrls)`
`void`	`setIncludedDocUrls_LessThan(String includedDocUrls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setIncludedDocUrls_Match(String includedDocUrls)`
`void`	`setIncludedDocUrls_Match(String includedDocUrls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)`
`void`	`setIncludedDocUrls_MatchPhrase(String includedDocUrls)`
`void`	`setIncludedDocUrls_MatchPhrase(String includedDocUrls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhraseQueryBuilder> opLambda)`
`void`	`setIncludedDocUrls_MatchPhrasePrefix(String includedDocUrls)`
`void`	`setIncludedDocUrls_MatchPhrasePrefix(String includedDocUrls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhrasePrefixQueryBuilder> opLambda)`
`void`	`setIncludedDocUrls_NotEqual(String includedDocUrls)`
`void`	`setIncludedDocUrls_NotEqual(String includedDocUrls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)`
`void`	`setIncludedDocUrls_NotTerm(String includedDocUrls)`
`void`	`setIncludedDocUrls_NotTerm(String includedDocUrls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)`
`void`	`setIncludedDocUrls_Prefix(String includedDocUrls)`
`void`	`setIncludedDocUrls_Prefix(String includedDocUrls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.PrefixQueryBuilder> opLambda)`
`void`	`setIncludedDocUrls_Regexp(String includedDocUrls)`
`void`	`setIncludedDocUrls_Regexp(String includedDocUrls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RegexpQueryBuilder> opLambda)`
`void`	`setIncludedDocUrls_SpanTerm(String includedDocUrls)`
`void`	`setIncludedDocUrls_SpanTerm(String includedDocUrls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.SpanTermQueryBuilder> opLambda)`
`void`	`setIncludedDocUrls_Term(String includedDocUrls)`
`void`	`setIncludedDocUrls_Term(String includedDocUrls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)`
`void`	`setIncludedDocUrls_Terms(Collection<String> includedDocUrlsList)`
`void`	`setIncludedDocUrls_Terms(Collection<String> includedDocUrlsList, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)`
`void`	`setIncludedDocUrls_Wildcard(String includedDocUrls)`
`void`	`setIncludedDocUrls_Wildcard(String includedDocUrls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.WildcardQueryBuilder> opLambda)`
`void`	`setIncludedUrls_CommonTerms(String includedUrls)`
`void`	`setIncludedUrls_CommonTerms(String includedUrls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.CommonTermsQueryBuilder> opLambda)`
`void`	`setIncludedUrls_Equal(String includedUrls)`
`void`	`setIncludedUrls_Equal(String includedUrls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)`
`void`	`setIncludedUrls_Exists()`
`void`	`setIncludedUrls_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.ExistsQueryBuilder> opLambda)`
`void`	`setIncludedUrls_Fuzzy(String includedUrls)`
`void`	`setIncludedUrls_Fuzzy(String includedUrls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)`
`void`	`setIncludedUrls_GreaterEqual(String includedUrls)`
`void`	`setIncludedUrls_GreaterEqual(String includedUrls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setIncludedUrls_GreaterThan(String includedUrls)`
`void`	`setIncludedUrls_GreaterThan(String includedUrls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setIncludedUrls_InScope(Collection<String> includedUrlsList)`
`void`	`setIncludedUrls_InScope(Collection<String> includedUrlsList, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)`
`void`	`setIncludedUrls_LessEqual(String includedUrls)`
`void`	`setIncludedUrls_LessEqual(String includedUrls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setIncludedUrls_LessThan(String includedUrls)`
`void`	`setIncludedUrls_LessThan(String includedUrls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setIncludedUrls_Match(String includedUrls)`
`void`	`setIncludedUrls_Match(String includedUrls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)`
`void`	`setIncludedUrls_MatchPhrase(String includedUrls)`
`void`	`setIncludedUrls_MatchPhrase(String includedUrls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhraseQueryBuilder> opLambda)`
`void`	`setIncludedUrls_MatchPhrasePrefix(String includedUrls)`
`void`	`setIncludedUrls_MatchPhrasePrefix(String includedUrls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhrasePrefixQueryBuilder> opLambda)`
`void`	`setIncludedUrls_NotEqual(String includedUrls)`
`void`	`setIncludedUrls_NotEqual(String includedUrls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)`
`void`	`setIncludedUrls_NotTerm(String includedUrls)`
`void`	`setIncludedUrls_NotTerm(String includedUrls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)`
`void`	`setIncludedUrls_Prefix(String includedUrls)`
`void`	`setIncludedUrls_Prefix(String includedUrls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.PrefixQueryBuilder> opLambda)`
`void`	`setIncludedUrls_Regexp(String includedUrls)`
`void`	`setIncludedUrls_Regexp(String includedUrls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RegexpQueryBuilder> opLambda)`
`void`	`setIncludedUrls_SpanTerm(String includedUrls)`
`void`	`setIncludedUrls_SpanTerm(String includedUrls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.SpanTermQueryBuilder> opLambda)`
`void`	`setIncludedUrls_Term(String includedUrls)`
`void`	`setIncludedUrls_Term(String includedUrls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)`
`void`	`setIncludedUrls_Terms(Collection<String> includedUrlsList)`
`void`	`setIncludedUrls_Terms(Collection<String> includedUrlsList, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)`
`void`	`setIncludedUrls_Wildcard(String includedUrls)`
`void`	`setIncludedUrls_Wildcard(String includedUrls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.WildcardQueryBuilder> opLambda)`
`void`	`setIntervalTime_CommonTerms(Integer intervalTime)`
`void`	`setIntervalTime_CommonTerms(Integer intervalTime, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.CommonTermsQueryBuilder> opLambda)`
`void`	`setIntervalTime_Equal(Integer intervalTime)`
`void`	`setIntervalTime_Equal(Integer intervalTime, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)`
`void`	`setIntervalTime_Exists()`
`void`	`setIntervalTime_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.ExistsQueryBuilder> opLambda)`
`void`	`setIntervalTime_Fuzzy(Integer intervalTime)`
`void`	`setIntervalTime_Fuzzy(Integer intervalTime, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)`
`void`	`setIntervalTime_GreaterEqual(Integer intervalTime)`
`void`	`setIntervalTime_GreaterEqual(Integer intervalTime, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setIntervalTime_GreaterThan(Integer intervalTime)`
`void`	`setIntervalTime_GreaterThan(Integer intervalTime, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setIntervalTime_InScope(Collection<Integer> intervalTimeList)`
`void`	`setIntervalTime_InScope(Collection<Integer> intervalTimeList, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)`
`void`	`setIntervalTime_LessEqual(Integer intervalTime)`
`void`	`setIntervalTime_LessEqual(Integer intervalTime, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setIntervalTime_LessThan(Integer intervalTime)`
`void`	`setIntervalTime_LessThan(Integer intervalTime, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setIntervalTime_Match(Integer intervalTime)`
`void`	`setIntervalTime_Match(Integer intervalTime, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)`
`void`	`setIntervalTime_MatchPhrase(Integer intervalTime)`
`void`	`setIntervalTime_MatchPhrase(Integer intervalTime, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhraseQueryBuilder> opLambda)`
`void`	`setIntervalTime_MatchPhrasePrefix(Integer intervalTime)`
`void`	`setIntervalTime_MatchPhrasePrefix(Integer intervalTime, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhrasePrefixQueryBuilder> opLambda)`
`void`	`setIntervalTime_NotEqual(Integer intervalTime)`
`void`	`setIntervalTime_NotEqual(Integer intervalTime, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)`
`void`	`setIntervalTime_NotTerm(Integer intervalTime)`
`void`	`setIntervalTime_NotTerm(Integer intervalTime, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)`
`void`	`setIntervalTime_Term(Integer intervalTime)`
`void`	`setIntervalTime_Term(Integer intervalTime, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)`
`void`	`setIntervalTime_Terms(Collection<Integer> intervalTimeList)`
`void`	`setIntervalTime_Terms(Collection<Integer> intervalTimeList, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)`
`void`	`setMaxAccessCount_CommonTerms(Long maxAccessCount)`
`void`	`setMaxAccessCount_CommonTerms(Long maxAccessCount, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.CommonTermsQueryBuilder> opLambda)`
`void`	`setMaxAccessCount_Equal(Long maxAccessCount)`
`void`	`setMaxAccessCount_Equal(Long maxAccessCount, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)`
`void`	`setMaxAccessCount_Exists()`
`void`	`setMaxAccessCount_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.ExistsQueryBuilder> opLambda)`
`void`	`setMaxAccessCount_Fuzzy(Long maxAccessCount)`
`void`	`setMaxAccessCount_Fuzzy(Long maxAccessCount, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)`
`void`	`setMaxAccessCount_GreaterEqual(Long maxAccessCount)`
`void`	`setMaxAccessCount_GreaterEqual(Long maxAccessCount, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setMaxAccessCount_GreaterThan(Long maxAccessCount)`
`void`	`setMaxAccessCount_GreaterThan(Long maxAccessCount, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setMaxAccessCount_InScope(Collection<Long> maxAccessCountList)`
`void`	`setMaxAccessCount_InScope(Collection<Long> maxAccessCountList, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)`
`void`	`setMaxAccessCount_LessEqual(Long maxAccessCount)`
`void`	`setMaxAccessCount_LessEqual(Long maxAccessCount, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setMaxAccessCount_LessThan(Long maxAccessCount)`
`void`	`setMaxAccessCount_LessThan(Long maxAccessCount, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setMaxAccessCount_Match(Long maxAccessCount)`
`void`	`setMaxAccessCount_Match(Long maxAccessCount, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)`
`void`	`setMaxAccessCount_MatchPhrase(Long maxAccessCount)`
`void`	`setMaxAccessCount_MatchPhrase(Long maxAccessCount, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhraseQueryBuilder> opLambda)`
`void`	`setMaxAccessCount_MatchPhrasePrefix(Long maxAccessCount)`
`void`	`setMaxAccessCount_MatchPhrasePrefix(Long maxAccessCount, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhrasePrefixQueryBuilder> opLambda)`
`void`	`setMaxAccessCount_NotEqual(Long maxAccessCount)`
`void`	`setMaxAccessCount_NotEqual(Long maxAccessCount, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)`
`void`	`setMaxAccessCount_NotTerm(Long maxAccessCount)`
`void`	`setMaxAccessCount_NotTerm(Long maxAccessCount, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)`
`void`	`setMaxAccessCount_Term(Long maxAccessCount)`
`void`	`setMaxAccessCount_Term(Long maxAccessCount, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)`
`void`	`setMaxAccessCount_Terms(Collection<Long> maxAccessCountList)`
`void`	`setMaxAccessCount_Terms(Collection<Long> maxAccessCountList, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)`
`void`	`setName_CommonTerms(String name)`
`void`	`setName_CommonTerms(String name, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.CommonTermsQueryBuilder> opLambda)`
`void`	`setName_Equal(String name)`
`void`	`setName_Equal(String name, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)`
`void`	`setName_Exists()`
`void`	`setName_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.ExistsQueryBuilder> opLambda)`
`void`	`setName_Fuzzy(String name)`
`void`	`setName_Fuzzy(String name, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)`
`void`	`setName_GreaterEqual(String name)`
`void`	`setName_GreaterEqual(String name, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setName_GreaterThan(String name)`
`void`	`setName_GreaterThan(String name, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setName_InScope(Collection<String> nameList)`
`void`	`setName_InScope(Collection<String> nameList, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)`
`void`	`setName_LessEqual(String name)`
`void`	`setName_LessEqual(String name, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setName_LessThan(String name)`
`void`	`setName_LessThan(String name, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setName_Match(String name)`
`void`	`setName_Match(String name, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)`
`void`	`setName_MatchPhrase(String name)`
`void`	`setName_MatchPhrase(String name, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhraseQueryBuilder> opLambda)`
`void`	`setName_MatchPhrasePrefix(String name)`
`void`	`setName_MatchPhrasePrefix(String name, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhrasePrefixQueryBuilder> opLambda)`
`void`	`setName_NotEqual(String name)`
`void`	`setName_NotEqual(String name, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)`
`void`	`setName_NotTerm(String name)`
`void`	`setName_NotTerm(String name, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)`
`void`	`setName_Prefix(String name)`
`void`	`setName_Prefix(String name, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.PrefixQueryBuilder> opLambda)`
`void`	`setName_Regexp(String name)`
`void`	`setName_Regexp(String name, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RegexpQueryBuilder> opLambda)`
`void`	`setName_SpanTerm(String name)`
`void`	`setName_SpanTerm(String name, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.SpanTermQueryBuilder> opLambda)`
`void`	`setName_Term(String name)`
`void`	`setName_Term(String name, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)`
`void`	`setName_Terms(Collection<String> nameList)`
`void`	`setName_Terms(Collection<String> nameList, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)`
`void`	`setName_Wildcard(String name)`
`void`	`setName_Wildcard(String name, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.WildcardQueryBuilder> opLambda)`
`void`	`setNumOfThread_CommonTerms(Integer numOfThread)`
`void`	`setNumOfThread_CommonTerms(Integer numOfThread, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.CommonTermsQueryBuilder> opLambda)`
`void`	`setNumOfThread_Equal(Integer numOfThread)`
`void`	`setNumOfThread_Equal(Integer numOfThread, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)`
`void`	`setNumOfThread_Exists()`
`void`	`setNumOfThread_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.ExistsQueryBuilder> opLambda)`
`void`	`setNumOfThread_Fuzzy(Integer numOfThread)`
`void`	`setNumOfThread_Fuzzy(Integer numOfThread, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)`
`void`	`setNumOfThread_GreaterEqual(Integer numOfThread)`
`void`	`setNumOfThread_GreaterEqual(Integer numOfThread, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setNumOfThread_GreaterThan(Integer numOfThread)`
`void`	`setNumOfThread_GreaterThan(Integer numOfThread, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setNumOfThread_InScope(Collection<Integer> numOfThreadList)`
`void`	`setNumOfThread_InScope(Collection<Integer> numOfThreadList, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)`
`void`	`setNumOfThread_LessEqual(Integer numOfThread)`
`void`	`setNumOfThread_LessEqual(Integer numOfThread, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setNumOfThread_LessThan(Integer numOfThread)`
`void`	`setNumOfThread_LessThan(Integer numOfThread, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setNumOfThread_Match(Integer numOfThread)`
`void`	`setNumOfThread_Match(Integer numOfThread, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)`
`void`	`setNumOfThread_MatchPhrase(Integer numOfThread)`
`void`	`setNumOfThread_MatchPhrase(Integer numOfThread, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhraseQueryBuilder> opLambda)`
`void`	`setNumOfThread_MatchPhrasePrefix(Integer numOfThread)`
`void`	`setNumOfThread_MatchPhrasePrefix(Integer numOfThread, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhrasePrefixQueryBuilder> opLambda)`
`void`	`setNumOfThread_NotEqual(Integer numOfThread)`
`void`	`setNumOfThread_NotEqual(Integer numOfThread, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)`
`void`	`setNumOfThread_NotTerm(Integer numOfThread)`
`void`	`setNumOfThread_NotTerm(Integer numOfThread, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)`
`void`	`setNumOfThread_Term(Integer numOfThread)`
`void`	`setNumOfThread_Term(Integer numOfThread, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)`
`void`	`setNumOfThread_Terms(Collection<Integer> numOfThreadList)`
`void`	`setNumOfThread_Terms(Collection<Integer> numOfThreadList, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)`
`void`	`setPermissions_CommonTerms(String permissions)`
`void`	`setPermissions_CommonTerms(String permissions, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.CommonTermsQueryBuilder> opLambda)`
`void`	`setPermissions_Equal(String permissions)`
`void`	`setPermissions_Equal(String permissions, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)`
`void`	`setPermissions_Exists()`
`void`	`setPermissions_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.ExistsQueryBuilder> opLambda)`
`void`	`setPermissions_Fuzzy(String permissions)`
`void`	`setPermissions_Fuzzy(String permissions, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)`
`void`	`setPermissions_GreaterEqual(String permissions)`
`void`	`setPermissions_GreaterEqual(String permissions, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setPermissions_GreaterThan(String permissions)`
`void`	`setPermissions_GreaterThan(String permissions, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setPermissions_InScope(Collection<String> permissionsList)`
`void`	`setPermissions_InScope(Collection<String> permissionsList, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)`
`void`	`setPermissions_LessEqual(String permissions)`
`void`	`setPermissions_LessEqual(String permissions, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setPermissions_LessThan(String permissions)`
`void`	`setPermissions_LessThan(String permissions, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setPermissions_Match(String permissions)`
`void`	`setPermissions_Match(String permissions, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)`
`void`	`setPermissions_MatchPhrase(String permissions)`
`void`	`setPermissions_MatchPhrase(String permissions, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhraseQueryBuilder> opLambda)`
`void`	`setPermissions_MatchPhrasePrefix(String permissions)`
`void`	`setPermissions_MatchPhrasePrefix(String permissions, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhrasePrefixQueryBuilder> opLambda)`
`void`	`setPermissions_NotEqual(String permissions)`
`void`	`setPermissions_NotEqual(String permissions, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)`
`void`	`setPermissions_NotTerm(String permissions)`
`void`	`setPermissions_NotTerm(String permissions, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)`
`void`	`setPermissions_Prefix(String permissions)`
`void`	`setPermissions_Prefix(String permissions, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.PrefixQueryBuilder> opLambda)`
`void`	`setPermissions_Regexp(String permissions)`
`void`	`setPermissions_Regexp(String permissions, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RegexpQueryBuilder> opLambda)`
`void`	`setPermissions_SpanTerm(String permissions)`
`void`	`setPermissions_SpanTerm(String permissions, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.SpanTermQueryBuilder> opLambda)`
`void`	`setPermissions_Term(String permissions)`
`void`	`setPermissions_Term(String permissions, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)`
`void`	`setPermissions_Terms(Collection<String> permissionsList)`
`void`	`setPermissions_Terms(Collection<String> permissionsList, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)`
`void`	`setPermissions_Wildcard(String permissions)`
`void`	`setPermissions_Wildcard(String permissions, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.WildcardQueryBuilder> opLambda)`
`void`	`setSortOrder_CommonTerms(Integer sortOrder)`
`void`	`setSortOrder_CommonTerms(Integer sortOrder, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.CommonTermsQueryBuilder> opLambda)`
`void`	`setSortOrder_Equal(Integer sortOrder)`
`void`	`setSortOrder_Equal(Integer sortOrder, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)`
`void`	`setSortOrder_Exists()`
`void`	`setSortOrder_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.ExistsQueryBuilder> opLambda)`
`void`	`setSortOrder_Fuzzy(Integer sortOrder)`
`void`	`setSortOrder_Fuzzy(Integer sortOrder, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)`
`void`	`setSortOrder_GreaterEqual(Integer sortOrder)`
`void`	`setSortOrder_GreaterEqual(Integer sortOrder, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setSortOrder_GreaterThan(Integer sortOrder)`
`void`	`setSortOrder_GreaterThan(Integer sortOrder, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setSortOrder_InScope(Collection<Integer> sortOrderList)`
`void`	`setSortOrder_InScope(Collection<Integer> sortOrderList, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)`
`void`	`setSortOrder_LessEqual(Integer sortOrder)`
`void`	`setSortOrder_LessEqual(Integer sortOrder, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setSortOrder_LessThan(Integer sortOrder)`
`void`	`setSortOrder_LessThan(Integer sortOrder, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setSortOrder_Match(Integer sortOrder)`
`void`	`setSortOrder_Match(Integer sortOrder, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)`
`void`	`setSortOrder_MatchPhrase(Integer sortOrder)`
`void`	`setSortOrder_MatchPhrase(Integer sortOrder, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhraseQueryBuilder> opLambda)`
`void`	`setSortOrder_MatchPhrasePrefix(Integer sortOrder)`
`void`	`setSortOrder_MatchPhrasePrefix(Integer sortOrder, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhrasePrefixQueryBuilder> opLambda)`
`void`	`setSortOrder_NotEqual(Integer sortOrder)`
`void`	`setSortOrder_NotEqual(Integer sortOrder, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)`
`void`	`setSortOrder_NotTerm(Integer sortOrder)`
`void`	`setSortOrder_NotTerm(Integer sortOrder, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)`
`void`	`setSortOrder_Term(Integer sortOrder)`
`void`	`setSortOrder_Term(Integer sortOrder, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)`
`void`	`setSortOrder_Terms(Collection<Integer> sortOrderList)`
`void`	`setSortOrder_Terms(Collection<Integer> sortOrderList, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)`
`void`	`setTimeToLive_CommonTerms(Integer timeToLive)`
`void`	`setTimeToLive_CommonTerms(Integer timeToLive, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.CommonTermsQueryBuilder> opLambda)`
`void`	`setTimeToLive_Equal(Integer timeToLive)`
`void`	`setTimeToLive_Equal(Integer timeToLive, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)`
`void`	`setTimeToLive_Exists()`
`void`	`setTimeToLive_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.ExistsQueryBuilder> opLambda)`
`void`	`setTimeToLive_Fuzzy(Integer timeToLive)`
`void`	`setTimeToLive_Fuzzy(Integer timeToLive, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)`
`void`	`setTimeToLive_GreaterEqual(Integer timeToLive)`
`void`	`setTimeToLive_GreaterEqual(Integer timeToLive, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setTimeToLive_GreaterThan(Integer timeToLive)`
`void`	`setTimeToLive_GreaterThan(Integer timeToLive, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setTimeToLive_InScope(Collection<Integer> timeToLiveList)`
`void`	`setTimeToLive_InScope(Collection<Integer> timeToLiveList, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)`
`void`	`setTimeToLive_LessEqual(Integer timeToLive)`
`void`	`setTimeToLive_LessEqual(Integer timeToLive, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setTimeToLive_LessThan(Integer timeToLive)`
`void`	`setTimeToLive_LessThan(Integer timeToLive, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setTimeToLive_Match(Integer timeToLive)`
`void`	`setTimeToLive_Match(Integer timeToLive, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)`
`void`	`setTimeToLive_MatchPhrase(Integer timeToLive)`
`void`	`setTimeToLive_MatchPhrase(Integer timeToLive, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhraseQueryBuilder> opLambda)`
`void`	`setTimeToLive_MatchPhrasePrefix(Integer timeToLive)`
`void`	`setTimeToLive_MatchPhrasePrefix(Integer timeToLive, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhrasePrefixQueryBuilder> opLambda)`
`void`	`setTimeToLive_NotEqual(Integer timeToLive)`
`void`	`setTimeToLive_NotEqual(Integer timeToLive, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)`
`void`	`setTimeToLive_NotTerm(Integer timeToLive)`
`void`	`setTimeToLive_NotTerm(Integer timeToLive, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)`
`void`	`setTimeToLive_Term(Integer timeToLive)`
`void`	`setTimeToLive_Term(Integer timeToLive, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)`
`void`	`setTimeToLive_Terms(Collection<Integer> timeToLiveList)`
`void`	`setTimeToLive_Terms(Collection<Integer> timeToLiveList, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)`
`void`	`setUpdatedBy_CommonTerms(String updatedBy)`
`void`	`setUpdatedBy_CommonTerms(String updatedBy, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.CommonTermsQueryBuilder> opLambda)`
`void`	`setUpdatedBy_Equal(String updatedBy)`
`void`	`setUpdatedBy_Equal(String updatedBy, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)`
`void`	`setUpdatedBy_Exists()`
`void`	`setUpdatedBy_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.ExistsQueryBuilder> opLambda)`
`void`	`setUpdatedBy_Fuzzy(String updatedBy)`
`void`	`setUpdatedBy_Fuzzy(String updatedBy, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)`
`void`	`setUpdatedBy_GreaterEqual(String updatedBy)`
`void`	`setUpdatedBy_GreaterEqual(String updatedBy, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setUpdatedBy_GreaterThan(String updatedBy)`
`void`	`setUpdatedBy_GreaterThan(String updatedBy, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setUpdatedBy_InScope(Collection<String> updatedByList)`
`void`	`setUpdatedBy_InScope(Collection<String> updatedByList, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)`
`void`	`setUpdatedBy_LessEqual(String updatedBy)`
`void`	`setUpdatedBy_LessEqual(String updatedBy, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setUpdatedBy_LessThan(String updatedBy)`
`void`	`setUpdatedBy_LessThan(String updatedBy, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setUpdatedBy_Match(String updatedBy)`
`void`	`setUpdatedBy_Match(String updatedBy, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)`
`void`	`setUpdatedBy_MatchPhrase(String updatedBy)`
`void`	`setUpdatedBy_MatchPhrase(String updatedBy, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhraseQueryBuilder> opLambda)`
`void`	`setUpdatedBy_MatchPhrasePrefix(String updatedBy)`
`void`	`setUpdatedBy_MatchPhrasePrefix(String updatedBy, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhrasePrefixQueryBuilder> opLambda)`
`void`	`setUpdatedBy_NotEqual(String updatedBy)`
`void`	`setUpdatedBy_NotEqual(String updatedBy, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)`
`void`	`setUpdatedBy_NotTerm(String updatedBy)`
`void`	`setUpdatedBy_NotTerm(String updatedBy, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)`
`void`	`setUpdatedBy_Prefix(String updatedBy)`
`void`	`setUpdatedBy_Prefix(String updatedBy, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.PrefixQueryBuilder> opLambda)`
`void`	`setUpdatedBy_Regexp(String updatedBy)`
`void`	`setUpdatedBy_Regexp(String updatedBy, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RegexpQueryBuilder> opLambda)`
`void`	`setUpdatedBy_SpanTerm(String updatedBy)`
`void`	`setUpdatedBy_SpanTerm(String updatedBy, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.SpanTermQueryBuilder> opLambda)`
`void`	`setUpdatedBy_Term(String updatedBy)`
`void`	`setUpdatedBy_Term(String updatedBy, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)`
`void`	`setUpdatedBy_Terms(Collection<String> updatedByList)`
`void`	`setUpdatedBy_Terms(Collection<String> updatedByList, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)`
`void`	`setUpdatedBy_Wildcard(String updatedBy)`
`void`	`setUpdatedBy_Wildcard(String updatedBy, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.WildcardQueryBuilder> opLambda)`
`void`	`setUpdatedTime_CommonTerms(Long updatedTime)`
`void`	`setUpdatedTime_CommonTerms(Long updatedTime, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.CommonTermsQueryBuilder> opLambda)`
`void`	`setUpdatedTime_Equal(Long updatedTime)`
`void`	`setUpdatedTime_Equal(Long updatedTime, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)`
`void`	`setUpdatedTime_Exists()`
`void`	`setUpdatedTime_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.ExistsQueryBuilder> opLambda)`
`void`	`setUpdatedTime_Fuzzy(Long updatedTime)`
`void`	`setUpdatedTime_Fuzzy(Long updatedTime, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)`
`void`	`setUpdatedTime_GreaterEqual(Long updatedTime)`
`void`	`setUpdatedTime_GreaterEqual(Long updatedTime, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setUpdatedTime_GreaterThan(Long updatedTime)`
`void`	`setUpdatedTime_GreaterThan(Long updatedTime, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setUpdatedTime_InScope(Collection<Long> updatedTimeList)`
`void`	`setUpdatedTime_InScope(Collection<Long> updatedTimeList, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)`
`void`	`setUpdatedTime_LessEqual(Long updatedTime)`
`void`	`setUpdatedTime_LessEqual(Long updatedTime, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setUpdatedTime_LessThan(Long updatedTime)`
`void`	`setUpdatedTime_LessThan(Long updatedTime, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setUpdatedTime_Match(Long updatedTime)`
`void`	`setUpdatedTime_Match(Long updatedTime, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)`
`void`	`setUpdatedTime_MatchPhrase(Long updatedTime)`
`void`	`setUpdatedTime_MatchPhrase(Long updatedTime, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhraseQueryBuilder> opLambda)`
`void`	`setUpdatedTime_MatchPhrasePrefix(Long updatedTime)`
`void`	`setUpdatedTime_MatchPhrasePrefix(Long updatedTime, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhrasePrefixQueryBuilder> opLambda)`
`void`	`setUpdatedTime_NotEqual(Long updatedTime)`
`void`	`setUpdatedTime_NotEqual(Long updatedTime, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)`
`void`	`setUpdatedTime_NotTerm(Long updatedTime)`
`void`	`setUpdatedTime_NotTerm(Long updatedTime, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)`
`void`	`setUpdatedTime_Term(Long updatedTime)`
`void`	`setUpdatedTime_Term(Long updatedTime, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)`
`void`	`setUpdatedTime_Terms(Collection<Long> updatedTimeList)`
`void`	`setUpdatedTime_Terms(Collection<Long> updatedTimeList, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)`
`void`	`setUrls_CommonTerms(String urls)`
`void`	`setUrls_CommonTerms(String urls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.CommonTermsQueryBuilder> opLambda)`
`void`	`setUrls_Equal(String urls)`
`void`	`setUrls_Equal(String urls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)`
`void`	`setUrls_Exists()`
`void`	`setUrls_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.ExistsQueryBuilder> opLambda)`
`void`	`setUrls_Fuzzy(String urls)`
`void`	`setUrls_Fuzzy(String urls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)`
`void`	`setUrls_GreaterEqual(String urls)`
`void`	`setUrls_GreaterEqual(String urls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setUrls_GreaterThan(String urls)`
`void`	`setUrls_GreaterThan(String urls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setUrls_InScope(Collection<String> urlsList)`
`void`	`setUrls_InScope(Collection<String> urlsList, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)`
`void`	`setUrls_LessEqual(String urls)`
`void`	`setUrls_LessEqual(String urls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setUrls_LessThan(String urls)`
`void`	`setUrls_LessThan(String urls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setUrls_Match(String urls)`
`void`	`setUrls_Match(String urls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)`
`void`	`setUrls_MatchPhrase(String urls)`
`void`	`setUrls_MatchPhrase(String urls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhraseQueryBuilder> opLambda)`
`void`	`setUrls_MatchPhrasePrefix(String urls)`
`void`	`setUrls_MatchPhrasePrefix(String urls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhrasePrefixQueryBuilder> opLambda)`
`void`	`setUrls_NotEqual(String urls)`
`void`	`setUrls_NotEqual(String urls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)`
`void`	`setUrls_NotTerm(String urls)`
`void`	`setUrls_NotTerm(String urls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)`
`void`	`setUrls_Prefix(String urls)`
`void`	`setUrls_Prefix(String urls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.PrefixQueryBuilder> opLambda)`
`void`	`setUrls_Regexp(String urls)`
`void`	`setUrls_Regexp(String urls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RegexpQueryBuilder> opLambda)`
`void`	`setUrls_SpanTerm(String urls)`
`void`	`setUrls_SpanTerm(String urls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.SpanTermQueryBuilder> opLambda)`
`void`	`setUrls_Term(String urls)`
`void`	`setUrls_Term(String urls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)`
`void`	`setUrls_Terms(Collection<String> urlsList)`
`void`	`setUrls_Terms(Collection<String> urlsList, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)`
`void`	`setUrls_Wildcard(String urls)`
`void`	`setUrls_Wildcard(String urls, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.WildcardQueryBuilder> opLambda)`
`void`	`setUserAgent_CommonTerms(String userAgent)`
`void`	`setUserAgent_CommonTerms(String userAgent, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.CommonTermsQueryBuilder> opLambda)`
`void`	`setUserAgent_Equal(String userAgent)`
`void`	`setUserAgent_Equal(String userAgent, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)`
`void`	`setUserAgent_Exists()`
`void`	`setUserAgent_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.ExistsQueryBuilder> opLambda)`
`void`	`setUserAgent_Fuzzy(String userAgent)`
`void`	`setUserAgent_Fuzzy(String userAgent, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)`
`void`	`setUserAgent_GreaterEqual(String userAgent)`
`void`	`setUserAgent_GreaterEqual(String userAgent, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setUserAgent_GreaterThan(String userAgent)`
`void`	`setUserAgent_GreaterThan(String userAgent, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setUserAgent_InScope(Collection<String> userAgentList)`
`void`	`setUserAgent_InScope(Collection<String> userAgentList, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)`
`void`	`setUserAgent_LessEqual(String userAgent)`
`void`	`setUserAgent_LessEqual(String userAgent, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setUserAgent_LessThan(String userAgent)`
`void`	`setUserAgent_LessThan(String userAgent, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setUserAgent_Match(String userAgent)`
`void`	`setUserAgent_Match(String userAgent, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)`
`void`	`setUserAgent_MatchPhrase(String userAgent)`
`void`	`setUserAgent_MatchPhrase(String userAgent, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhraseQueryBuilder> opLambda)`
`void`	`setUserAgent_MatchPhrasePrefix(String userAgent)`
`void`	`setUserAgent_MatchPhrasePrefix(String userAgent, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhrasePrefixQueryBuilder> opLambda)`
`void`	`setUserAgent_NotEqual(String userAgent)`
`void`	`setUserAgent_NotEqual(String userAgent, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)`
`void`	`setUserAgent_NotTerm(String userAgent)`
`void`	`setUserAgent_NotTerm(String userAgent, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)`
`void`	`setUserAgent_Prefix(String userAgent)`
`void`	`setUserAgent_Prefix(String userAgent, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.PrefixQueryBuilder> opLambda)`
`void`	`setUserAgent_Regexp(String userAgent)`
`void`	`setUserAgent_Regexp(String userAgent, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RegexpQueryBuilder> opLambda)`
`void`	`setUserAgent_SpanTerm(String userAgent)`
`void`	`setUserAgent_SpanTerm(String userAgent, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.SpanTermQueryBuilder> opLambda)`
`void`	`setUserAgent_Term(String userAgent)`
`void`	`setUserAgent_Term(String userAgent, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)`
`void`	`setUserAgent_Terms(Collection<String> userAgentList)`
`void`	`setUserAgent_Terms(Collection<String> userAgentList, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)`
`void`	`setUserAgent_Wildcard(String userAgent)`
`void`	`setUserAgent_Wildcard(String userAgent, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.WildcardQueryBuilder> opLambda)`
`void`	`setVirtualHosts_CommonTerms(String virtualHosts)`
`void`	`setVirtualHosts_CommonTerms(String virtualHosts, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.CommonTermsQueryBuilder> opLambda)`
`void`	`setVirtualHosts_Equal(String virtualHosts)`
`void`	`setVirtualHosts_Equal(String virtualHosts, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)`
`void`	`setVirtualHosts_Exists()`
`void`	`setVirtualHosts_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.ExistsQueryBuilder> opLambda)`
`void`	`setVirtualHosts_Fuzzy(String virtualHosts)`
`void`	`setVirtualHosts_Fuzzy(String virtualHosts, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)`
`void`	`setVirtualHosts_GreaterEqual(String virtualHosts)`
`void`	`setVirtualHosts_GreaterEqual(String virtualHosts, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setVirtualHosts_GreaterThan(String virtualHosts)`
`void`	`setVirtualHosts_GreaterThan(String virtualHosts, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setVirtualHosts_InScope(Collection<String> virtualHostsList)`
`void`	`setVirtualHosts_InScope(Collection<String> virtualHostsList, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)`
`void`	`setVirtualHosts_LessEqual(String virtualHosts)`
`void`	`setVirtualHosts_LessEqual(String virtualHosts, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setVirtualHosts_LessThan(String virtualHosts)`
`void`	`setVirtualHosts_LessThan(String virtualHosts, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)`
`void`	`setVirtualHosts_Match(String virtualHosts)`
`void`	`setVirtualHosts_Match(String virtualHosts, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)`
`void`	`setVirtualHosts_MatchPhrase(String virtualHosts)`
`void`	`setVirtualHosts_MatchPhrase(String virtualHosts, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhraseQueryBuilder> opLambda)`
`void`	`setVirtualHosts_MatchPhrasePrefix(String virtualHosts)`
`void`	`setVirtualHosts_MatchPhrasePrefix(String virtualHosts, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhrasePrefixQueryBuilder> opLambda)`
`void`	`setVirtualHosts_NotEqual(String virtualHosts)`
`void`	`setVirtualHosts_NotEqual(String virtualHosts, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)`
`void`	`setVirtualHosts_NotTerm(String virtualHosts)`
`void`	`setVirtualHosts_NotTerm(String virtualHosts, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)`
`void`	`setVirtualHosts_Prefix(String virtualHosts)`
`void`	`setVirtualHosts_Prefix(String virtualHosts, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.PrefixQueryBuilder> opLambda)`
`void`	`setVirtualHosts_Regexp(String virtualHosts)`
`void`	`setVirtualHosts_Regexp(String virtualHosts, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RegexpQueryBuilder> opLambda)`
`void`	`setVirtualHosts_SpanTerm(String virtualHosts)`
`void`	`setVirtualHosts_SpanTerm(String virtualHosts, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.SpanTermQueryBuilder> opLambda)`
`void`	`setVirtualHosts_Term(String virtualHosts)`
`void`	`setVirtualHosts_Term(String virtualHosts, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)`
`void`	`setVirtualHosts_Terms(Collection<String> virtualHostsList)`
`void`	`setVirtualHosts_Terms(Collection<String> virtualHostsList, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)`
`void`	`setVirtualHosts_Wildcard(String virtualHosts)`
`void`	`setVirtualHosts_Wildcard(String virtualHosts, EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.WildcardQueryBuilder> opLambda)`
`String`	`xgetAliasName()`

Methods inherited from class org.codelibs.fess.es.config.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
- BsWebConfigCQ
```
public BsWebConfigCQ()
```

Method Detail

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

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

functionScore

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

filtered

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

filtered

public void filtered(EsAbstractConditionQuery.FilteredCall<WebConfigCQ,WebConfigCQ> filteredLambda,
                     EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)

not

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

not

public void not(EsAbstractConditionQuery.OperatorCall<WebConfigCQ> notLambda,
                EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)

bool

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

bool

public void bool(EsAbstractConditionQuery.BoolCall<WebConfigCQ> boolLambda,
                 EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)

setId_Equal

public void setId_Equal(String id)

setId_Equal

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

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

setId_Term

public void setId_Term(String id,
                       EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.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.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)

setId_NotTerm

public void setId_NotTerm(String id,
                          EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.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.codelibs.fesen.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.codelibs.fesen.index.query.IdsQueryBuilder> opLambda)

addOrderBy_Id_Asc

public BsWebConfigCQ addOrderBy_Id_Asc()

addOrderBy_Id_Desc

public BsWebConfigCQ addOrderBy_Id_Desc()

setAvailable_Equal

public void setAvailable_Equal(Boolean available)

setAvailable_Equal

public void setAvailable_Equal(Boolean available,
                               EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)

setAvailable_Term

public void setAvailable_Term(Boolean available)

setAvailable_Term

public void setAvailable_Term(Boolean available,
                              EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)

setAvailable_NotEqual

public void setAvailable_NotEqual(Boolean available)

setAvailable_NotTerm

public void setAvailable_NotTerm(Boolean available)

setAvailable_NotEqual

public void setAvailable_NotEqual(Boolean available,
                                  EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)

setAvailable_NotTerm

public void setAvailable_NotTerm(Boolean available,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)

setAvailable_Terms

public void setAvailable_Terms(Collection<Boolean> availableList)

setAvailable_Terms

public void setAvailable_Terms(Collection<Boolean> availableList,
                               EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)

setAvailable_InScope

public void setAvailable_InScope(Collection<Boolean> availableList)

setAvailable_InScope

public void setAvailable_InScope(Collection<Boolean> availableList,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)

setAvailable_Match

public void setAvailable_Match(Boolean available)

setAvailable_Match

public void setAvailable_Match(Boolean available,
                               EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)

setAvailable_MatchPhrase

public void setAvailable_MatchPhrase(Boolean available)

setAvailable_MatchPhrase

public void setAvailable_MatchPhrase(Boolean available,
                                     EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhraseQueryBuilder> opLambda)

setAvailable_MatchPhrasePrefix

public void setAvailable_MatchPhrasePrefix(Boolean available)

setAvailable_MatchPhrasePrefix

public void setAvailable_MatchPhrasePrefix(Boolean available,
                                           EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhrasePrefixQueryBuilder> opLambda)

setAvailable_Fuzzy

public void setAvailable_Fuzzy(Boolean available)

setAvailable_Fuzzy

public void setAvailable_Fuzzy(Boolean available,
                               EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)

setAvailable_GreaterThan

public void setAvailable_GreaterThan(Boolean available)

setAvailable_GreaterThan

public void setAvailable_GreaterThan(Boolean available,
                                     EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setAvailable_LessThan

public void setAvailable_LessThan(Boolean available)

setAvailable_LessThan

public void setAvailable_LessThan(Boolean available,
                                  EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setAvailable_GreaterEqual

public void setAvailable_GreaterEqual(Boolean available)

setAvailable_GreaterEqual

public void setAvailable_GreaterEqual(Boolean available,
                                      EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setAvailable_LessEqual

public void setAvailable_LessEqual(Boolean available)

setAvailable_LessEqual

public void setAvailable_LessEqual(Boolean available,
                                   EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setAvailable_Exists
```
public void setAvailable_Exists()
```

setAvailable_Exists

public void setAvailable_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.ExistsQueryBuilder> opLambda)

setAvailable_CommonTerms

public void setAvailable_CommonTerms(Boolean available)

setAvailable_CommonTerms

public void setAvailable_CommonTerms(Boolean available,
                                     EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.CommonTermsQueryBuilder> opLambda)

addOrderBy_Available_Asc

public BsWebConfigCQ addOrderBy_Available_Asc()

addOrderBy_Available_Desc

public BsWebConfigCQ addOrderBy_Available_Desc()

setBoost_Equal

public void setBoost_Equal(Float boost)

setBoost_Equal

public void setBoost_Equal(Float boost,
                           EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)

setBoost_Term

public void setBoost_Term(Float boost)

setBoost_Term

public void setBoost_Term(Float boost,
                          EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)

setBoost_NotEqual

public void setBoost_NotEqual(Float boost)

setBoost_NotTerm

public void setBoost_NotTerm(Float boost)

setBoost_NotEqual

public void setBoost_NotEqual(Float boost,
                              EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)

setBoost_NotTerm

public void setBoost_NotTerm(Float boost,
                             EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)

setBoost_Terms

public void setBoost_Terms(Collection<Float> boostList)

setBoost_Terms

public void setBoost_Terms(Collection<Float> boostList,
                           EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)

setBoost_InScope

public void setBoost_InScope(Collection<Float> boostList)

setBoost_InScope

public void setBoost_InScope(Collection<Float> boostList,
                             EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)

setBoost_Match

public void setBoost_Match(Float boost)

setBoost_Match

public void setBoost_Match(Float boost,
                           EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)

setBoost_MatchPhrase

public void setBoost_MatchPhrase(Float boost)

setBoost_MatchPhrase

public void setBoost_MatchPhrase(Float boost,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhraseQueryBuilder> opLambda)

setBoost_MatchPhrasePrefix

public void setBoost_MatchPhrasePrefix(Float boost)

setBoost_MatchPhrasePrefix

public void setBoost_MatchPhrasePrefix(Float boost,
                                       EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhrasePrefixQueryBuilder> opLambda)

setBoost_Fuzzy

public void setBoost_Fuzzy(Float boost)

setBoost_Fuzzy

public void setBoost_Fuzzy(Float boost,
                           EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)

setBoost_GreaterThan

public void setBoost_GreaterThan(Float boost)

setBoost_GreaterThan

public void setBoost_GreaterThan(Float boost,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setBoost_LessThan

public void setBoost_LessThan(Float boost)

setBoost_LessThan

public void setBoost_LessThan(Float boost,
                              EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setBoost_GreaterEqual

public void setBoost_GreaterEqual(Float boost)

setBoost_GreaterEqual

public void setBoost_GreaterEqual(Float boost,
                                  EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setBoost_LessEqual

public void setBoost_LessEqual(Float boost)

setBoost_LessEqual

public void setBoost_LessEqual(Float boost,
                               EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setBoost_Exists
```
public void setBoost_Exists()
```

setBoost_Exists

public void setBoost_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.ExistsQueryBuilder> opLambda)

setBoost_CommonTerms

public void setBoost_CommonTerms(Float boost)

setBoost_CommonTerms

public void setBoost_CommonTerms(Float boost,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.CommonTermsQueryBuilder> opLambda)

addOrderBy_Boost_Asc

public BsWebConfigCQ addOrderBy_Boost_Asc()

addOrderBy_Boost_Desc

public BsWebConfigCQ addOrderBy_Boost_Desc()

setConfigParameter_Equal

public void setConfigParameter_Equal(String configParameter)

setConfigParameter_Equal

public void setConfigParameter_Equal(String configParameter,
                                     EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)

setConfigParameter_Term

public void setConfigParameter_Term(String configParameter)

setConfigParameter_Term

public void setConfigParameter_Term(String configParameter,
                                    EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)

setConfigParameter_NotEqual

public void setConfigParameter_NotEqual(String configParameter)

setConfigParameter_NotTerm

public void setConfigParameter_NotTerm(String configParameter)

setConfigParameter_NotEqual

public void setConfigParameter_NotEqual(String configParameter,
                                        EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)

setConfigParameter_NotTerm

public void setConfigParameter_NotTerm(String configParameter,
                                       EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)

setConfigParameter_Terms

public void setConfigParameter_Terms(Collection<String> configParameterList)

setConfigParameter_Terms

public void setConfigParameter_Terms(Collection<String> configParameterList,
                                     EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)

setConfigParameter_InScope

public void setConfigParameter_InScope(Collection<String> configParameterList)

setConfigParameter_InScope

public void setConfigParameter_InScope(Collection<String> configParameterList,
                                       EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)

setConfigParameter_Match

public void setConfigParameter_Match(String configParameter)

setConfigParameter_Match

public void setConfigParameter_Match(String configParameter,
                                     EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)

setConfigParameter_MatchPhrase

public void setConfigParameter_MatchPhrase(String configParameter)

setConfigParameter_MatchPhrase

public void setConfigParameter_MatchPhrase(String configParameter,
                                           EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhraseQueryBuilder> opLambda)

setConfigParameter_MatchPhrasePrefix

public void setConfigParameter_MatchPhrasePrefix(String configParameter)

setConfigParameter_MatchPhrasePrefix

public void setConfigParameter_MatchPhrasePrefix(String configParameter,
                                                 EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhrasePrefixQueryBuilder> opLambda)

setConfigParameter_Fuzzy

public void setConfigParameter_Fuzzy(String configParameter)

setConfigParameter_Fuzzy

public void setConfigParameter_Fuzzy(String configParameter,
                                     EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)

setConfigParameter_Prefix

public void setConfigParameter_Prefix(String configParameter)

setConfigParameter_Prefix

public void setConfigParameter_Prefix(String configParameter,
                                      EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.PrefixQueryBuilder> opLambda)

setConfigParameter_Wildcard

public void setConfigParameter_Wildcard(String configParameter)

setConfigParameter_Wildcard

public void setConfigParameter_Wildcard(String configParameter,
                                        EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.WildcardQueryBuilder> opLambda)

setConfigParameter_Regexp

public void setConfigParameter_Regexp(String configParameter)

setConfigParameter_Regexp

public void setConfigParameter_Regexp(String configParameter,
                                      EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RegexpQueryBuilder> opLambda)

setConfigParameter_SpanTerm

public void setConfigParameter_SpanTerm(String configParameter)

setConfigParameter_SpanTerm

public void setConfigParameter_SpanTerm(String configParameter,
                                        EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.SpanTermQueryBuilder> opLambda)

setConfigParameter_GreaterThan

public void setConfigParameter_GreaterThan(String configParameter)

setConfigParameter_GreaterThan

public void setConfigParameter_GreaterThan(String configParameter,
                                           EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setConfigParameter_LessThan

public void setConfigParameter_LessThan(String configParameter)

setConfigParameter_LessThan

public void setConfigParameter_LessThan(String configParameter,
                                        EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setConfigParameter_GreaterEqual

public void setConfigParameter_GreaterEqual(String configParameter)

setConfigParameter_GreaterEqual

public void setConfigParameter_GreaterEqual(String configParameter,
                                            EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setConfigParameter_LessEqual

public void setConfigParameter_LessEqual(String configParameter)

setConfigParameter_LessEqual

public void setConfigParameter_LessEqual(String configParameter,
                                         EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setConfigParameter_Exists

public void setConfigParameter_Exists()

setConfigParameter_Exists

public void setConfigParameter_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.ExistsQueryBuilder> opLambda)

setConfigParameter_CommonTerms

public void setConfigParameter_CommonTerms(String configParameter)

setConfigParameter_CommonTerms

public void setConfigParameter_CommonTerms(String configParameter,
                                           EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.CommonTermsQueryBuilder> opLambda)

addOrderBy_ConfigParameter_Asc

public BsWebConfigCQ addOrderBy_ConfigParameter_Asc()

addOrderBy_ConfigParameter_Desc

public BsWebConfigCQ addOrderBy_ConfigParameter_Desc()

setCreatedBy_Equal

public void setCreatedBy_Equal(String createdBy)

setCreatedBy_Equal

public void setCreatedBy_Equal(String createdBy,
                               EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)

setCreatedBy_Term

public void setCreatedBy_Term(String createdBy)

setCreatedBy_Term

public void setCreatedBy_Term(String createdBy,
                              EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)

setCreatedBy_NotEqual

public void setCreatedBy_NotEqual(String createdBy)

setCreatedBy_NotTerm

public void setCreatedBy_NotTerm(String createdBy)

setCreatedBy_NotEqual

public void setCreatedBy_NotEqual(String createdBy,
                                  EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)

setCreatedBy_NotTerm

public void setCreatedBy_NotTerm(String createdBy,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)

setCreatedBy_Terms

public void setCreatedBy_Terms(Collection<String> createdByList)

setCreatedBy_Terms

public void setCreatedBy_Terms(Collection<String> createdByList,
                               EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)

setCreatedBy_InScope

public void setCreatedBy_InScope(Collection<String> createdByList)

setCreatedBy_InScope

public void setCreatedBy_InScope(Collection<String> createdByList,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)

setCreatedBy_Match

public void setCreatedBy_Match(String createdBy)

setCreatedBy_Match

public void setCreatedBy_Match(String createdBy,
                               EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)

setCreatedBy_MatchPhrase

public void setCreatedBy_MatchPhrase(String createdBy)

setCreatedBy_MatchPhrase

public void setCreatedBy_MatchPhrase(String createdBy,
                                     EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhraseQueryBuilder> opLambda)

setCreatedBy_MatchPhrasePrefix

public void setCreatedBy_MatchPhrasePrefix(String createdBy)

setCreatedBy_MatchPhrasePrefix

public void setCreatedBy_MatchPhrasePrefix(String createdBy,
                                           EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhrasePrefixQueryBuilder> opLambda)

setCreatedBy_Fuzzy

public void setCreatedBy_Fuzzy(String createdBy)

setCreatedBy_Fuzzy

public void setCreatedBy_Fuzzy(String createdBy,
                               EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)

setCreatedBy_Prefix

public void setCreatedBy_Prefix(String createdBy)

setCreatedBy_Prefix

public void setCreatedBy_Prefix(String createdBy,
                                EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.PrefixQueryBuilder> opLambda)

setCreatedBy_Wildcard

public void setCreatedBy_Wildcard(String createdBy)

setCreatedBy_Wildcard

public void setCreatedBy_Wildcard(String createdBy,
                                  EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.WildcardQueryBuilder> opLambda)

setCreatedBy_Regexp

public void setCreatedBy_Regexp(String createdBy)

setCreatedBy_Regexp

public void setCreatedBy_Regexp(String createdBy,
                                EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RegexpQueryBuilder> opLambda)

setCreatedBy_SpanTerm

public void setCreatedBy_SpanTerm(String createdBy)

setCreatedBy_SpanTerm

public void setCreatedBy_SpanTerm(String createdBy,
                                  EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.SpanTermQueryBuilder> opLambda)

setCreatedBy_GreaterThan

public void setCreatedBy_GreaterThan(String createdBy)

setCreatedBy_GreaterThan

public void setCreatedBy_GreaterThan(String createdBy,
                                     EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setCreatedBy_LessThan

public void setCreatedBy_LessThan(String createdBy)

setCreatedBy_LessThan

public void setCreatedBy_LessThan(String createdBy,
                                  EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setCreatedBy_GreaterEqual

public void setCreatedBy_GreaterEqual(String createdBy)

setCreatedBy_GreaterEqual

public void setCreatedBy_GreaterEqual(String createdBy,
                                      EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setCreatedBy_LessEqual

public void setCreatedBy_LessEqual(String createdBy)

setCreatedBy_LessEqual

public void setCreatedBy_LessEqual(String createdBy,
                                   EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setCreatedBy_Exists
```
public void setCreatedBy_Exists()
```

setCreatedBy_Exists

public void setCreatedBy_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.ExistsQueryBuilder> opLambda)

setCreatedBy_CommonTerms

public void setCreatedBy_CommonTerms(String createdBy)

setCreatedBy_CommonTerms

public void setCreatedBy_CommonTerms(String createdBy,
                                     EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.CommonTermsQueryBuilder> opLambda)

addOrderBy_CreatedBy_Asc

public BsWebConfigCQ addOrderBy_CreatedBy_Asc()

addOrderBy_CreatedBy_Desc

public BsWebConfigCQ addOrderBy_CreatedBy_Desc()

setCreatedTime_Equal

public void setCreatedTime_Equal(Long createdTime)

setCreatedTime_Equal

public void setCreatedTime_Equal(Long createdTime,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)

setCreatedTime_Term

public void setCreatedTime_Term(Long createdTime)

setCreatedTime_Term

public void setCreatedTime_Term(Long createdTime,
                                EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)

setCreatedTime_NotEqual

public void setCreatedTime_NotEqual(Long createdTime)

setCreatedTime_NotTerm

public void setCreatedTime_NotTerm(Long createdTime)

setCreatedTime_NotEqual

public void setCreatedTime_NotEqual(Long createdTime,
                                    EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)

setCreatedTime_NotTerm

public void setCreatedTime_NotTerm(Long createdTime,
                                   EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)

setCreatedTime_Terms

public void setCreatedTime_Terms(Collection<Long> createdTimeList)

setCreatedTime_Terms

public void setCreatedTime_Terms(Collection<Long> createdTimeList,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)

setCreatedTime_InScope

public void setCreatedTime_InScope(Collection<Long> createdTimeList)

setCreatedTime_InScope

public void setCreatedTime_InScope(Collection<Long> createdTimeList,
                                   EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)

setCreatedTime_Match

public void setCreatedTime_Match(Long createdTime)

setCreatedTime_Match

public void setCreatedTime_Match(Long createdTime,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)

setCreatedTime_MatchPhrase

public void setCreatedTime_MatchPhrase(Long createdTime)

setCreatedTime_MatchPhrase

public void setCreatedTime_MatchPhrase(Long createdTime,
                                       EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhraseQueryBuilder> opLambda)

setCreatedTime_MatchPhrasePrefix

public void setCreatedTime_MatchPhrasePrefix(Long createdTime)

setCreatedTime_MatchPhrasePrefix

public void setCreatedTime_MatchPhrasePrefix(Long createdTime,
                                             EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhrasePrefixQueryBuilder> opLambda)

setCreatedTime_Fuzzy

public void setCreatedTime_Fuzzy(Long createdTime)

setCreatedTime_Fuzzy

public void setCreatedTime_Fuzzy(Long createdTime,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)

setCreatedTime_GreaterThan

public void setCreatedTime_GreaterThan(Long createdTime)

setCreatedTime_GreaterThan

public void setCreatedTime_GreaterThan(Long createdTime,
                                       EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setCreatedTime_LessThan

public void setCreatedTime_LessThan(Long createdTime)

setCreatedTime_LessThan

public void setCreatedTime_LessThan(Long createdTime,
                                    EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setCreatedTime_GreaterEqual

public void setCreatedTime_GreaterEqual(Long createdTime)

setCreatedTime_GreaterEqual

public void setCreatedTime_GreaterEqual(Long createdTime,
                                        EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setCreatedTime_LessEqual

public void setCreatedTime_LessEqual(Long createdTime)

setCreatedTime_LessEqual

public void setCreatedTime_LessEqual(Long createdTime,
                                     EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setCreatedTime_Exists
```
public void setCreatedTime_Exists()
```

setCreatedTime_Exists

public void setCreatedTime_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.ExistsQueryBuilder> opLambda)

setCreatedTime_CommonTerms

public void setCreatedTime_CommonTerms(Long createdTime)

setCreatedTime_CommonTerms

public void setCreatedTime_CommonTerms(Long createdTime,
                                       EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.CommonTermsQueryBuilder> opLambda)

addOrderBy_CreatedTime_Asc

public BsWebConfigCQ addOrderBy_CreatedTime_Asc()

addOrderBy_CreatedTime_Desc

public BsWebConfigCQ addOrderBy_CreatedTime_Desc()

setDepth_Equal

public void setDepth_Equal(Integer depth)

setDepth_Equal

public void setDepth_Equal(Integer depth,
                           EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)

setDepth_Term

public void setDepth_Term(Integer depth)

setDepth_Term

public void setDepth_Term(Integer depth,
                          EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)

setDepth_NotEqual

public void setDepth_NotEqual(Integer depth)

setDepth_NotTerm

public void setDepth_NotTerm(Integer depth)

setDepth_NotEqual

public void setDepth_NotEqual(Integer depth,
                              EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)

setDepth_NotTerm

public void setDepth_NotTerm(Integer depth,
                             EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)

setDepth_Terms

public void setDepth_Terms(Collection<Integer> depthList)

setDepth_Terms

public void setDepth_Terms(Collection<Integer> depthList,
                           EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)

setDepth_InScope

public void setDepth_InScope(Collection<Integer> depthList)

setDepth_InScope

public void setDepth_InScope(Collection<Integer> depthList,
                             EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)

setDepth_Match

public void setDepth_Match(Integer depth)

setDepth_Match

public void setDepth_Match(Integer depth,
                           EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)

setDepth_MatchPhrase

public void setDepth_MatchPhrase(Integer depth)

setDepth_MatchPhrase

public void setDepth_MatchPhrase(Integer depth,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhraseQueryBuilder> opLambda)

setDepth_MatchPhrasePrefix

public void setDepth_MatchPhrasePrefix(Integer depth)

setDepth_MatchPhrasePrefix

public void setDepth_MatchPhrasePrefix(Integer depth,
                                       EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhrasePrefixQueryBuilder> opLambda)

setDepth_Fuzzy

public void setDepth_Fuzzy(Integer depth)

setDepth_Fuzzy

public void setDepth_Fuzzy(Integer depth,
                           EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)

setDepth_GreaterThan

public void setDepth_GreaterThan(Integer depth)

setDepth_GreaterThan

public void setDepth_GreaterThan(Integer depth,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setDepth_LessThan

public void setDepth_LessThan(Integer depth)

setDepth_LessThan

public void setDepth_LessThan(Integer depth,
                              EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setDepth_GreaterEqual

public void setDepth_GreaterEqual(Integer depth)

setDepth_GreaterEqual

public void setDepth_GreaterEqual(Integer depth,
                                  EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setDepth_LessEqual

public void setDepth_LessEqual(Integer depth)

setDepth_LessEqual

public void setDepth_LessEqual(Integer depth,
                               EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setDepth_Exists
```
public void setDepth_Exists()
```

setDepth_Exists

public void setDepth_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.ExistsQueryBuilder> opLambda)

setDepth_CommonTerms

public void setDepth_CommonTerms(Integer depth)

setDepth_CommonTerms

public void setDepth_CommonTerms(Integer depth,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.CommonTermsQueryBuilder> opLambda)

addOrderBy_Depth_Asc

public BsWebConfigCQ addOrderBy_Depth_Asc()

addOrderBy_Depth_Desc

public BsWebConfigCQ addOrderBy_Depth_Desc()

setDescription_Equal

public void setDescription_Equal(String description)

setDescription_Equal

public void setDescription_Equal(String description,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)

setDescription_Term

public void setDescription_Term(String description)

setDescription_Term

public void setDescription_Term(String description,
                                EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)

setDescription_NotEqual

public void setDescription_NotEqual(String description)

setDescription_NotTerm

public void setDescription_NotTerm(String description)

setDescription_NotEqual

public void setDescription_NotEqual(String description,
                                    EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)

setDescription_NotTerm

public void setDescription_NotTerm(String description,
                                   EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)

setDescription_Terms

public void setDescription_Terms(Collection<String> descriptionList)

setDescription_Terms

public void setDescription_Terms(Collection<String> descriptionList,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)

setDescription_InScope

public void setDescription_InScope(Collection<String> descriptionList)

setDescription_InScope

public void setDescription_InScope(Collection<String> descriptionList,
                                   EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)

setDescription_Match

public void setDescription_Match(String description)

setDescription_Match

public void setDescription_Match(String description,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)

setDescription_MatchPhrase

public void setDescription_MatchPhrase(String description)

setDescription_MatchPhrase

public void setDescription_MatchPhrase(String description,
                                       EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhraseQueryBuilder> opLambda)

setDescription_MatchPhrasePrefix

public void setDescription_MatchPhrasePrefix(String description)

setDescription_MatchPhrasePrefix

public void setDescription_MatchPhrasePrefix(String description,
                                             EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhrasePrefixQueryBuilder> opLambda)

setDescription_Fuzzy

public void setDescription_Fuzzy(String description)

setDescription_Fuzzy

public void setDescription_Fuzzy(String description,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)

setDescription_Prefix

public void setDescription_Prefix(String description)

setDescription_Prefix

public void setDescription_Prefix(String description,
                                  EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.PrefixQueryBuilder> opLambda)

setDescription_Wildcard

public void setDescription_Wildcard(String description)

setDescription_Wildcard

public void setDescription_Wildcard(String description,
                                    EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.WildcardQueryBuilder> opLambda)

setDescription_Regexp

public void setDescription_Regexp(String description)

setDescription_Regexp

public void setDescription_Regexp(String description,
                                  EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RegexpQueryBuilder> opLambda)

setDescription_SpanTerm

public void setDescription_SpanTerm(String description)

setDescription_SpanTerm

public void setDescription_SpanTerm(String description,
                                    EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.SpanTermQueryBuilder> opLambda)

setDescription_GreaterThan

public void setDescription_GreaterThan(String description)

setDescription_GreaterThan

public void setDescription_GreaterThan(String description,
                                       EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setDescription_LessThan

public void setDescription_LessThan(String description)

setDescription_LessThan

public void setDescription_LessThan(String description,
                                    EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setDescription_GreaterEqual

public void setDescription_GreaterEqual(String description)

setDescription_GreaterEqual

public void setDescription_GreaterEqual(String description,
                                        EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setDescription_LessEqual

public void setDescription_LessEqual(String description)

setDescription_LessEqual

public void setDescription_LessEqual(String description,
                                     EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setDescription_Exists
```
public void setDescription_Exists()
```

setDescription_Exists

public void setDescription_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.ExistsQueryBuilder> opLambda)

setDescription_CommonTerms

public void setDescription_CommonTerms(String description)

setDescription_CommonTerms

public void setDescription_CommonTerms(String description,
                                       EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.CommonTermsQueryBuilder> opLambda)

setExcludedDocUrls_Equal

public void setExcludedDocUrls_Equal(String excludedDocUrls)

setExcludedDocUrls_Equal

public void setExcludedDocUrls_Equal(String excludedDocUrls,
                                     EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)

setExcludedDocUrls_Term

public void setExcludedDocUrls_Term(String excludedDocUrls)

setExcludedDocUrls_Term

public void setExcludedDocUrls_Term(String excludedDocUrls,
                                    EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)

setExcludedDocUrls_NotEqual

public void setExcludedDocUrls_NotEqual(String excludedDocUrls)

setExcludedDocUrls_NotTerm

public void setExcludedDocUrls_NotTerm(String excludedDocUrls)

setExcludedDocUrls_NotEqual

public void setExcludedDocUrls_NotEqual(String excludedDocUrls,
                                        EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)

setExcludedDocUrls_NotTerm

public void setExcludedDocUrls_NotTerm(String excludedDocUrls,
                                       EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)

setExcludedDocUrls_Terms

public void setExcludedDocUrls_Terms(Collection<String> excludedDocUrlsList)

setExcludedDocUrls_Terms

public void setExcludedDocUrls_Terms(Collection<String> excludedDocUrlsList,
                                     EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)

setExcludedDocUrls_InScope

public void setExcludedDocUrls_InScope(Collection<String> excludedDocUrlsList)

setExcludedDocUrls_InScope

public void setExcludedDocUrls_InScope(Collection<String> excludedDocUrlsList,
                                       EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)

setExcludedDocUrls_Match

public void setExcludedDocUrls_Match(String excludedDocUrls)

setExcludedDocUrls_Match

public void setExcludedDocUrls_Match(String excludedDocUrls,
                                     EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)

setExcludedDocUrls_MatchPhrase

public void setExcludedDocUrls_MatchPhrase(String excludedDocUrls)

setExcludedDocUrls_MatchPhrase

public void setExcludedDocUrls_MatchPhrase(String excludedDocUrls,
                                           EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhraseQueryBuilder> opLambda)

setExcludedDocUrls_MatchPhrasePrefix

public void setExcludedDocUrls_MatchPhrasePrefix(String excludedDocUrls)

setExcludedDocUrls_MatchPhrasePrefix

public void setExcludedDocUrls_MatchPhrasePrefix(String excludedDocUrls,
                                                 EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhrasePrefixQueryBuilder> opLambda)

setExcludedDocUrls_Fuzzy

public void setExcludedDocUrls_Fuzzy(String excludedDocUrls)

setExcludedDocUrls_Fuzzy

public void setExcludedDocUrls_Fuzzy(String excludedDocUrls,
                                     EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)

setExcludedDocUrls_Prefix

public void setExcludedDocUrls_Prefix(String excludedDocUrls)

setExcludedDocUrls_Prefix

public void setExcludedDocUrls_Prefix(String excludedDocUrls,
                                      EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.PrefixQueryBuilder> opLambda)

setExcludedDocUrls_Wildcard

public void setExcludedDocUrls_Wildcard(String excludedDocUrls)

setExcludedDocUrls_Wildcard

public void setExcludedDocUrls_Wildcard(String excludedDocUrls,
                                        EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.WildcardQueryBuilder> opLambda)

setExcludedDocUrls_Regexp

public void setExcludedDocUrls_Regexp(String excludedDocUrls)

setExcludedDocUrls_Regexp

public void setExcludedDocUrls_Regexp(String excludedDocUrls,
                                      EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RegexpQueryBuilder> opLambda)

setExcludedDocUrls_SpanTerm

public void setExcludedDocUrls_SpanTerm(String excludedDocUrls)

setExcludedDocUrls_SpanTerm

public void setExcludedDocUrls_SpanTerm(String excludedDocUrls,
                                        EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.SpanTermQueryBuilder> opLambda)

setExcludedDocUrls_GreaterThan

public void setExcludedDocUrls_GreaterThan(String excludedDocUrls)

setExcludedDocUrls_GreaterThan

public void setExcludedDocUrls_GreaterThan(String excludedDocUrls,
                                           EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setExcludedDocUrls_LessThan

public void setExcludedDocUrls_LessThan(String excludedDocUrls)

setExcludedDocUrls_LessThan

public void setExcludedDocUrls_LessThan(String excludedDocUrls,
                                        EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setExcludedDocUrls_GreaterEqual

public void setExcludedDocUrls_GreaterEqual(String excludedDocUrls)

setExcludedDocUrls_GreaterEqual

public void setExcludedDocUrls_GreaterEqual(String excludedDocUrls,
                                            EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setExcludedDocUrls_LessEqual

public void setExcludedDocUrls_LessEqual(String excludedDocUrls)

setExcludedDocUrls_LessEqual

public void setExcludedDocUrls_LessEqual(String excludedDocUrls,
                                         EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setExcludedDocUrls_Exists

public void setExcludedDocUrls_Exists()

setExcludedDocUrls_Exists

public void setExcludedDocUrls_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.ExistsQueryBuilder> opLambda)

setExcludedDocUrls_CommonTerms

public void setExcludedDocUrls_CommonTerms(String excludedDocUrls)

setExcludedDocUrls_CommonTerms

public void setExcludedDocUrls_CommonTerms(String excludedDocUrls,
                                           EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.CommonTermsQueryBuilder> opLambda)

addOrderBy_ExcludedDocUrls_Asc

public BsWebConfigCQ addOrderBy_ExcludedDocUrls_Asc()

addOrderBy_ExcludedDocUrls_Desc

public BsWebConfigCQ addOrderBy_ExcludedDocUrls_Desc()

setExcludedUrls_Equal

public void setExcludedUrls_Equal(String excludedUrls)

setExcludedUrls_Equal

public void setExcludedUrls_Equal(String excludedUrls,
                                  EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)

setExcludedUrls_Term

public void setExcludedUrls_Term(String excludedUrls)

setExcludedUrls_Term

public void setExcludedUrls_Term(String excludedUrls,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)

setExcludedUrls_NotEqual

public void setExcludedUrls_NotEqual(String excludedUrls)

setExcludedUrls_NotTerm

public void setExcludedUrls_NotTerm(String excludedUrls)

setExcludedUrls_NotEqual

public void setExcludedUrls_NotEqual(String excludedUrls,
                                     EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)

setExcludedUrls_NotTerm

public void setExcludedUrls_NotTerm(String excludedUrls,
                                    EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)

setExcludedUrls_Terms

public void setExcludedUrls_Terms(Collection<String> excludedUrlsList)

setExcludedUrls_Terms

public void setExcludedUrls_Terms(Collection<String> excludedUrlsList,
                                  EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)

setExcludedUrls_InScope

public void setExcludedUrls_InScope(Collection<String> excludedUrlsList)

setExcludedUrls_InScope

public void setExcludedUrls_InScope(Collection<String> excludedUrlsList,
                                    EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)

setExcludedUrls_Match

public void setExcludedUrls_Match(String excludedUrls)

setExcludedUrls_Match

public void setExcludedUrls_Match(String excludedUrls,
                                  EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)

setExcludedUrls_MatchPhrase

public void setExcludedUrls_MatchPhrase(String excludedUrls)

setExcludedUrls_MatchPhrase

public void setExcludedUrls_MatchPhrase(String excludedUrls,
                                        EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhraseQueryBuilder> opLambda)

setExcludedUrls_MatchPhrasePrefix

public void setExcludedUrls_MatchPhrasePrefix(String excludedUrls)

setExcludedUrls_MatchPhrasePrefix

public void setExcludedUrls_MatchPhrasePrefix(String excludedUrls,
                                              EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhrasePrefixQueryBuilder> opLambda)

setExcludedUrls_Fuzzy

public void setExcludedUrls_Fuzzy(String excludedUrls)

setExcludedUrls_Fuzzy

public void setExcludedUrls_Fuzzy(String excludedUrls,
                                  EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)

setExcludedUrls_Prefix

public void setExcludedUrls_Prefix(String excludedUrls)

setExcludedUrls_Prefix

public void setExcludedUrls_Prefix(String excludedUrls,
                                   EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.PrefixQueryBuilder> opLambda)

setExcludedUrls_Wildcard

public void setExcludedUrls_Wildcard(String excludedUrls)

setExcludedUrls_Wildcard

public void setExcludedUrls_Wildcard(String excludedUrls,
                                     EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.WildcardQueryBuilder> opLambda)

setExcludedUrls_Regexp

public void setExcludedUrls_Regexp(String excludedUrls)

setExcludedUrls_Regexp

public void setExcludedUrls_Regexp(String excludedUrls,
                                   EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RegexpQueryBuilder> opLambda)

setExcludedUrls_SpanTerm

public void setExcludedUrls_SpanTerm(String excludedUrls)

setExcludedUrls_SpanTerm

public void setExcludedUrls_SpanTerm(String excludedUrls,
                                     EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.SpanTermQueryBuilder> opLambda)

setExcludedUrls_GreaterThan

public void setExcludedUrls_GreaterThan(String excludedUrls)

setExcludedUrls_GreaterThan

public void setExcludedUrls_GreaterThan(String excludedUrls,
                                        EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setExcludedUrls_LessThan

public void setExcludedUrls_LessThan(String excludedUrls)

setExcludedUrls_LessThan

public void setExcludedUrls_LessThan(String excludedUrls,
                                     EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setExcludedUrls_GreaterEqual

public void setExcludedUrls_GreaterEqual(String excludedUrls)

setExcludedUrls_GreaterEqual

public void setExcludedUrls_GreaterEqual(String excludedUrls,
                                         EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setExcludedUrls_LessEqual

public void setExcludedUrls_LessEqual(String excludedUrls)

setExcludedUrls_LessEqual

public void setExcludedUrls_LessEqual(String excludedUrls,
                                      EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setExcludedUrls_Exists
```
public void setExcludedUrls_Exists()
```

setExcludedUrls_Exists

public void setExcludedUrls_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.ExistsQueryBuilder> opLambda)

setExcludedUrls_CommonTerms

public void setExcludedUrls_CommonTerms(String excludedUrls)

setExcludedUrls_CommonTerms

public void setExcludedUrls_CommonTerms(String excludedUrls,
                                        EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.CommonTermsQueryBuilder> opLambda)

addOrderBy_ExcludedUrls_Asc

public BsWebConfigCQ addOrderBy_ExcludedUrls_Asc()

addOrderBy_ExcludedUrls_Desc

public BsWebConfigCQ addOrderBy_ExcludedUrls_Desc()

setIncludedDocUrls_Equal

public void setIncludedDocUrls_Equal(String includedDocUrls)

setIncludedDocUrls_Equal

public void setIncludedDocUrls_Equal(String includedDocUrls,
                                     EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)

setIncludedDocUrls_Term

public void setIncludedDocUrls_Term(String includedDocUrls)

setIncludedDocUrls_Term

public void setIncludedDocUrls_Term(String includedDocUrls,
                                    EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)

setIncludedDocUrls_NotEqual

public void setIncludedDocUrls_NotEqual(String includedDocUrls)

setIncludedDocUrls_NotTerm

public void setIncludedDocUrls_NotTerm(String includedDocUrls)

setIncludedDocUrls_NotEqual

public void setIncludedDocUrls_NotEqual(String includedDocUrls,
                                        EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)

setIncludedDocUrls_NotTerm

public void setIncludedDocUrls_NotTerm(String includedDocUrls,
                                       EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)

setIncludedDocUrls_Terms

public void setIncludedDocUrls_Terms(Collection<String> includedDocUrlsList)

setIncludedDocUrls_Terms

public void setIncludedDocUrls_Terms(Collection<String> includedDocUrlsList,
                                     EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)

setIncludedDocUrls_InScope

public void setIncludedDocUrls_InScope(Collection<String> includedDocUrlsList)

setIncludedDocUrls_InScope

public void setIncludedDocUrls_InScope(Collection<String> includedDocUrlsList,
                                       EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)

setIncludedDocUrls_Match

public void setIncludedDocUrls_Match(String includedDocUrls)

setIncludedDocUrls_Match

public void setIncludedDocUrls_Match(String includedDocUrls,
                                     EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)

setIncludedDocUrls_MatchPhrase

public void setIncludedDocUrls_MatchPhrase(String includedDocUrls)

setIncludedDocUrls_MatchPhrase

public void setIncludedDocUrls_MatchPhrase(String includedDocUrls,
                                           EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhraseQueryBuilder> opLambda)

setIncludedDocUrls_MatchPhrasePrefix

public void setIncludedDocUrls_MatchPhrasePrefix(String includedDocUrls)

setIncludedDocUrls_MatchPhrasePrefix

public void setIncludedDocUrls_MatchPhrasePrefix(String includedDocUrls,
                                                 EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhrasePrefixQueryBuilder> opLambda)

setIncludedDocUrls_Fuzzy

public void setIncludedDocUrls_Fuzzy(String includedDocUrls)

setIncludedDocUrls_Fuzzy

public void setIncludedDocUrls_Fuzzy(String includedDocUrls,
                                     EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)

setIncludedDocUrls_Prefix

public void setIncludedDocUrls_Prefix(String includedDocUrls)

setIncludedDocUrls_Prefix

public void setIncludedDocUrls_Prefix(String includedDocUrls,
                                      EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.PrefixQueryBuilder> opLambda)

setIncludedDocUrls_Wildcard

public void setIncludedDocUrls_Wildcard(String includedDocUrls)

setIncludedDocUrls_Wildcard

public void setIncludedDocUrls_Wildcard(String includedDocUrls,
                                        EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.WildcardQueryBuilder> opLambda)

setIncludedDocUrls_Regexp

public void setIncludedDocUrls_Regexp(String includedDocUrls)

setIncludedDocUrls_Regexp

public void setIncludedDocUrls_Regexp(String includedDocUrls,
                                      EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RegexpQueryBuilder> opLambda)

setIncludedDocUrls_SpanTerm

public void setIncludedDocUrls_SpanTerm(String includedDocUrls)

setIncludedDocUrls_SpanTerm

public void setIncludedDocUrls_SpanTerm(String includedDocUrls,
                                        EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.SpanTermQueryBuilder> opLambda)

setIncludedDocUrls_GreaterThan

public void setIncludedDocUrls_GreaterThan(String includedDocUrls)

setIncludedDocUrls_GreaterThan

public void setIncludedDocUrls_GreaterThan(String includedDocUrls,
                                           EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setIncludedDocUrls_LessThan

public void setIncludedDocUrls_LessThan(String includedDocUrls)

setIncludedDocUrls_LessThan

public void setIncludedDocUrls_LessThan(String includedDocUrls,
                                        EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setIncludedDocUrls_GreaterEqual

public void setIncludedDocUrls_GreaterEqual(String includedDocUrls)

setIncludedDocUrls_GreaterEqual

public void setIncludedDocUrls_GreaterEqual(String includedDocUrls,
                                            EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setIncludedDocUrls_LessEqual

public void setIncludedDocUrls_LessEqual(String includedDocUrls)

setIncludedDocUrls_LessEqual

public void setIncludedDocUrls_LessEqual(String includedDocUrls,
                                         EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setIncludedDocUrls_Exists

public void setIncludedDocUrls_Exists()

setIncludedDocUrls_Exists

public void setIncludedDocUrls_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.ExistsQueryBuilder> opLambda)

setIncludedDocUrls_CommonTerms

public void setIncludedDocUrls_CommonTerms(String includedDocUrls)

setIncludedDocUrls_CommonTerms

public void setIncludedDocUrls_CommonTerms(String includedDocUrls,
                                           EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.CommonTermsQueryBuilder> opLambda)

addOrderBy_IncludedDocUrls_Asc

public BsWebConfigCQ addOrderBy_IncludedDocUrls_Asc()

addOrderBy_IncludedDocUrls_Desc

public BsWebConfigCQ addOrderBy_IncludedDocUrls_Desc()

setIncludedUrls_Equal

public void setIncludedUrls_Equal(String includedUrls)

setIncludedUrls_Equal

public void setIncludedUrls_Equal(String includedUrls,
                                  EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)

setIncludedUrls_Term

public void setIncludedUrls_Term(String includedUrls)

setIncludedUrls_Term

public void setIncludedUrls_Term(String includedUrls,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)

setIncludedUrls_NotEqual

public void setIncludedUrls_NotEqual(String includedUrls)

setIncludedUrls_NotTerm

public void setIncludedUrls_NotTerm(String includedUrls)

setIncludedUrls_NotEqual

public void setIncludedUrls_NotEqual(String includedUrls,
                                     EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)

setIncludedUrls_NotTerm

public void setIncludedUrls_NotTerm(String includedUrls,
                                    EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)

setIncludedUrls_Terms

public void setIncludedUrls_Terms(Collection<String> includedUrlsList)

setIncludedUrls_Terms

public void setIncludedUrls_Terms(Collection<String> includedUrlsList,
                                  EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)

setIncludedUrls_InScope

public void setIncludedUrls_InScope(Collection<String> includedUrlsList)

setIncludedUrls_InScope

public void setIncludedUrls_InScope(Collection<String> includedUrlsList,
                                    EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)

setIncludedUrls_Match

public void setIncludedUrls_Match(String includedUrls)

setIncludedUrls_Match

public void setIncludedUrls_Match(String includedUrls,
                                  EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)

setIncludedUrls_MatchPhrase

public void setIncludedUrls_MatchPhrase(String includedUrls)

setIncludedUrls_MatchPhrase

public void setIncludedUrls_MatchPhrase(String includedUrls,
                                        EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhraseQueryBuilder> opLambda)

setIncludedUrls_MatchPhrasePrefix

public void setIncludedUrls_MatchPhrasePrefix(String includedUrls)

setIncludedUrls_MatchPhrasePrefix

public void setIncludedUrls_MatchPhrasePrefix(String includedUrls,
                                              EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhrasePrefixQueryBuilder> opLambda)

setIncludedUrls_Fuzzy

public void setIncludedUrls_Fuzzy(String includedUrls)

setIncludedUrls_Fuzzy

public void setIncludedUrls_Fuzzy(String includedUrls,
                                  EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)

setIncludedUrls_Prefix

public void setIncludedUrls_Prefix(String includedUrls)

setIncludedUrls_Prefix

public void setIncludedUrls_Prefix(String includedUrls,
                                   EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.PrefixQueryBuilder> opLambda)

setIncludedUrls_Wildcard

public void setIncludedUrls_Wildcard(String includedUrls)

setIncludedUrls_Wildcard

public void setIncludedUrls_Wildcard(String includedUrls,
                                     EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.WildcardQueryBuilder> opLambda)

setIncludedUrls_Regexp

public void setIncludedUrls_Regexp(String includedUrls)

setIncludedUrls_Regexp

public void setIncludedUrls_Regexp(String includedUrls,
                                   EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RegexpQueryBuilder> opLambda)

setIncludedUrls_SpanTerm

public void setIncludedUrls_SpanTerm(String includedUrls)

setIncludedUrls_SpanTerm

public void setIncludedUrls_SpanTerm(String includedUrls,
                                     EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.SpanTermQueryBuilder> opLambda)

setIncludedUrls_GreaterThan

public void setIncludedUrls_GreaterThan(String includedUrls)

setIncludedUrls_GreaterThan

public void setIncludedUrls_GreaterThan(String includedUrls,
                                        EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setIncludedUrls_LessThan

public void setIncludedUrls_LessThan(String includedUrls)

setIncludedUrls_LessThan

public void setIncludedUrls_LessThan(String includedUrls,
                                     EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setIncludedUrls_GreaterEqual

public void setIncludedUrls_GreaterEqual(String includedUrls)

setIncludedUrls_GreaterEqual

public void setIncludedUrls_GreaterEqual(String includedUrls,
                                         EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setIncludedUrls_LessEqual

public void setIncludedUrls_LessEqual(String includedUrls)

setIncludedUrls_LessEqual

public void setIncludedUrls_LessEqual(String includedUrls,
                                      EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setIncludedUrls_Exists
```
public void setIncludedUrls_Exists()
```

setIncludedUrls_Exists

public void setIncludedUrls_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.ExistsQueryBuilder> opLambda)

setIncludedUrls_CommonTerms

public void setIncludedUrls_CommonTerms(String includedUrls)

setIncludedUrls_CommonTerms

public void setIncludedUrls_CommonTerms(String includedUrls,
                                        EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.CommonTermsQueryBuilder> opLambda)

addOrderBy_IncludedUrls_Asc

public BsWebConfigCQ addOrderBy_IncludedUrls_Asc()

addOrderBy_IncludedUrls_Desc

public BsWebConfigCQ addOrderBy_IncludedUrls_Desc()

setIntervalTime_Equal

public void setIntervalTime_Equal(Integer intervalTime)

setIntervalTime_Equal

public void setIntervalTime_Equal(Integer intervalTime,
                                  EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)

setIntervalTime_Term

public void setIntervalTime_Term(Integer intervalTime)

setIntervalTime_Term

public void setIntervalTime_Term(Integer intervalTime,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)

setIntervalTime_NotEqual

public void setIntervalTime_NotEqual(Integer intervalTime)

setIntervalTime_NotTerm

public void setIntervalTime_NotTerm(Integer intervalTime)

setIntervalTime_NotEqual

public void setIntervalTime_NotEqual(Integer intervalTime,
                                     EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)

setIntervalTime_NotTerm

public void setIntervalTime_NotTerm(Integer intervalTime,
                                    EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)

setIntervalTime_Terms

public void setIntervalTime_Terms(Collection<Integer> intervalTimeList)

setIntervalTime_Terms

public void setIntervalTime_Terms(Collection<Integer> intervalTimeList,
                                  EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)

setIntervalTime_InScope

public void setIntervalTime_InScope(Collection<Integer> intervalTimeList)

setIntervalTime_InScope

public void setIntervalTime_InScope(Collection<Integer> intervalTimeList,
                                    EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)

setIntervalTime_Match

public void setIntervalTime_Match(Integer intervalTime)

setIntervalTime_Match

public void setIntervalTime_Match(Integer intervalTime,
                                  EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)

setIntervalTime_MatchPhrase

public void setIntervalTime_MatchPhrase(Integer intervalTime)

setIntervalTime_MatchPhrase

public void setIntervalTime_MatchPhrase(Integer intervalTime,
                                        EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhraseQueryBuilder> opLambda)

setIntervalTime_MatchPhrasePrefix

public void setIntervalTime_MatchPhrasePrefix(Integer intervalTime)

setIntervalTime_MatchPhrasePrefix

public void setIntervalTime_MatchPhrasePrefix(Integer intervalTime,
                                              EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhrasePrefixQueryBuilder> opLambda)

setIntervalTime_Fuzzy

public void setIntervalTime_Fuzzy(Integer intervalTime)

setIntervalTime_Fuzzy

public void setIntervalTime_Fuzzy(Integer intervalTime,
                                  EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)

setIntervalTime_GreaterThan

public void setIntervalTime_GreaterThan(Integer intervalTime)

setIntervalTime_GreaterThan

public void setIntervalTime_GreaterThan(Integer intervalTime,
                                        EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setIntervalTime_LessThan

public void setIntervalTime_LessThan(Integer intervalTime)

setIntervalTime_LessThan

public void setIntervalTime_LessThan(Integer intervalTime,
                                     EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setIntervalTime_GreaterEqual

public void setIntervalTime_GreaterEqual(Integer intervalTime)

setIntervalTime_GreaterEqual

public void setIntervalTime_GreaterEqual(Integer intervalTime,
                                         EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setIntervalTime_LessEqual

public void setIntervalTime_LessEqual(Integer intervalTime)

setIntervalTime_LessEqual

public void setIntervalTime_LessEqual(Integer intervalTime,
                                      EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setIntervalTime_Exists
```
public void setIntervalTime_Exists()
```

setIntervalTime_Exists

public void setIntervalTime_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.ExistsQueryBuilder> opLambda)

setIntervalTime_CommonTerms

public void setIntervalTime_CommonTerms(Integer intervalTime)

setIntervalTime_CommonTerms

public void setIntervalTime_CommonTerms(Integer intervalTime,
                                        EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.CommonTermsQueryBuilder> opLambda)

addOrderBy_IntervalTime_Asc

public BsWebConfigCQ addOrderBy_IntervalTime_Asc()

addOrderBy_IntervalTime_Desc

public BsWebConfigCQ addOrderBy_IntervalTime_Desc()

setMaxAccessCount_Equal

public void setMaxAccessCount_Equal(Long maxAccessCount)

setMaxAccessCount_Equal

public void setMaxAccessCount_Equal(Long maxAccessCount,
                                    EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)

setMaxAccessCount_Term

public void setMaxAccessCount_Term(Long maxAccessCount)

setMaxAccessCount_Term

public void setMaxAccessCount_Term(Long maxAccessCount,
                                   EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)

setMaxAccessCount_NotEqual

public void setMaxAccessCount_NotEqual(Long maxAccessCount)

setMaxAccessCount_NotTerm

public void setMaxAccessCount_NotTerm(Long maxAccessCount)

setMaxAccessCount_NotEqual

public void setMaxAccessCount_NotEqual(Long maxAccessCount,
                                       EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)

setMaxAccessCount_NotTerm

public void setMaxAccessCount_NotTerm(Long maxAccessCount,
                                      EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)

setMaxAccessCount_Terms

public void setMaxAccessCount_Terms(Collection<Long> maxAccessCountList)

setMaxAccessCount_Terms

public void setMaxAccessCount_Terms(Collection<Long> maxAccessCountList,
                                    EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)

setMaxAccessCount_InScope

public void setMaxAccessCount_InScope(Collection<Long> maxAccessCountList)

setMaxAccessCount_InScope

public void setMaxAccessCount_InScope(Collection<Long> maxAccessCountList,
                                      EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)

setMaxAccessCount_Match

public void setMaxAccessCount_Match(Long maxAccessCount)

setMaxAccessCount_Match

public void setMaxAccessCount_Match(Long maxAccessCount,
                                    EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)

setMaxAccessCount_MatchPhrase

public void setMaxAccessCount_MatchPhrase(Long maxAccessCount)

setMaxAccessCount_MatchPhrase

public void setMaxAccessCount_MatchPhrase(Long maxAccessCount,
                                          EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhraseQueryBuilder> opLambda)

setMaxAccessCount_MatchPhrasePrefix

public void setMaxAccessCount_MatchPhrasePrefix(Long maxAccessCount)

setMaxAccessCount_MatchPhrasePrefix

public void setMaxAccessCount_MatchPhrasePrefix(Long maxAccessCount,
                                                EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhrasePrefixQueryBuilder> opLambda)

setMaxAccessCount_Fuzzy

public void setMaxAccessCount_Fuzzy(Long maxAccessCount)

setMaxAccessCount_Fuzzy

public void setMaxAccessCount_Fuzzy(Long maxAccessCount,
                                    EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)

setMaxAccessCount_GreaterThan

public void setMaxAccessCount_GreaterThan(Long maxAccessCount)

setMaxAccessCount_GreaterThan

public void setMaxAccessCount_GreaterThan(Long maxAccessCount,
                                          EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setMaxAccessCount_LessThan

public void setMaxAccessCount_LessThan(Long maxAccessCount)

setMaxAccessCount_LessThan

public void setMaxAccessCount_LessThan(Long maxAccessCount,
                                       EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setMaxAccessCount_GreaterEqual

public void setMaxAccessCount_GreaterEqual(Long maxAccessCount)

setMaxAccessCount_GreaterEqual

public void setMaxAccessCount_GreaterEqual(Long maxAccessCount,
                                           EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setMaxAccessCount_LessEqual

public void setMaxAccessCount_LessEqual(Long maxAccessCount)

setMaxAccessCount_LessEqual

public void setMaxAccessCount_LessEqual(Long maxAccessCount,
                                        EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setMaxAccessCount_Exists

public void setMaxAccessCount_Exists()

setMaxAccessCount_Exists

public void setMaxAccessCount_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.ExistsQueryBuilder> opLambda)

setMaxAccessCount_CommonTerms

public void setMaxAccessCount_CommonTerms(Long maxAccessCount)

setMaxAccessCount_CommonTerms

public void setMaxAccessCount_CommonTerms(Long maxAccessCount,
                                          EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.CommonTermsQueryBuilder> opLambda)

addOrderBy_MaxAccessCount_Asc

public BsWebConfigCQ addOrderBy_MaxAccessCount_Asc()

addOrderBy_MaxAccessCount_Desc

public BsWebConfigCQ addOrderBy_MaxAccessCount_Desc()

setName_Equal

public void setName_Equal(String name)

setName_Equal

public void setName_Equal(String name,
                          EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)

setName_Term

public void setName_Term(String name)

setName_Term

public void setName_Term(String name,
                         EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)

setName_NotEqual

public void setName_NotEqual(String name)

setName_NotTerm

public void setName_NotTerm(String name)

setName_NotEqual

public void setName_NotEqual(String name,
                             EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)

setName_NotTerm

public void setName_NotTerm(String name,
                            EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)

setName_Terms

public void setName_Terms(Collection<String> nameList)

setName_Terms

public void setName_Terms(Collection<String> nameList,
                          EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)

setName_InScope

public void setName_InScope(Collection<String> nameList)

setName_InScope

public void setName_InScope(Collection<String> nameList,
                            EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)

setName_Match

public void setName_Match(String name)

setName_Match

public void setName_Match(String name,
                          EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)

setName_MatchPhrase

public void setName_MatchPhrase(String name)

setName_MatchPhrase

public void setName_MatchPhrase(String name,
                                EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhraseQueryBuilder> opLambda)

setName_MatchPhrasePrefix

public void setName_MatchPhrasePrefix(String name)

setName_MatchPhrasePrefix

public void setName_MatchPhrasePrefix(String name,
                                      EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhrasePrefixQueryBuilder> opLambda)

setName_Fuzzy

public void setName_Fuzzy(String name)

setName_Fuzzy

public void setName_Fuzzy(String name,
                          EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)

setName_Prefix

public void setName_Prefix(String name)

setName_Prefix

public void setName_Prefix(String name,
                           EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.PrefixQueryBuilder> opLambda)

setName_Wildcard

public void setName_Wildcard(String name)

setName_Wildcard

public void setName_Wildcard(String name,
                             EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.WildcardQueryBuilder> opLambda)

setName_Regexp

public void setName_Regexp(String name)

setName_Regexp

public void setName_Regexp(String name,
                           EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RegexpQueryBuilder> opLambda)

setName_SpanTerm

public void setName_SpanTerm(String name)

setName_SpanTerm

public void setName_SpanTerm(String name,
                             EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.SpanTermQueryBuilder> opLambda)

setName_GreaterThan

public void setName_GreaterThan(String name)

setName_GreaterThan

public void setName_GreaterThan(String name,
                                EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setName_LessThan

public void setName_LessThan(String name)

setName_LessThan

public void setName_LessThan(String name,
                             EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setName_GreaterEqual

public void setName_GreaterEqual(String name)

setName_GreaterEqual

public void setName_GreaterEqual(String name,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setName_LessEqual

public void setName_LessEqual(String name)

setName_LessEqual

public void setName_LessEqual(String name,
                              EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setName_Exists
```
public void setName_Exists()
```

setName_Exists

public void setName_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.ExistsQueryBuilder> opLambda)

setName_CommonTerms

public void setName_CommonTerms(String name)

setName_CommonTerms

public void setName_CommonTerms(String name,
                                EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.CommonTermsQueryBuilder> opLambda)

addOrderBy_Name_Asc

public BsWebConfigCQ addOrderBy_Name_Asc()

addOrderBy_Name_Desc

public BsWebConfigCQ addOrderBy_Name_Desc()

setNumOfThread_Equal

public void setNumOfThread_Equal(Integer numOfThread)

setNumOfThread_Equal

public void setNumOfThread_Equal(Integer numOfThread,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)

setNumOfThread_Term

public void setNumOfThread_Term(Integer numOfThread)

setNumOfThread_Term

public void setNumOfThread_Term(Integer numOfThread,
                                EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)

setNumOfThread_NotEqual

public void setNumOfThread_NotEqual(Integer numOfThread)

setNumOfThread_NotTerm

public void setNumOfThread_NotTerm(Integer numOfThread)

setNumOfThread_NotEqual

public void setNumOfThread_NotEqual(Integer numOfThread,
                                    EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)

setNumOfThread_NotTerm

public void setNumOfThread_NotTerm(Integer numOfThread,
                                   EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)

setNumOfThread_Terms

public void setNumOfThread_Terms(Collection<Integer> numOfThreadList)

setNumOfThread_Terms

public void setNumOfThread_Terms(Collection<Integer> numOfThreadList,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)

setNumOfThread_InScope

public void setNumOfThread_InScope(Collection<Integer> numOfThreadList)

setNumOfThread_InScope

public void setNumOfThread_InScope(Collection<Integer> numOfThreadList,
                                   EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)

setNumOfThread_Match

public void setNumOfThread_Match(Integer numOfThread)

setNumOfThread_Match

public void setNumOfThread_Match(Integer numOfThread,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)

setNumOfThread_MatchPhrase

public void setNumOfThread_MatchPhrase(Integer numOfThread)

setNumOfThread_MatchPhrase

public void setNumOfThread_MatchPhrase(Integer numOfThread,
                                       EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhraseQueryBuilder> opLambda)

setNumOfThread_MatchPhrasePrefix

public void setNumOfThread_MatchPhrasePrefix(Integer numOfThread)

setNumOfThread_MatchPhrasePrefix

public void setNumOfThread_MatchPhrasePrefix(Integer numOfThread,
                                             EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhrasePrefixQueryBuilder> opLambda)

setNumOfThread_Fuzzy

public void setNumOfThread_Fuzzy(Integer numOfThread)

setNumOfThread_Fuzzy

public void setNumOfThread_Fuzzy(Integer numOfThread,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)

setNumOfThread_GreaterThan

public void setNumOfThread_GreaterThan(Integer numOfThread)

setNumOfThread_GreaterThan

public void setNumOfThread_GreaterThan(Integer numOfThread,
                                       EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setNumOfThread_LessThan

public void setNumOfThread_LessThan(Integer numOfThread)

setNumOfThread_LessThan

public void setNumOfThread_LessThan(Integer numOfThread,
                                    EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setNumOfThread_GreaterEqual

public void setNumOfThread_GreaterEqual(Integer numOfThread)

setNumOfThread_GreaterEqual

public void setNumOfThread_GreaterEqual(Integer numOfThread,
                                        EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setNumOfThread_LessEqual

public void setNumOfThread_LessEqual(Integer numOfThread)

setNumOfThread_LessEqual

public void setNumOfThread_LessEqual(Integer numOfThread,
                                     EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setNumOfThread_Exists
```
public void setNumOfThread_Exists()
```

setNumOfThread_Exists

public void setNumOfThread_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.ExistsQueryBuilder> opLambda)

setNumOfThread_CommonTerms

public void setNumOfThread_CommonTerms(Integer numOfThread)

setNumOfThread_CommonTerms

public void setNumOfThread_CommonTerms(Integer numOfThread,
                                       EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.CommonTermsQueryBuilder> opLambda)

addOrderBy_NumOfThread_Asc

public BsWebConfigCQ addOrderBy_NumOfThread_Asc()

addOrderBy_NumOfThread_Desc

public BsWebConfigCQ addOrderBy_NumOfThread_Desc()

setPermissions_Equal

public void setPermissions_Equal(String permissions)

setPermissions_Equal

public void setPermissions_Equal(String permissions,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)

setPermissions_Term

public void setPermissions_Term(String permissions)

setPermissions_Term

public void setPermissions_Term(String permissions,
                                EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)

setPermissions_NotEqual

public void setPermissions_NotEqual(String permissions)

setPermissions_NotTerm

public void setPermissions_NotTerm(String permissions)

setPermissions_NotEqual

public void setPermissions_NotEqual(String permissions,
                                    EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)

setPermissions_NotTerm

public void setPermissions_NotTerm(String permissions,
                                   EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)

setPermissions_Terms

public void setPermissions_Terms(Collection<String> permissionsList)

setPermissions_Terms

public void setPermissions_Terms(Collection<String> permissionsList,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)

setPermissions_InScope

public void setPermissions_InScope(Collection<String> permissionsList)

setPermissions_InScope

public void setPermissions_InScope(Collection<String> permissionsList,
                                   EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)

setPermissions_Match

public void setPermissions_Match(String permissions)

setPermissions_Match

public void setPermissions_Match(String permissions,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)

setPermissions_MatchPhrase

public void setPermissions_MatchPhrase(String permissions)

setPermissions_MatchPhrase

public void setPermissions_MatchPhrase(String permissions,
                                       EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhraseQueryBuilder> opLambda)

setPermissions_MatchPhrasePrefix

public void setPermissions_MatchPhrasePrefix(String permissions)

setPermissions_MatchPhrasePrefix

public void setPermissions_MatchPhrasePrefix(String permissions,
                                             EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhrasePrefixQueryBuilder> opLambda)

setPermissions_Fuzzy

public void setPermissions_Fuzzy(String permissions)

setPermissions_Fuzzy

public void setPermissions_Fuzzy(String permissions,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)

setPermissions_Prefix

public void setPermissions_Prefix(String permissions)

setPermissions_Prefix

public void setPermissions_Prefix(String permissions,
                                  EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.PrefixQueryBuilder> opLambda)

setPermissions_Wildcard

public void setPermissions_Wildcard(String permissions)

setPermissions_Wildcard

public void setPermissions_Wildcard(String permissions,
                                    EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.WildcardQueryBuilder> opLambda)

setPermissions_Regexp

public void setPermissions_Regexp(String permissions)

setPermissions_Regexp

public void setPermissions_Regexp(String permissions,
                                  EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RegexpQueryBuilder> opLambda)

setPermissions_SpanTerm

public void setPermissions_SpanTerm(String permissions)

setPermissions_SpanTerm

public void setPermissions_SpanTerm(String permissions,
                                    EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.SpanTermQueryBuilder> opLambda)

setPermissions_GreaterThan

public void setPermissions_GreaterThan(String permissions)

setPermissions_GreaterThan

public void setPermissions_GreaterThan(String permissions,
                                       EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setPermissions_LessThan

public void setPermissions_LessThan(String permissions)

setPermissions_LessThan

public void setPermissions_LessThan(String permissions,
                                    EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setPermissions_GreaterEqual

public void setPermissions_GreaterEqual(String permissions)

setPermissions_GreaterEqual

public void setPermissions_GreaterEqual(String permissions,
                                        EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setPermissions_LessEqual

public void setPermissions_LessEqual(String permissions)

setPermissions_LessEqual

public void setPermissions_LessEqual(String permissions,
                                     EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setPermissions_Exists
```
public void setPermissions_Exists()
```

setPermissions_Exists

public void setPermissions_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.ExistsQueryBuilder> opLambda)

setPermissions_CommonTerms

public void setPermissions_CommonTerms(String permissions)

setPermissions_CommonTerms

public void setPermissions_CommonTerms(String permissions,
                                       EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.CommonTermsQueryBuilder> opLambda)

addOrderBy_Permissions_Asc

public BsWebConfigCQ addOrderBy_Permissions_Asc()

addOrderBy_Permissions_Desc

public BsWebConfigCQ addOrderBy_Permissions_Desc()

setSortOrder_Equal

public void setSortOrder_Equal(Integer sortOrder)

setSortOrder_Equal

public void setSortOrder_Equal(Integer sortOrder,
                               EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)

setSortOrder_Term

public void setSortOrder_Term(Integer sortOrder)

setSortOrder_Term

public void setSortOrder_Term(Integer sortOrder,
                              EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)

setSortOrder_NotEqual

public void setSortOrder_NotEqual(Integer sortOrder)

setSortOrder_NotTerm

public void setSortOrder_NotTerm(Integer sortOrder)

setSortOrder_NotEqual

public void setSortOrder_NotEqual(Integer sortOrder,
                                  EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)

setSortOrder_NotTerm

public void setSortOrder_NotTerm(Integer sortOrder,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)

setSortOrder_Terms

public void setSortOrder_Terms(Collection<Integer> sortOrderList)

setSortOrder_Terms

public void setSortOrder_Terms(Collection<Integer> sortOrderList,
                               EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)

setSortOrder_InScope

public void setSortOrder_InScope(Collection<Integer> sortOrderList)

setSortOrder_InScope

public void setSortOrder_InScope(Collection<Integer> sortOrderList,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)

setSortOrder_Match

public void setSortOrder_Match(Integer sortOrder)

setSortOrder_Match

public void setSortOrder_Match(Integer sortOrder,
                               EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)

setSortOrder_MatchPhrase

public void setSortOrder_MatchPhrase(Integer sortOrder)

setSortOrder_MatchPhrase

public void setSortOrder_MatchPhrase(Integer sortOrder,
                                     EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhraseQueryBuilder> opLambda)

setSortOrder_MatchPhrasePrefix

public void setSortOrder_MatchPhrasePrefix(Integer sortOrder)

setSortOrder_MatchPhrasePrefix

public void setSortOrder_MatchPhrasePrefix(Integer sortOrder,
                                           EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhrasePrefixQueryBuilder> opLambda)

setSortOrder_Fuzzy

public void setSortOrder_Fuzzy(Integer sortOrder)

setSortOrder_Fuzzy

public void setSortOrder_Fuzzy(Integer sortOrder,
                               EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)

setSortOrder_GreaterThan

public void setSortOrder_GreaterThan(Integer sortOrder)

setSortOrder_GreaterThan

public void setSortOrder_GreaterThan(Integer sortOrder,
                                     EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setSortOrder_LessThan

public void setSortOrder_LessThan(Integer sortOrder)

setSortOrder_LessThan

public void setSortOrder_LessThan(Integer sortOrder,
                                  EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setSortOrder_GreaterEqual

public void setSortOrder_GreaterEqual(Integer sortOrder)

setSortOrder_GreaterEqual

public void setSortOrder_GreaterEqual(Integer sortOrder,
                                      EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setSortOrder_LessEqual

public void setSortOrder_LessEqual(Integer sortOrder)

setSortOrder_LessEqual

public void setSortOrder_LessEqual(Integer sortOrder,
                                   EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setSortOrder_Exists
```
public void setSortOrder_Exists()
```

setSortOrder_Exists

public void setSortOrder_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.ExistsQueryBuilder> opLambda)

setSortOrder_CommonTerms

public void setSortOrder_CommonTerms(Integer sortOrder)

setSortOrder_CommonTerms

public void setSortOrder_CommonTerms(Integer sortOrder,
                                     EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.CommonTermsQueryBuilder> opLambda)

addOrderBy_SortOrder_Asc

public BsWebConfigCQ addOrderBy_SortOrder_Asc()

addOrderBy_SortOrder_Desc

public BsWebConfigCQ addOrderBy_SortOrder_Desc()

setTimeToLive_Equal

public void setTimeToLive_Equal(Integer timeToLive)

setTimeToLive_Equal

public void setTimeToLive_Equal(Integer timeToLive,
                                EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)

setTimeToLive_Term

public void setTimeToLive_Term(Integer timeToLive)

setTimeToLive_Term

public void setTimeToLive_Term(Integer timeToLive,
                               EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)

setTimeToLive_NotEqual

public void setTimeToLive_NotEqual(Integer timeToLive)

setTimeToLive_NotTerm

public void setTimeToLive_NotTerm(Integer timeToLive)

setTimeToLive_NotEqual

public void setTimeToLive_NotEqual(Integer timeToLive,
                                   EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)

setTimeToLive_NotTerm

public void setTimeToLive_NotTerm(Integer timeToLive,
                                  EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)

setTimeToLive_Terms

public void setTimeToLive_Terms(Collection<Integer> timeToLiveList)

setTimeToLive_Terms

public void setTimeToLive_Terms(Collection<Integer> timeToLiveList,
                                EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)

setTimeToLive_InScope

public void setTimeToLive_InScope(Collection<Integer> timeToLiveList)

setTimeToLive_InScope

public void setTimeToLive_InScope(Collection<Integer> timeToLiveList,
                                  EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)

setTimeToLive_Match

public void setTimeToLive_Match(Integer timeToLive)

setTimeToLive_Match

public void setTimeToLive_Match(Integer timeToLive,
                                EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)

setTimeToLive_MatchPhrase

public void setTimeToLive_MatchPhrase(Integer timeToLive)

setTimeToLive_MatchPhrase

public void setTimeToLive_MatchPhrase(Integer timeToLive,
                                      EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhraseQueryBuilder> opLambda)

setTimeToLive_MatchPhrasePrefix

public void setTimeToLive_MatchPhrasePrefix(Integer timeToLive)

setTimeToLive_MatchPhrasePrefix

public void setTimeToLive_MatchPhrasePrefix(Integer timeToLive,
                                            EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhrasePrefixQueryBuilder> opLambda)

setTimeToLive_Fuzzy

public void setTimeToLive_Fuzzy(Integer timeToLive)

setTimeToLive_Fuzzy

public void setTimeToLive_Fuzzy(Integer timeToLive,
                                EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)

setTimeToLive_GreaterThan

public void setTimeToLive_GreaterThan(Integer timeToLive)

setTimeToLive_GreaterThan

public void setTimeToLive_GreaterThan(Integer timeToLive,
                                      EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setTimeToLive_LessThan

public void setTimeToLive_LessThan(Integer timeToLive)

setTimeToLive_LessThan

public void setTimeToLive_LessThan(Integer timeToLive,
                                   EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setTimeToLive_GreaterEqual

public void setTimeToLive_GreaterEqual(Integer timeToLive)

setTimeToLive_GreaterEqual

public void setTimeToLive_GreaterEqual(Integer timeToLive,
                                       EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setTimeToLive_LessEqual

public void setTimeToLive_LessEqual(Integer timeToLive)

setTimeToLive_LessEqual

public void setTimeToLive_LessEqual(Integer timeToLive,
                                    EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setTimeToLive_Exists
```
public void setTimeToLive_Exists()
```

setTimeToLive_Exists

public void setTimeToLive_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.ExistsQueryBuilder> opLambda)

setTimeToLive_CommonTerms

public void setTimeToLive_CommonTerms(Integer timeToLive)

setTimeToLive_CommonTerms

public void setTimeToLive_CommonTerms(Integer timeToLive,
                                      EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.CommonTermsQueryBuilder> opLambda)

addOrderBy_TimeToLive_Asc

public BsWebConfigCQ addOrderBy_TimeToLive_Asc()

addOrderBy_TimeToLive_Desc

public BsWebConfigCQ addOrderBy_TimeToLive_Desc()

setUpdatedBy_Equal

public void setUpdatedBy_Equal(String updatedBy)

setUpdatedBy_Equal

public void setUpdatedBy_Equal(String updatedBy,
                               EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)

setUpdatedBy_Term

public void setUpdatedBy_Term(String updatedBy)

setUpdatedBy_Term

public void setUpdatedBy_Term(String updatedBy,
                              EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)

setUpdatedBy_NotEqual

public void setUpdatedBy_NotEqual(String updatedBy)

setUpdatedBy_NotTerm

public void setUpdatedBy_NotTerm(String updatedBy)

setUpdatedBy_NotEqual

public void setUpdatedBy_NotEqual(String updatedBy,
                                  EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)

setUpdatedBy_NotTerm

public void setUpdatedBy_NotTerm(String updatedBy,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)

setUpdatedBy_Terms

public void setUpdatedBy_Terms(Collection<String> updatedByList)

setUpdatedBy_Terms

public void setUpdatedBy_Terms(Collection<String> updatedByList,
                               EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)

setUpdatedBy_InScope

public void setUpdatedBy_InScope(Collection<String> updatedByList)

setUpdatedBy_InScope

public void setUpdatedBy_InScope(Collection<String> updatedByList,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)

setUpdatedBy_Match

public void setUpdatedBy_Match(String updatedBy)

setUpdatedBy_Match

public void setUpdatedBy_Match(String updatedBy,
                               EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)

setUpdatedBy_MatchPhrase

public void setUpdatedBy_MatchPhrase(String updatedBy)

setUpdatedBy_MatchPhrase

public void setUpdatedBy_MatchPhrase(String updatedBy,
                                     EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhraseQueryBuilder> opLambda)

setUpdatedBy_MatchPhrasePrefix

public void setUpdatedBy_MatchPhrasePrefix(String updatedBy)

setUpdatedBy_MatchPhrasePrefix

public void setUpdatedBy_MatchPhrasePrefix(String updatedBy,
                                           EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhrasePrefixQueryBuilder> opLambda)

setUpdatedBy_Fuzzy

public void setUpdatedBy_Fuzzy(String updatedBy)

setUpdatedBy_Fuzzy

public void setUpdatedBy_Fuzzy(String updatedBy,
                               EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)

setUpdatedBy_Prefix

public void setUpdatedBy_Prefix(String updatedBy)

setUpdatedBy_Prefix

public void setUpdatedBy_Prefix(String updatedBy,
                                EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.PrefixQueryBuilder> opLambda)

setUpdatedBy_Wildcard

public void setUpdatedBy_Wildcard(String updatedBy)

setUpdatedBy_Wildcard

public void setUpdatedBy_Wildcard(String updatedBy,
                                  EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.WildcardQueryBuilder> opLambda)

setUpdatedBy_Regexp

public void setUpdatedBy_Regexp(String updatedBy)

setUpdatedBy_Regexp

public void setUpdatedBy_Regexp(String updatedBy,
                                EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RegexpQueryBuilder> opLambda)

setUpdatedBy_SpanTerm

public void setUpdatedBy_SpanTerm(String updatedBy)

setUpdatedBy_SpanTerm

public void setUpdatedBy_SpanTerm(String updatedBy,
                                  EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.SpanTermQueryBuilder> opLambda)

setUpdatedBy_GreaterThan

public void setUpdatedBy_GreaterThan(String updatedBy)

setUpdatedBy_GreaterThan

public void setUpdatedBy_GreaterThan(String updatedBy,
                                     EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setUpdatedBy_LessThan

public void setUpdatedBy_LessThan(String updatedBy)

setUpdatedBy_LessThan

public void setUpdatedBy_LessThan(String updatedBy,
                                  EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setUpdatedBy_GreaterEqual

public void setUpdatedBy_GreaterEqual(String updatedBy)

setUpdatedBy_GreaterEqual

public void setUpdatedBy_GreaterEqual(String updatedBy,
                                      EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setUpdatedBy_LessEqual

public void setUpdatedBy_LessEqual(String updatedBy)

setUpdatedBy_LessEqual

public void setUpdatedBy_LessEqual(String updatedBy,
                                   EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setUpdatedBy_Exists
```
public void setUpdatedBy_Exists()
```

setUpdatedBy_Exists

public void setUpdatedBy_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.ExistsQueryBuilder> opLambda)

setUpdatedBy_CommonTerms

public void setUpdatedBy_CommonTerms(String updatedBy)

setUpdatedBy_CommonTerms

public void setUpdatedBy_CommonTerms(String updatedBy,
                                     EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.CommonTermsQueryBuilder> opLambda)

addOrderBy_UpdatedBy_Asc

public BsWebConfigCQ addOrderBy_UpdatedBy_Asc()

addOrderBy_UpdatedBy_Desc

public BsWebConfigCQ addOrderBy_UpdatedBy_Desc()

setUpdatedTime_Equal

public void setUpdatedTime_Equal(Long updatedTime)

setUpdatedTime_Equal

public void setUpdatedTime_Equal(Long updatedTime,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)

setUpdatedTime_Term

public void setUpdatedTime_Term(Long updatedTime)

setUpdatedTime_Term

public void setUpdatedTime_Term(Long updatedTime,
                                EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)

setUpdatedTime_NotEqual

public void setUpdatedTime_NotEqual(Long updatedTime)

setUpdatedTime_NotTerm

public void setUpdatedTime_NotTerm(Long updatedTime)

setUpdatedTime_NotEqual

public void setUpdatedTime_NotEqual(Long updatedTime,
                                    EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)

setUpdatedTime_NotTerm

public void setUpdatedTime_NotTerm(Long updatedTime,
                                   EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)

setUpdatedTime_Terms

public void setUpdatedTime_Terms(Collection<Long> updatedTimeList)

setUpdatedTime_Terms

public void setUpdatedTime_Terms(Collection<Long> updatedTimeList,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)

setUpdatedTime_InScope

public void setUpdatedTime_InScope(Collection<Long> updatedTimeList)

setUpdatedTime_InScope

public void setUpdatedTime_InScope(Collection<Long> updatedTimeList,
                                   EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)

setUpdatedTime_Match

public void setUpdatedTime_Match(Long updatedTime)

setUpdatedTime_Match

public void setUpdatedTime_Match(Long updatedTime,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)

setUpdatedTime_MatchPhrase

public void setUpdatedTime_MatchPhrase(Long updatedTime)

setUpdatedTime_MatchPhrase

public void setUpdatedTime_MatchPhrase(Long updatedTime,
                                       EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhraseQueryBuilder> opLambda)

setUpdatedTime_MatchPhrasePrefix

public void setUpdatedTime_MatchPhrasePrefix(Long updatedTime)

setUpdatedTime_MatchPhrasePrefix

public void setUpdatedTime_MatchPhrasePrefix(Long updatedTime,
                                             EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhrasePrefixQueryBuilder> opLambda)

setUpdatedTime_Fuzzy

public void setUpdatedTime_Fuzzy(Long updatedTime)

setUpdatedTime_Fuzzy

public void setUpdatedTime_Fuzzy(Long updatedTime,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)

setUpdatedTime_GreaterThan

public void setUpdatedTime_GreaterThan(Long updatedTime)

setUpdatedTime_GreaterThan

public void setUpdatedTime_GreaterThan(Long updatedTime,
                                       EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setUpdatedTime_LessThan

public void setUpdatedTime_LessThan(Long updatedTime)

setUpdatedTime_LessThan

public void setUpdatedTime_LessThan(Long updatedTime,
                                    EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setUpdatedTime_GreaterEqual

public void setUpdatedTime_GreaterEqual(Long updatedTime)

setUpdatedTime_GreaterEqual

public void setUpdatedTime_GreaterEqual(Long updatedTime,
                                        EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setUpdatedTime_LessEqual

public void setUpdatedTime_LessEqual(Long updatedTime)

setUpdatedTime_LessEqual

public void setUpdatedTime_LessEqual(Long updatedTime,
                                     EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setUpdatedTime_Exists
```
public void setUpdatedTime_Exists()
```

setUpdatedTime_Exists

public void setUpdatedTime_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.ExistsQueryBuilder> opLambda)

setUpdatedTime_CommonTerms

public void setUpdatedTime_CommonTerms(Long updatedTime)

setUpdatedTime_CommonTerms

public void setUpdatedTime_CommonTerms(Long updatedTime,
                                       EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.CommonTermsQueryBuilder> opLambda)

addOrderBy_UpdatedTime_Asc

public BsWebConfigCQ addOrderBy_UpdatedTime_Asc()

addOrderBy_UpdatedTime_Desc

public BsWebConfigCQ addOrderBy_UpdatedTime_Desc()

setUrls_Equal

public void setUrls_Equal(String urls)

setUrls_Equal

public void setUrls_Equal(String urls,
                          EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)

setUrls_Term

public void setUrls_Term(String urls)

setUrls_Term

public void setUrls_Term(String urls,
                         EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)

setUrls_NotEqual

public void setUrls_NotEqual(String urls)

setUrls_NotTerm

public void setUrls_NotTerm(String urls)

setUrls_NotEqual

public void setUrls_NotEqual(String urls,
                             EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)

setUrls_NotTerm

public void setUrls_NotTerm(String urls,
                            EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)

setUrls_Terms

public void setUrls_Terms(Collection<String> urlsList)

setUrls_Terms

public void setUrls_Terms(Collection<String> urlsList,
                          EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)

setUrls_InScope

public void setUrls_InScope(Collection<String> urlsList)

setUrls_InScope

public void setUrls_InScope(Collection<String> urlsList,
                            EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)

setUrls_Match

public void setUrls_Match(String urls)

setUrls_Match

public void setUrls_Match(String urls,
                          EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)

setUrls_MatchPhrase

public void setUrls_MatchPhrase(String urls)

setUrls_MatchPhrase

public void setUrls_MatchPhrase(String urls,
                                EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhraseQueryBuilder> opLambda)

setUrls_MatchPhrasePrefix

public void setUrls_MatchPhrasePrefix(String urls)

setUrls_MatchPhrasePrefix

public void setUrls_MatchPhrasePrefix(String urls,
                                      EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhrasePrefixQueryBuilder> opLambda)

setUrls_Fuzzy

public void setUrls_Fuzzy(String urls)

setUrls_Fuzzy

public void setUrls_Fuzzy(String urls,
                          EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)

setUrls_Prefix

public void setUrls_Prefix(String urls)

setUrls_Prefix

public void setUrls_Prefix(String urls,
                           EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.PrefixQueryBuilder> opLambda)

setUrls_Wildcard

public void setUrls_Wildcard(String urls)

setUrls_Wildcard

public void setUrls_Wildcard(String urls,
                             EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.WildcardQueryBuilder> opLambda)

setUrls_Regexp

public void setUrls_Regexp(String urls)

setUrls_Regexp

public void setUrls_Regexp(String urls,
                           EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RegexpQueryBuilder> opLambda)

setUrls_SpanTerm

public void setUrls_SpanTerm(String urls)

setUrls_SpanTerm

public void setUrls_SpanTerm(String urls,
                             EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.SpanTermQueryBuilder> opLambda)

setUrls_GreaterThan

public void setUrls_GreaterThan(String urls)

setUrls_GreaterThan

public void setUrls_GreaterThan(String urls,
                                EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setUrls_LessThan

public void setUrls_LessThan(String urls)

setUrls_LessThan

public void setUrls_LessThan(String urls,
                             EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setUrls_GreaterEqual

public void setUrls_GreaterEqual(String urls)

setUrls_GreaterEqual

public void setUrls_GreaterEqual(String urls,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setUrls_LessEqual

public void setUrls_LessEqual(String urls)

setUrls_LessEqual

public void setUrls_LessEqual(String urls,
                              EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setUrls_Exists
```
public void setUrls_Exists()
```

setUrls_Exists

public void setUrls_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.ExistsQueryBuilder> opLambda)

setUrls_CommonTerms

public void setUrls_CommonTerms(String urls)

setUrls_CommonTerms

public void setUrls_CommonTerms(String urls,
                                EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.CommonTermsQueryBuilder> opLambda)

addOrderBy_Urls_Asc

public BsWebConfigCQ addOrderBy_Urls_Asc()

addOrderBy_Urls_Desc

public BsWebConfigCQ addOrderBy_Urls_Desc()

setUserAgent_Equal

public void setUserAgent_Equal(String userAgent)

setUserAgent_Equal

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

setUserAgent_Term

public void setUserAgent_Term(String userAgent)

setUserAgent_Term

public void setUserAgent_Term(String userAgent,
                              EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.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.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)

setUserAgent_NotTerm

public void setUserAgent_NotTerm(String userAgent,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.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.codelibs.fesen.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.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)

setUserAgent_Match

public void setUserAgent_Match(String userAgent)

setUserAgent_Match

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

setUserAgent_MatchPhrase

public void setUserAgent_MatchPhrase(String userAgent)

setUserAgent_MatchPhrase

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

setUserAgent_MatchPhrasePrefix

public void setUserAgent_MatchPhrasePrefix(String userAgent)

setUserAgent_MatchPhrasePrefix

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

setUserAgent_Fuzzy

public void setUserAgent_Fuzzy(String userAgent)

setUserAgent_Fuzzy

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

setUserAgent_Prefix

public void setUserAgent_Prefix(String userAgent)

setUserAgent_Prefix

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

setUserAgent_Wildcard

public void setUserAgent_Wildcard(String userAgent)

setUserAgent_Wildcard

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

setUserAgent_Regexp

public void setUserAgent_Regexp(String userAgent)

setUserAgent_Regexp

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

setUserAgent_SpanTerm

public void setUserAgent_SpanTerm(String userAgent)

setUserAgent_SpanTerm

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

setUserAgent_GreaterThan

public void setUserAgent_GreaterThan(String userAgent)

setUserAgent_GreaterThan

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

setUserAgent_LessThan

public void setUserAgent_LessThan(String userAgent)

setUserAgent_LessThan

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

setUserAgent_GreaterEqual

public void setUserAgent_GreaterEqual(String userAgent)

setUserAgent_GreaterEqual

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

setUserAgent_LessEqual

public void setUserAgent_LessEqual(String userAgent)

setUserAgent_LessEqual

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

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

setUserAgent_Exists

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

setUserAgent_CommonTerms

public void setUserAgent_CommonTerms(String userAgent)

setUserAgent_CommonTerms

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

addOrderBy_UserAgent_Asc

public BsWebConfigCQ addOrderBy_UserAgent_Asc()

addOrderBy_UserAgent_Desc

public BsWebConfigCQ addOrderBy_UserAgent_Desc()

setVirtualHosts_Equal

public void setVirtualHosts_Equal(String virtualHosts)

setVirtualHosts_Equal

public void setVirtualHosts_Equal(String virtualHosts,
                                  EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)

setVirtualHosts_Term

public void setVirtualHosts_Term(String virtualHosts)

setVirtualHosts_Term

public void setVirtualHosts_Term(String virtualHosts,
                                 EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermQueryBuilder> opLambda)

setVirtualHosts_NotEqual

public void setVirtualHosts_NotEqual(String virtualHosts)

setVirtualHosts_NotTerm

public void setVirtualHosts_NotTerm(String virtualHosts)

setVirtualHosts_NotEqual

public void setVirtualHosts_NotEqual(String virtualHosts,
                                     EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)

setVirtualHosts_NotTerm

public void setVirtualHosts_NotTerm(String virtualHosts,
                                    EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.BoolQueryBuilder> opLambda)

setVirtualHosts_Terms

public void setVirtualHosts_Terms(Collection<String> virtualHostsList)

setVirtualHosts_Terms

public void setVirtualHosts_Terms(Collection<String> virtualHostsList,
                                  EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)

setVirtualHosts_InScope

public void setVirtualHosts_InScope(Collection<String> virtualHostsList)

setVirtualHosts_InScope

public void setVirtualHosts_InScope(Collection<String> virtualHostsList,
                                    EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.TermsQueryBuilder> opLambda)

setVirtualHosts_Match

public void setVirtualHosts_Match(String virtualHosts)

setVirtualHosts_Match

public void setVirtualHosts_Match(String virtualHosts,
                                  EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)

setVirtualHosts_MatchPhrase

public void setVirtualHosts_MatchPhrase(String virtualHosts)

setVirtualHosts_MatchPhrase

public void setVirtualHosts_MatchPhrase(String virtualHosts,
                                        EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhraseQueryBuilder> opLambda)

setVirtualHosts_MatchPhrasePrefix

public void setVirtualHosts_MatchPhrasePrefix(String virtualHosts)

setVirtualHosts_MatchPhrasePrefix

public void setVirtualHosts_MatchPhrasePrefix(String virtualHosts,
                                              EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchPhrasePrefixQueryBuilder> opLambda)

setVirtualHosts_Fuzzy

public void setVirtualHosts_Fuzzy(String virtualHosts)

setVirtualHosts_Fuzzy

public void setVirtualHosts_Fuzzy(String virtualHosts,
                                  EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.MatchQueryBuilder> opLambda)

setVirtualHosts_Prefix

public void setVirtualHosts_Prefix(String virtualHosts)

setVirtualHosts_Prefix

public void setVirtualHosts_Prefix(String virtualHosts,
                                   EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.PrefixQueryBuilder> opLambda)

setVirtualHosts_Wildcard

public void setVirtualHosts_Wildcard(String virtualHosts)

setVirtualHosts_Wildcard

public void setVirtualHosts_Wildcard(String virtualHosts,
                                     EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.WildcardQueryBuilder> opLambda)

setVirtualHosts_Regexp

public void setVirtualHosts_Regexp(String virtualHosts)

setVirtualHosts_Regexp

public void setVirtualHosts_Regexp(String virtualHosts,
                                   EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RegexpQueryBuilder> opLambda)

setVirtualHosts_SpanTerm

public void setVirtualHosts_SpanTerm(String virtualHosts)

setVirtualHosts_SpanTerm

public void setVirtualHosts_SpanTerm(String virtualHosts,
                                     EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.SpanTermQueryBuilder> opLambda)

setVirtualHosts_GreaterThan

public void setVirtualHosts_GreaterThan(String virtualHosts)

setVirtualHosts_GreaterThan

public void setVirtualHosts_GreaterThan(String virtualHosts,
                                        EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setVirtualHosts_LessThan

public void setVirtualHosts_LessThan(String virtualHosts)

setVirtualHosts_LessThan

public void setVirtualHosts_LessThan(String virtualHosts,
                                     EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setVirtualHosts_GreaterEqual

public void setVirtualHosts_GreaterEqual(String virtualHosts)

setVirtualHosts_GreaterEqual

public void setVirtualHosts_GreaterEqual(String virtualHosts,
                                         EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setVirtualHosts_LessEqual

public void setVirtualHosts_LessEqual(String virtualHosts)

setVirtualHosts_LessEqual

public void setVirtualHosts_LessEqual(String virtualHosts,
                                      EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.RangeQueryBuilder> opLambda)

setVirtualHosts_Exists
```
public void setVirtualHosts_Exists()
```

setVirtualHosts_Exists

public void setVirtualHosts_Exists(EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.ExistsQueryBuilder> opLambda)

setVirtualHosts_CommonTerms

public void setVirtualHosts_CommonTerms(String virtualHosts)

setVirtualHosts_CommonTerms

public void setVirtualHosts_CommonTerms(String virtualHosts,
                                        EsAbstractConditionQuery.ConditionOptionCall<org.codelibs.fesen.index.query.CommonTermsQueryBuilder> opLambda)

addOrderBy_VirtualHosts_Asc

public BsWebConfigCQ addOrderBy_VirtualHosts_Asc()

addOrderBy_VirtualHosts_Desc

public BsWebConfigCQ addOrderBy_VirtualHosts_Desc()

Class BsWebConfigCQ

Nested Class Summary

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

Field Summary

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

Constructor Summary

Method Summary

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

Methods inherited from class java.lang.Object

Field Detail

suppressUnusedImportLocalDateTime

Constructor Detail

BsWebConfigCQ

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

setAvailable_Equal

setAvailable_Equal

setAvailable_Term

setAvailable_Term

setAvailable_NotEqual

setAvailable_NotTerm

setAvailable_NotEqual

setAvailable_NotTerm

setAvailable_Terms

setAvailable_Terms

setAvailable_InScope

setAvailable_InScope

setAvailable_Match

setAvailable_Match

setAvailable_MatchPhrase

setAvailable_MatchPhrase

setAvailable_MatchPhrasePrefix

setAvailable_MatchPhrasePrefix

setAvailable_Fuzzy

setAvailable_Fuzzy

setAvailable_GreaterThan

setAvailable_GreaterThan

setAvailable_LessThan

setAvailable_LessThan

setAvailable_GreaterEqual

setAvailable_GreaterEqual

setAvailable_LessEqual

setAvailable_LessEqual

setAvailable_Exists

setAvailable_Exists

setAvailable_CommonTerms

setAvailable_CommonTerms

addOrderBy_Available_Asc

addOrderBy_Available_Desc

setBoost_Equal

setBoost_Equal

setBoost_Term

setBoost_Term

setBoost_NotEqual

setBoost_NotTerm

setBoost_NotEqual

setBoost_NotTerm

setBoost_Terms