#285 add cf

src/main/java/org/codelibs/fess/es/cbean/bs/AbstractConditionBean.java

@@ -592,6 +592,8 @@ public abstract class AbstractConditionBean implements ConditionBean {
 
         private Boolean version;
 
+        private int terminateAfter = 0;
+
         public void build(SearchRequestBuilder builder) {
             if (explain != null) {
                 builder.setExplain(explain);
@@ -614,6 +616,9 @@ public abstract class AbstractConditionBean implements ConditionBean {
             if (version != null) {
                 builder.setVersion(version);
             }
+            if (terminateAfter > 0) {
+                builder.setTerminateAfter(terminateAfter);
+            }
         }
 
         public void setExplain(boolean explain) {
@@ -644,6 +649,10 @@ public abstract class AbstractConditionBean implements ConditionBean {
             this.version = version;
         }
 
+        public void setTerminateAfter(int terminateAfter) {
+            this.terminateAfter = terminateAfter;
+        }
+
     }
 
 }

src/main/java/org/codelibs/fess/es/cbean/cf/BoostDocumentRuleCF.java

@@ -0,0 +1,7 @@
+package org.codelibs.fess.es.cbean.cf;
+
+import org.codelibs.fess.es.cbean.cf.bs.BsBoostDocumentRuleCF;
+
+public class BoostDocumentRuleCF extends BsBoostDocumentRuleCF {
+
+}

src/main/java/org/codelibs/fess/es/cbean/cf/ClickLogCF.java

@@ -0,0 +1,9 @@
+package org.codelibs.fess.es.cbean.cf;
+
+import org.codelibs.fess.es.cbean.cf.bs.BsClickLogCF;
+
+/**
+ * @author FreeGen
+ */
+public class ClickLogCF extends BsClickLogCF {
+}

src/main/java/org/codelibs/fess/es/cbean/cf/CrawlingSessionCF.java

@@ -0,0 +1,9 @@
+package org.codelibs.fess.es.cbean.cf;
+
+import org.codelibs.fess.es.cbean.cf.bs.BsCrawlingSessionCF;
+
+/**
+ * @author FreeGen
+ */
+public class CrawlingSessionCF extends BsCrawlingSessionCF {
+}

src/main/java/org/codelibs/fess/es/cbean/cf/CrawlingSessionInfoCF.java

@@ -0,0 +1,9 @@
+package org.codelibs.fess.es.cbean.cf;
+
+import org.codelibs.fess.es.cbean.cf.bs.BsCrawlingSessionInfoCF;
+
+/**
+ * @author FreeGen
+ */
+public class CrawlingSessionInfoCF extends BsCrawlingSessionInfoCF {
+}

src/main/java/org/codelibs/fess/es/cbean/cf/DataConfigCF.java

@@ -0,0 +1,9 @@
+package org.codelibs.fess.es.cbean.cf;
+
+import org.codelibs.fess.es.cbean.cf.bs.BsDataConfigCF;
+
+/**
+ * @author FreeGen
+ */
+public class DataConfigCF extends BsDataConfigCF {
+}

src/main/java/org/codelibs/fess/es/cbean/cf/DataConfigToLabelCF.java

@@ -0,0 +1,9 @@
+package org.codelibs.fess.es.cbean.cf;
+
+import org.codelibs.fess.es.cbean.cf.bs.BsDataConfigToLabelCF;
+
+/**
+ * @author FreeGen
+ */
+public class DataConfigToLabelCF extends BsDataConfigToLabelCF {
+}

src/main/java/org/codelibs/fess/es/cbean/cf/DataConfigToRoleCF.java

@@ -0,0 +1,9 @@
+package org.codelibs.fess.es.cbean.cf;
+
+import org.codelibs.fess.es.cbean.cf.bs.BsDataConfigToRoleCF;
+
+/**
+ * @author FreeGen
+ */
+public class DataConfigToRoleCF extends BsDataConfigToRoleCF {
+}

src/main/java/org/codelibs/fess/es/cbean/cf/FailureUrlCF.java

@@ -0,0 +1,9 @@
+package org.codelibs.fess.es.cbean.cf;
+
+import org.codelibs.fess.es.cbean.cf.bs.BsFailureUrlCF;
+
+/**
+ * @author FreeGen
+ */
+public class FailureUrlCF extends BsFailureUrlCF {
+}

src/main/java/org/codelibs/fess/es/cbean/cf/FavoriteLogCF.java

@@ -0,0 +1,9 @@
+package org.codelibs.fess.es.cbean.cf;
+
+import org.codelibs.fess.es.cbean.cf.bs.BsFavoriteLogCF;
+
+/**
+ * @author FreeGen
+ */
+public class FavoriteLogCF extends BsFavoriteLogCF {
+}

src/main/java/org/codelibs/fess/es/cbean/cf/FileAuthenticationCF.java

@@ -0,0 +1,9 @@
+package org.codelibs.fess.es.cbean.cf;
+
+import org.codelibs.fess.es.cbean.cf.bs.BsFileAuthenticationCF;
+
+/**
+ * @author FreeGen
+ */
+public class FileAuthenticationCF extends BsFileAuthenticationCF {
+}

src/main/java/org/codelibs/fess/es/cbean/cf/FileConfigCF.java

@@ -0,0 +1,9 @@
+package org.codelibs.fess.es.cbean.cf;
+
+import org.codelibs.fess.es.cbean.cf.bs.BsFileConfigCF;
+
+/**
+ * @author FreeGen
+ */
+public class FileConfigCF extends BsFileConfigCF {
+}

src/main/java/org/codelibs/fess/es/cbean/cf/FileConfigToLabelCF.java

@@ -0,0 +1,9 @@
+package org.codelibs.fess.es.cbean.cf;
+
+import org.codelibs.fess.es.cbean.cf.bs.BsFileConfigToLabelCF;
+
+/**
+ * @author FreeGen
+ */
+public class FileConfigToLabelCF extends BsFileConfigToLabelCF {
+}

src/main/java/org/codelibs/fess/es/cbean/cf/FileConfigToRoleCF.java

@@ -0,0 +1,9 @@
+package org.codelibs.fess.es.cbean.cf;
+
+import org.codelibs.fess.es.cbean.cf.bs.BsFileConfigToRoleCF;
+
+/**
+ * @author FreeGen
+ */
+public class FileConfigToRoleCF extends BsFileConfigToRoleCF {
+}

src/main/java/org/codelibs/fess/es/cbean/cf/JobLogCF.java

@@ -0,0 +1,9 @@
+package org.codelibs.fess.es.cbean.cf;
+
+import org.codelibs.fess.es.cbean.cf.bs.BsJobLogCF;
+
+/**
+ * @author FreeGen
+ */
+public class JobLogCF extends BsJobLogCF {
+}

src/main/java/org/codelibs/fess/es/cbean/cf/KeyMatchCF.java

@@ -0,0 +1,9 @@
+package org.codelibs.fess.es.cbean.cf;
+
+import org.codelibs.fess.es.cbean.cf.bs.BsKeyMatchCF;
+
+/**
+ * @author FreeGen
+ */
+public class KeyMatchCF extends BsKeyMatchCF {
+}

src/main/java/org/codelibs/fess/es/cbean/cf/LabelToRoleCF.java

@@ -0,0 +1,9 @@
+package org.codelibs.fess.es.cbean.cf;
+
+import org.codelibs.fess.es.cbean.cf.bs.BsLabelToRoleCF;
+
+/**
+ * @author FreeGen
+ */
+public class LabelToRoleCF extends BsLabelToRoleCF {
+}

src/main/java/org/codelibs/fess/es/cbean/cf/LabelTypeCF.java

@@ -0,0 +1,9 @@
+package org.codelibs.fess.es.cbean.cf;
+
+import org.codelibs.fess.es.cbean.cf.bs.BsLabelTypeCF;
+
+/**
+ * @author FreeGen
+ */
+public class LabelTypeCF extends BsLabelTypeCF {
+}

src/main/java/org/codelibs/fess/es/cbean/cf/OverlappingHostCF.java

@@ -0,0 +1,9 @@
+package org.codelibs.fess.es.cbean.cf;
+
+import org.codelibs.fess.es.cbean.cf.bs.BsOverlappingHostCF;
+
+/**
+ * @author FreeGen
+ */
+public class OverlappingHostCF extends BsOverlappingHostCF {
+}

src/main/java/org/codelibs/fess/es/cbean/cf/PathMappingCF.java

@@ -0,0 +1,9 @@
+package org.codelibs.fess.es.cbean.cf;
+
+import org.codelibs.fess.es.cbean.cf.bs.BsPathMappingCF;
+
+/**
+ * @author FreeGen
+ */
+public class PathMappingCF extends BsPathMappingCF {
+}

src/main/java/org/codelibs/fess/es/cbean/cf/RequestHeaderCF.java

@@ -0,0 +1,9 @@
+package org.codelibs.fess.es.cbean.cf;
+
+import org.codelibs.fess.es.cbean.cf.bs.BsRequestHeaderCF;
+
+/**
+ * @author FreeGen
+ */
+public class RequestHeaderCF extends BsRequestHeaderCF {
+}

src/main/java/org/codelibs/fess/es/cbean/cf/RoleTypeCF.java

@@ -0,0 +1,9 @@
+package org.codelibs.fess.es.cbean.cf;
+
+import org.codelibs.fess.es.cbean.cf.bs.BsRoleTypeCF;
+
+/**
+ * @author FreeGen
+ */
+public class RoleTypeCF extends BsRoleTypeCF {
+}

src/main/java/org/codelibs/fess/es/cbean/cf/ScheduledJobCF.java

@@ -0,0 +1,9 @@
+package org.codelibs.fess.es.cbean.cf;
+
+import org.codelibs.fess.es.cbean.cf.bs.BsScheduledJobCF;
+
+/**
+ * @author FreeGen
+ */
+public class ScheduledJobCF extends BsScheduledJobCF {
+}

src/main/java/org/codelibs/fess/es/cbean/cf/SearchFieldLogCF.java

@@ -0,0 +1,9 @@
+package org.codelibs.fess.es.cbean.cf;
+
+import org.codelibs.fess.es.cbean.cf.bs.BsSearchFieldLogCF;
+
+/**
+ * @author FreeGen
+ */
+public class SearchFieldLogCF extends BsSearchFieldLogCF {
+}

src/main/java/org/codelibs/fess/es/cbean/cf/SearchLogCF.java

@@ -0,0 +1,9 @@
+package org.codelibs.fess.es.cbean.cf;
+
+import org.codelibs.fess.es.cbean.cf.bs.BsSearchLogCF;
+
+/**
+ * @author FreeGen
+ */
+public class SearchLogCF extends BsSearchLogCF {
+}

src/main/java/org/codelibs/fess/es/cbean/cf/SuggestBadWordCF.java

@@ -0,0 +1,9 @@
+package org.codelibs.fess.es.cbean.cf;
+
+import org.codelibs.fess.es.cbean.cf.bs.BsSuggestBadWordCF;
+
+/**
+ * @author FreeGen
+ */
+public class SuggestBadWordCF extends BsSuggestBadWordCF {
+}

src/main/java/org/codelibs/fess/es/cbean/cf/SuggestElevateWordCF.java

@@ -0,0 +1,9 @@
+package org.codelibs.fess.es.cbean.cf;
+
+import org.codelibs.fess.es.cbean.cf.bs.BsSuggestElevateWordCF;
+
+/**
+ * @author FreeGen
+ */
+public class SuggestElevateWordCF extends BsSuggestElevateWordCF {
+}

src/main/java/org/codelibs/fess/es/cbean/cf/UserInfoCF.java

@@ -0,0 +1,9 @@
+package org.codelibs.fess.es.cbean.cf;
+
+import org.codelibs.fess.es.cbean.cf.bs.BsUserInfoCF;
+
+/**
+ * @author FreeGen
+ */
+public class UserInfoCF extends BsUserInfoCF {
+}

src/main/java/org/codelibs/fess/es/cbean/cf/WebAuthenticationCF.java

@@ -0,0 +1,9 @@
+package org.codelibs.fess.es.cbean.cf;
+
+import org.codelibs.fess.es.cbean.cf.bs.BsWebAuthenticationCF;
+
+/**
+ * @author FreeGen
+ */
+public class WebAuthenticationCF extends BsWebAuthenticationCF {
+}

src/main/java/org/codelibs/fess/es/cbean/cf/WebConfigCF.java

@@ -0,0 +1,9 @@
+package org.codelibs.fess.es.cbean.cf;
+
+import org.codelibs.fess.es.cbean.cf.bs.BsWebConfigCF;
+
+/**
+ * @author FreeGen
+ */
+public class WebConfigCF extends BsWebConfigCF {
+}

src/main/java/org/codelibs/fess/es/cbean/cf/WebConfigToLabelCF.java

@@ -0,0 +1,9 @@
+package org.codelibs.fess.es.cbean.cf;
+
+import org.codelibs.fess.es.cbean.cf.bs.BsWebConfigToLabelCF;
+
+/**
+ * @author FreeGen
+ */
+public class WebConfigToLabelCF extends BsWebConfigToLabelCF {
+}

src/main/java/org/codelibs/fess/es/cbean/cf/WebConfigToRoleCF.java

@@ -0,0 +1,9 @@
+package org.codelibs.fess.es.cbean.cf;
+
+import org.codelibs.fess.es.cbean.cf.bs.BsWebConfigToRoleCF;
+
+/**
+ * @author FreeGen
+ */
+public class WebConfigToRoleCF extends BsWebConfigToRoleCF {
+}

src/main/java/org/codelibs/fess/es/cbean/cf/bs/AbstractConditionFilter.java

@@ -0,0 +1,215 @@
+package org.codelibs.fess.es.cbean.cf.bs;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+import org.dbflute.cbean.ckey.ConditionKey;
+import org.elasticsearch.index.query.AndFilterBuilder;
+import org.elasticsearch.index.query.BoolFilterBuilder;
+import org.elasticsearch.index.query.ExistsFilterBuilder;
+import org.elasticsearch.index.query.FilterBuilder;
+import org.elasticsearch.index.query.FilterBuilders;
+import org.elasticsearch.index.query.IdsFilterBuilder;
+import org.elasticsearch.index.query.MatchAllFilterBuilder;
+import org.elasticsearch.index.query.MissingFilterBuilder;
+import org.elasticsearch.index.query.NotFilterBuilder;
+import org.elasticsearch.index.query.OrFilterBuilder;
+import org.elasticsearch.index.query.PrefixFilterBuilder;
+import org.elasticsearch.index.query.QueryBuilder;
+import org.elasticsearch.index.query.QueryFilterBuilder;
+import org.elasticsearch.index.query.RangeFilterBuilder;
+import org.elasticsearch.index.query.ScriptFilterBuilder;
+import org.elasticsearch.index.query.TermFilterBuilder;
+import org.elasticsearch.index.query.TermsFilterBuilder;
+
+public class AbstractConditionFilter {
+    protected List<FilterBuilder> filterBuilderList;
+
+    public boolean hasFilters() {
+        return filterBuilderList != null && !filterBuilderList.isEmpty();
+    }
+
+    public FilterBuilder getFilter() {
+        if (filterBuilderList == null) {
+            return null;
+        } else if (filterBuilderList.size() == 1) {
+            return filterBuilderList.get(0);
+        }
+        return FilterBuilders.andFilter(filterBuilderList.toArray(new FilterBuilder[filterBuilderList.size()]));
+    }
+
+    public void addFilter(FilterBuilder filterBuilder) {
+        regF(filterBuilder);
+    }
+
+    public void setIds_Equal(Collection<String> idList) {
+        setIds_Equal(idList, null);
+    }
+
+    public void setIds_Equal(Collection<String> idList, ConditionOptionCall<IdsFilterBuilder> opLambda) {
+        IdsFilterBuilder builder = regIdsF(idList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void matchAll() {
+        matchAll(null);
+    }
+
+    public void matchAll(ConditionOptionCall<MatchAllFilterBuilder> opLambda) {
+        MatchAllFilterBuilder builder = FilterBuilders.matchAllFilter();
+        regF(builder);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setScript(String script) {
+        setScript(script, null);
+    }
+
+    public void setScript(String script, ConditionOptionCall<ScriptFilterBuilder> opLambda) {
+        ScriptFilterBuilder builder = regScriptF(script);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    protected void regF(FilterBuilder builder) {
+        if (filterBuilderList == null) {
+            filterBuilderList = new ArrayList<>();
+        }
+        filterBuilderList.add(builder);
+    }
+
+    protected TermFilterBuilder regTermF(String name, Object value) {
+        TermFilterBuilder termFilter = FilterBuilders.termFilter(name, value);
+        regF(termFilter);
+        return termFilter;
+    }
+
+    protected TermsFilterBuilder regTermsF(String name, Collection<?> value) {
+        TermsFilterBuilder termsFilter = FilterBuilders.termsFilter(name, value);
+        regF(termsFilter);
+        return termsFilter;
+    }
+
+    protected PrefixFilterBuilder regPrefixF(String name, String value) {
+        PrefixFilterBuilder prefixFilter = FilterBuilders.prefixFilter(name, value);
+        regF(prefixFilter);
+        return prefixFilter;
+    }
+
+    protected ExistsFilterBuilder regExistsF(String name) {
+        ExistsFilterBuilder existsFilter = FilterBuilders.existsFilter(name);
+        regF(existsFilter);
+        return existsFilter;
+    }
+
+    protected MissingFilterBuilder regMissingF(String name) {
+        MissingFilterBuilder missingFilter = FilterBuilders.missingFilter(name);
+        regF(missingFilter);
+        return missingFilter;
+    }
+
+    protected RangeFilterBuilder regRangeF(String name, ConditionKey ck, Object value) {
+        for (FilterBuilder builder : filterBuilderList) {
+            if (builder instanceof RangeFilterBuilder) {
+                RangeFilterBuilder rangeFilterBuilder = (RangeFilterBuilder) builder;
+                if (rangeFilterBuilder.toString().replaceAll("\\s", "").startsWith("{\"range\":{\"" + name + "\"")) {
+                    addRangeC(rangeFilterBuilder, ck, value);
+                    return rangeFilterBuilder;
+                }
+            }
+        }
+        RangeFilterBuilder rangeFilterBuilder = FilterBuilders.rangeFilter(name);
+        addRangeC(rangeFilterBuilder, ck, value);
+        regF(rangeFilterBuilder);
+        return rangeFilterBuilder;
+    }
+
+    protected void addRangeC(RangeFilterBuilder builder, ConditionKey ck, Object value) {
+        if (ck.equals(ConditionKey.CK_GREATER_THAN)) {
+            builder.gt(value);
+        } else if (ck.equals(ConditionKey.CK_GREATER_EQUAL)) {
+            builder.gte(value);
+        } else if (ck.equals(ConditionKey.CK_LESS_THAN)) {
+            builder.lt(value);
+        } else if (ck.equals(ConditionKey.CK_LESS_EQUAL)) {
+            builder.lte(value);
+        }
+    }
+
+    protected ScriptFilterBuilder regScriptF(String script) {
+        ScriptFilterBuilder scriptFilter = FilterBuilders.scriptFilter(script);
+        regF(scriptFilter);
+        return scriptFilter;
+    }
+
+    protected IdsFilterBuilder regIdsF(Collection<?> value) {
+        IdsFilterBuilder idsFilter = FilterBuilders.idsFilter(value.toArray(new String[value.size()]));
+        regF(idsFilter);
+        return idsFilter;
+    }
+
+    protected BoolFilterBuilder regBoolF(List<FilterBuilder> mustList, List<FilterBuilder> shouldList, List<FilterBuilder> mustNotList) {
+        BoolFilterBuilder boolFilter = FilterBuilders.boolFilter();
+        mustList.forEach(query -> {
+            boolFilter.must(query);
+        });
+        shouldList.forEach(query -> {
+            boolFilter.should(query);
+        });
+        mustNotList.forEach(query -> {
+            boolFilter.mustNot(query);
+        });
+        return boolFilter;
+    }
+
+    protected AndFilterBuilder regAndF(List<FilterBuilder> filterList) {
+        AndFilterBuilder andFilter = FilterBuilders.andFilter(filterList.toArray(new FilterBuilder[filterList.size()]));
+        regF(andFilter);
+        return andFilter;
+    }
+
+    protected OrFilterBuilder regOrF(List<FilterBuilder> filterList) {
+        OrFilterBuilder andFilter = FilterBuilders.orFilter(filterList.toArray(new FilterBuilder[filterList.size()]));
+        regF(andFilter);
+        return andFilter;
+    }
+
+    protected NotFilterBuilder regNotF(FilterBuilder filter) {
+        NotFilterBuilder notFilter = FilterBuilders.notFilter(filter);
+        regF(notFilter);
+        return notFilter;
+    }
+
+    protected QueryFilterBuilder regQueryF(QueryBuilder filter) {
+        QueryFilterBuilder queryFilter = FilterBuilders.queryFilter(filter);
+        regF(queryFilter);
+        return queryFilter;
+    }
+
+    @FunctionalInterface
+    public interface ConditionOptionCall<OP extends FilterBuilder> {
+
+        /**
+         * @param op The option of condition to be set up. (NotNull)
+         */
+        void callback(OP op);
+    }
+
+    @FunctionalInterface
+    public interface BoolCall<CF extends AbstractConditionFilter> {
+
+        void callback(CF must, CF should, CF mustNot);
+    }
+
+    @FunctionalInterface
+    public interface OperatorCall<CF extends AbstractConditionFilter> {
+
+        void callback(CF and);
+    }
+}

src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsBoostDocumentRuleCF.java

@@ -0,0 +1,932 @@
+package org.codelibs.fess.es.cbean.cf.bs;
+
+import java.util.Collection;
+
+import org.codelibs.fess.es.cbean.cf.BoostDocumentRuleCF;
+import org.codelibs.fess.es.cbean.cq.BoostDocumentRuleCQ;
+import org.dbflute.exception.IllegalConditionBeanOperationException;
+import org.dbflute.cbean.ckey.ConditionKey;
+import org.elasticsearch.index.query.AndFilterBuilder;
+import org.elasticsearch.index.query.BoolFilterBuilder;
+import org.elasticsearch.index.query.ExistsFilterBuilder;
+import org.elasticsearch.index.query.MissingFilterBuilder;
+import org.elasticsearch.index.query.NotFilterBuilder;
+import org.elasticsearch.index.query.OrFilterBuilder;
+import org.elasticsearch.index.query.PrefixFilterBuilder;
+import org.elasticsearch.index.query.QueryFilterBuilder;
+import org.elasticsearch.index.query.RangeFilterBuilder;
+import org.elasticsearch.index.query.TermFilterBuilder;
+import org.elasticsearch.index.query.TermsFilterBuilder;
+
+/**
+ * @author FreeGen
+ */
+public abstract class BsBoostDocumentRuleCF extends AbstractConditionFilter {
+
+    public void bool(BoolCall<BoostDocumentRuleCF> boolLambda) {
+        bool(boolLambda, null);
+    }
+
+    public void bool(BoolCall<BoostDocumentRuleCF> boolLambda, ConditionOptionCall<BoolFilterBuilder> opLambda) {
+        BoostDocumentRuleCF mustFilter = new BoostDocumentRuleCF();
+        BoostDocumentRuleCF shouldFilter = new BoostDocumentRuleCF();
+        BoostDocumentRuleCF mustNotFilter = new BoostDocumentRuleCF();
+        boolLambda.callback(mustFilter, shouldFilter, mustNotFilter);
+        if (mustFilter.hasFilters() || shouldFilter.hasFilters() || mustNotFilter.hasFilters()) {
+            BoolFilterBuilder builder =
+                    regBoolF(mustFilter.filterBuilderList, shouldFilter.filterBuilderList, mustNotFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void and(OperatorCall<BoostDocumentRuleCF> andLambda) {
+        and(andLambda, null);
+    }
+
+    public void and(OperatorCall<BoostDocumentRuleCF> andLambda, ConditionOptionCall<AndFilterBuilder> opLambda) {
+        BoostDocumentRuleCF andFilter = new BoostDocumentRuleCF();
+        andLambda.callback(andFilter);
+        if (andFilter.hasFilters()) {
+            AndFilterBuilder builder = regAndF(andFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void or(OperatorCall<BoostDocumentRuleCF> orLambda) {
+        or(orLambda, null);
+    }
+
+    public void or(OperatorCall<BoostDocumentRuleCF> orLambda, ConditionOptionCall<OrFilterBuilder> opLambda) {
+        BoostDocumentRuleCF orFilter = new BoostDocumentRuleCF();
+        orLambda.callback(orFilter);
+        if (orFilter.hasFilters()) {
+            OrFilterBuilder builder = regOrF(orFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void not(OperatorCall<BoostDocumentRuleCF> notLambda) {
+        not(notLambda, null);
+    }
+
+    public void not(OperatorCall<BoostDocumentRuleCF> notLambda, ConditionOptionCall<NotFilterBuilder> opLambda) {
+        BoostDocumentRuleCF notFilter = new BoostDocumentRuleCF();
+        notLambda.callback(notFilter);
+        if (notFilter.hasFilters()) {
+            if (notFilter.filterBuilderList.size() > 1) {
+                final String msg = "not filter must be one filter.";
+                throw new IllegalConditionBeanOperationException(msg);
+            }
+            NotFilterBuilder builder = regNotF(notFilter.filterBuilderList.get(0));
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall<BoostDocumentRuleCQ> queryLambda) {
+        query(queryLambda, null);
+    }
+
+    public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall<BoostDocumentRuleCQ> queryLambda,
+            ConditionOptionCall<QueryFilterBuilder> opLambda) {
+        BoostDocumentRuleCQ query = new BoostDocumentRuleCQ();
+        queryLambda.callback(query);
+        if (query.hasQueries()) {
+            QueryFilterBuilder builder = regQueryF(query.getQuery());
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void setBoostExpr_Term(String boostExpr) {
+        setBoostExpr_Term(boostExpr, null);
+    }
+
+    public void setBoostExpr_Term(String boostExpr, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("boostExpr", boostExpr);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setBoostExpr_Terms(Collection<String> boostExprList) {
+        setBoostExpr_Terms(boostExprList, null);
+    }
+
+    public void setBoostExpr_Terms(Collection<String> boostExprList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("boostExpr", boostExprList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setBoostExpr_InScope(Collection<String> boostExprList) {
+        setBoostExpr_Terms(boostExprList, null);
+    }
+
+    public void setBoostExpr_InScope(Collection<String> boostExprList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setBoostExpr_Terms(boostExprList, opLambda);
+    }
+
+    public void setBoostExpr_Prefix(String boostExpr) {
+        setBoostExpr_Prefix(boostExpr, null);
+    }
+
+    public void setBoostExpr_Prefix(String boostExpr, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("boostExpr", boostExpr);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setBoostExpr_Exists() {
+        setBoostExpr_Exists(null);
+    }
+
+    public void setBoostExpr_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("boostExpr");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setBoostExpr_Missing() {
+        setBoostExpr_Missing(null);
+    }
+
+    public void setBoostExpr_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("boostExpr");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setBoostExpr_GreaterThan(String boostExpr) {
+        setBoostExpr_GreaterThan(boostExpr, null);
+    }
+
+    public void setBoostExpr_GreaterThan(String boostExpr, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("boostExpr", ConditionKey.CK_GREATER_THAN, boostExpr);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setBoostExpr_LessThan(String boostExpr) {
+        setBoostExpr_LessThan(boostExpr, null);
+    }
+
+    public void setBoostExpr_LessThan(String boostExpr, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("boostExpr", ConditionKey.CK_LESS_THAN, boostExpr);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setBoostExpr_GreaterEqual(String boostExpr) {
+        setBoostExpr_GreaterEqual(boostExpr, null);
+    }
+
+    public void setBoostExpr_GreaterEqual(String boostExpr, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("boostExpr", ConditionKey.CK_GREATER_EQUAL, boostExpr);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setBoostExpr_LessEqual(String boostExpr) {
+        setBoostExpr_LessEqual(boostExpr, null);
+    }
+
+    public void setBoostExpr_LessEqual(String boostExpr, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("boostExpr", ConditionKey.CK_LESS_EQUAL, boostExpr);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_Term(String createdBy) {
+        setCreatedBy_Term(createdBy, null);
+    }
+
+    public void setCreatedBy_Term(String createdBy, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_Terms(Collection<String> createdByList) {
+        setCreatedBy_Terms(createdByList, null);
+    }
+
+    public void setCreatedBy_Terms(Collection<String> createdByList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("createdBy", createdByList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_InScope(Collection<String> createdByList) {
+        setCreatedBy_Terms(createdByList, null);
+    }
+
+    public void setCreatedBy_InScope(Collection<String> createdByList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setCreatedBy_Terms(createdByList, opLambda);
+    }
+
+    public void setCreatedBy_Prefix(String createdBy) {
+        setCreatedBy_Prefix(createdBy, null);
+    }
+
+    public void setCreatedBy_Prefix(String createdBy, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_Exists() {
+        setCreatedBy_Exists(null);
+    }
+
+    public void setCreatedBy_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("createdBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_Missing() {
+        setCreatedBy_Missing(null);
+    }
+
+    public void setCreatedBy_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("createdBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_GreaterThan(String createdBy) {
+        setCreatedBy_GreaterThan(createdBy, null);
+    }
+
+    public void setCreatedBy_GreaterThan(String createdBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_GREATER_THAN, createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_LessThan(String createdBy) {
+        setCreatedBy_LessThan(createdBy, null);
+    }
+
+    public void setCreatedBy_LessThan(String createdBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_LESS_THAN, createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_GreaterEqual(String createdBy) {
+        setCreatedBy_GreaterEqual(createdBy, null);
+    }
+
+    public void setCreatedBy_GreaterEqual(String createdBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_LessEqual(String createdBy) {
+        setCreatedBy_LessEqual(createdBy, null);
+    }
+
+    public void setCreatedBy_LessEqual(String createdBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_Term(Long createdTime) {
+        setCreatedTime_Term(createdTime, null);
+    }
+
+    public void setCreatedTime_Term(Long createdTime, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("createdTime", createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_Terms(Collection<Long> createdTimeList) {
+        setCreatedTime_Terms(createdTimeList, null);
+    }
+
+    public void setCreatedTime_Terms(Collection<Long> createdTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("createdTime", createdTimeList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_InScope(Collection<Long> createdTimeList) {
+        setCreatedTime_Terms(createdTimeList, null);
+    }
+
+    public void setCreatedTime_InScope(Collection<Long> createdTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setCreatedTime_Terms(createdTimeList, opLambda);
+    }
+
+    public void setCreatedTime_Exists() {
+        setCreatedTime_Exists(null);
+    }
+
+    public void setCreatedTime_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("createdTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_Missing() {
+        setCreatedTime_Missing(null);
+    }
+
+    public void setCreatedTime_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("createdTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_GreaterThan(Long createdTime) {
+        setCreatedTime_GreaterThan(createdTime, null);
+    }
+
+    public void setCreatedTime_GreaterThan(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_THAN, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_LessThan(Long createdTime) {
+        setCreatedTime_LessThan(createdTime, null);
+    }
+
+    public void setCreatedTime_LessThan(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_THAN, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_GreaterEqual(Long createdTime) {
+        setCreatedTime_GreaterEqual(createdTime, null);
+    }
+
+    public void setCreatedTime_GreaterEqual(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_LessEqual(Long createdTime) {
+        setCreatedTime_LessEqual(createdTime, null);
+    }
+
+    public void setCreatedTime_LessEqual(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Term(String id) {
+        setId_Term(id, null);
+    }
+
+    public void setId_Term(String id, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("id", id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Terms(Collection<String> idList) {
+        setId_Terms(idList, null);
+    }
+
+    public void setId_Terms(Collection<String> idList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("id", idList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_InScope(Collection<String> idList) {
+        setId_Terms(idList, null);
+    }
+
+    public void setId_InScope(Collection<String> idList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setId_Terms(idList, opLambda);
+    }
+
+    public void setId_Prefix(String id) {
+        setId_Prefix(id, null);
+    }
+
+    public void setId_Prefix(String id, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("id", id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Exists() {
+        setId_Exists(null);
+    }
+
+    public void setId_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("id");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Missing() {
+        setId_Missing(null);
+    }
+
+    public void setId_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("id");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_GreaterThan(String id) {
+        setId_GreaterThan(id, null);
+    }
+
+    public void setId_GreaterThan(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_THAN, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_LessThan(String id) {
+        setId_LessThan(id, null);
+    }
+
+    public void setId_LessThan(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_THAN, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_GreaterEqual(String id) {
+        setId_GreaterEqual(id, null);
+    }
+
+    public void setId_GreaterEqual(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_EQUAL, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_LessEqual(String id) {
+        setId_LessEqual(id, null);
+    }
+
+    public void setId_LessEqual(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_EQUAL, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_Term(Integer sortOrder) {
+        setSortOrder_Term(sortOrder, null);
+    }
+
+    public void setSortOrder_Term(Integer sortOrder, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("sortOrder", sortOrder);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_Terms(Collection<Integer> sortOrderList) {
+        setSortOrder_Terms(sortOrderList, null);
+    }
+
+    public void setSortOrder_Terms(Collection<Integer> sortOrderList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("sortOrder", sortOrderList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_InScope(Collection<Integer> sortOrderList) {
+        setSortOrder_Terms(sortOrderList, null);
+    }
+
+    public void setSortOrder_InScope(Collection<Integer> sortOrderList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setSortOrder_Terms(sortOrderList, opLambda);
+    }
+
+    public void setSortOrder_Exists() {
+        setSortOrder_Exists(null);
+    }
+
+    public void setSortOrder_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("sortOrder");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_Missing() {
+        setSortOrder_Missing(null);
+    }
+
+    public void setSortOrder_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("sortOrder");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_GreaterThan(Integer sortOrder) {
+        setSortOrder_GreaterThan(sortOrder, null);
+    }
+
+    public void setSortOrder_GreaterThan(Integer sortOrder, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_GREATER_THAN, sortOrder);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_LessThan(Integer sortOrder) {
+        setSortOrder_LessThan(sortOrder, null);
+    }
+
+    public void setSortOrder_LessThan(Integer sortOrder, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_LESS_THAN, sortOrder);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_GreaterEqual(Integer sortOrder) {
+        setSortOrder_GreaterEqual(sortOrder, null);
+    }
+
+    public void setSortOrder_GreaterEqual(Integer sortOrder, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_GREATER_EQUAL, sortOrder);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_LessEqual(Integer sortOrder) {
+        setSortOrder_LessEqual(sortOrder, null);
+    }
+
+    public void setSortOrder_LessEqual(Integer sortOrder, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_LESS_EQUAL, sortOrder);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Term(String updatedBy) {
+        setUpdatedBy_Term(updatedBy, null);
+    }
+
+    public void setUpdatedBy_Term(String updatedBy, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Terms(Collection<String> updatedByList) {
+        setUpdatedBy_Terms(updatedByList, null);
+    }
+
+    public void setUpdatedBy_Terms(Collection<String> updatedByList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("updatedBy", updatedByList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_InScope(Collection<String> updatedByList) {
+        setUpdatedBy_Terms(updatedByList, null);
+    }
+
+    public void setUpdatedBy_InScope(Collection<String> updatedByList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setUpdatedBy_Terms(updatedByList, opLambda);
+    }
+
+    public void setUpdatedBy_Prefix(String updatedBy) {
+        setUpdatedBy_Prefix(updatedBy, null);
+    }
+
+    public void setUpdatedBy_Prefix(String updatedBy, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Exists() {
+        setUpdatedBy_Exists(null);
+    }
+
+    public void setUpdatedBy_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("updatedBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Missing() {
+        setUpdatedBy_Missing(null);
+    }
+
+    public void setUpdatedBy_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("updatedBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_GreaterThan(String updatedBy) {
+        setUpdatedBy_GreaterThan(updatedBy, null);
+    }
+
+    public void setUpdatedBy_GreaterThan(String updatedBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_LessThan(String updatedBy) {
+        setUpdatedBy_LessThan(updatedBy, null);
+    }
+
+    public void setUpdatedBy_LessThan(String updatedBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_GreaterEqual(String updatedBy) {
+        setUpdatedBy_GreaterEqual(updatedBy, null);
+    }
+
+    public void setUpdatedBy_GreaterEqual(String updatedBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_LessEqual(String updatedBy) {
+        setUpdatedBy_LessEqual(updatedBy, null);
+    }
+
+    public void setUpdatedBy_LessEqual(String updatedBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_Term(Long updatedTime) {
+        setUpdatedTime_Term(updatedTime, null);
+    }
+
+    public void setUpdatedTime_Term(Long updatedTime, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("updatedTime", updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_Terms(Collection<Long> updatedTimeList) {
+        setUpdatedTime_Terms(updatedTimeList, null);
+    }
+
+    public void setUpdatedTime_Terms(Collection<Long> updatedTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("updatedTime", updatedTimeList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_InScope(Collection<Long> updatedTimeList) {
+        setUpdatedTime_Terms(updatedTimeList, null);
+    }
+
+    public void setUpdatedTime_InScope(Collection<Long> updatedTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setUpdatedTime_Terms(updatedTimeList, opLambda);
+    }
+
+    public void setUpdatedTime_Exists() {
+        setUpdatedTime_Exists(null);
+    }
+
+    public void setUpdatedTime_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("updatedTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_Missing() {
+        setUpdatedTime_Missing(null);
+    }
+
+    public void setUpdatedTime_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("updatedTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_GreaterThan(Long updatedTime) {
+        setUpdatedTime_GreaterThan(updatedTime, null);
+    }
+
+    public void setUpdatedTime_GreaterThan(Long updatedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_LessThan(Long updatedTime) {
+        setUpdatedTime_LessThan(updatedTime, null);
+    }
+
+    public void setUpdatedTime_LessThan(Long updatedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_GreaterEqual(Long updatedTime) {
+        setUpdatedTime_GreaterEqual(updatedTime, null);
+    }
+
+    public void setUpdatedTime_GreaterEqual(Long updatedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_LessEqual(Long updatedTime) {
+        setUpdatedTime_LessEqual(updatedTime, null);
+    }
+
+    public void setUpdatedTime_LessEqual(Long updatedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUrlExpr_Term(String urlExpr) {
+        setUrlExpr_Term(urlExpr, null);
+    }
+
+    public void setUrlExpr_Term(String urlExpr, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("urlExpr", urlExpr);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUrlExpr_Terms(Collection<String> urlExprList) {
+        setUrlExpr_Terms(urlExprList, null);
+    }
+
+    public void setUrlExpr_Terms(Collection<String> urlExprList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("urlExpr", urlExprList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUrlExpr_InScope(Collection<String> urlExprList) {
+        setUrlExpr_Terms(urlExprList, null);
+    }
+
+    public void setUrlExpr_InScope(Collection<String> urlExprList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setUrlExpr_Terms(urlExprList, opLambda);
+    }
+
+    public void setUrlExpr_Prefix(String urlExpr) {
+        setUrlExpr_Prefix(urlExpr, null);
+    }
+
+    public void setUrlExpr_Prefix(String urlExpr, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("urlExpr", urlExpr);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUrlExpr_Exists() {
+        setUrlExpr_Exists(null);
+    }
+
+    public void setUrlExpr_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("urlExpr");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUrlExpr_Missing() {
+        setUrlExpr_Missing(null);
+    }
+
+    public void setUrlExpr_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("urlExpr");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUrlExpr_GreaterThan(String urlExpr) {
+        setUrlExpr_GreaterThan(urlExpr, null);
+    }
+
+    public void setUrlExpr_GreaterThan(String urlExpr, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("urlExpr", ConditionKey.CK_GREATER_THAN, urlExpr);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUrlExpr_LessThan(String urlExpr) {
+        setUrlExpr_LessThan(urlExpr, null);
+    }
+
+    public void setUrlExpr_LessThan(String urlExpr, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("urlExpr", ConditionKey.CK_LESS_THAN, urlExpr);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUrlExpr_GreaterEqual(String urlExpr) {
+        setUrlExpr_GreaterEqual(urlExpr, null);
+    }
+
+    public void setUrlExpr_GreaterEqual(String urlExpr, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("urlExpr", ConditionKey.CK_GREATER_EQUAL, urlExpr);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUrlExpr_LessEqual(String urlExpr) {
+        setUrlExpr_LessEqual(urlExpr, null);
+    }
+
+    public void setUrlExpr_LessEqual(String urlExpr, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("urlExpr", ConditionKey.CK_LESS_EQUAL, urlExpr);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+}

src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsClickLogCF.java

@@ -0,0 +1,526 @@
+package org.codelibs.fess.es.cbean.cf.bs;
+
+import java.util.Collection;
+
+import org.codelibs.fess.es.cbean.cf.ClickLogCF;
+import org.codelibs.fess.es.cbean.cq.ClickLogCQ;
+import org.dbflute.exception.IllegalConditionBeanOperationException;
+import org.dbflute.cbean.ckey.ConditionKey;
+import org.elasticsearch.index.query.AndFilterBuilder;
+import org.elasticsearch.index.query.BoolFilterBuilder;
+import org.elasticsearch.index.query.ExistsFilterBuilder;
+import org.elasticsearch.index.query.MissingFilterBuilder;
+import org.elasticsearch.index.query.NotFilterBuilder;
+import org.elasticsearch.index.query.OrFilterBuilder;
+import org.elasticsearch.index.query.PrefixFilterBuilder;
+import org.elasticsearch.index.query.QueryFilterBuilder;
+import org.elasticsearch.index.query.RangeFilterBuilder;
+import org.elasticsearch.index.query.TermFilterBuilder;
+import org.elasticsearch.index.query.TermsFilterBuilder;
+
+/**
+ * @author FreeGen
+ */
+public abstract class BsClickLogCF extends AbstractConditionFilter {
+
+    public void bool(BoolCall<ClickLogCF> boolLambda) {
+        bool(boolLambda, null);
+    }
+
+    public void bool(BoolCall<ClickLogCF> boolLambda, ConditionOptionCall<BoolFilterBuilder> opLambda) {
+        ClickLogCF mustFilter = new ClickLogCF();
+        ClickLogCF shouldFilter = new ClickLogCF();
+        ClickLogCF mustNotFilter = new ClickLogCF();
+        boolLambda.callback(mustFilter, shouldFilter, mustNotFilter);
+        if (mustFilter.hasFilters() || shouldFilter.hasFilters() || mustNotFilter.hasFilters()) {
+            BoolFilterBuilder builder =
+                    regBoolF(mustFilter.filterBuilderList, shouldFilter.filterBuilderList, mustNotFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void and(OperatorCall<ClickLogCF> andLambda) {
+        and(andLambda, null);
+    }
+
+    public void and(OperatorCall<ClickLogCF> andLambda, ConditionOptionCall<AndFilterBuilder> opLambda) {
+        ClickLogCF andFilter = new ClickLogCF();
+        andLambda.callback(andFilter);
+        if (andFilter.hasFilters()) {
+            AndFilterBuilder builder = regAndF(andFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void or(OperatorCall<ClickLogCF> orLambda) {
+        or(orLambda, null);
+    }
+
+    public void or(OperatorCall<ClickLogCF> orLambda, ConditionOptionCall<OrFilterBuilder> opLambda) {
+        ClickLogCF orFilter = new ClickLogCF();
+        orLambda.callback(orFilter);
+        if (orFilter.hasFilters()) {
+            OrFilterBuilder builder = regOrF(orFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void not(OperatorCall<ClickLogCF> notLambda) {
+        not(notLambda, null);
+    }
+
+    public void not(OperatorCall<ClickLogCF> notLambda, ConditionOptionCall<NotFilterBuilder> opLambda) {
+        ClickLogCF notFilter = new ClickLogCF();
+        notLambda.callback(notFilter);
+        if (notFilter.hasFilters()) {
+            if (notFilter.filterBuilderList.size() > 1) {
+                final String msg = "not filter must be one filter.";
+                throw new IllegalConditionBeanOperationException(msg);
+            }
+            NotFilterBuilder builder = regNotF(notFilter.filterBuilderList.get(0));
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall<ClickLogCQ> queryLambda) {
+        query(queryLambda, null);
+    }
+
+    public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall<ClickLogCQ> queryLambda,
+            ConditionOptionCall<QueryFilterBuilder> opLambda) {
+        ClickLogCQ query = new ClickLogCQ();
+        queryLambda.callback(query);
+        if (query.hasQueries()) {
+            QueryFilterBuilder builder = regQueryF(query.getQuery());
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void setId_Term(String id) {
+        setId_Term(id, null);
+    }
+
+    public void setId_Term(String id, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("id", id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Terms(Collection<String> idList) {
+        setId_Terms(idList, null);
+    }
+
+    public void setId_Terms(Collection<String> idList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("id", idList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_InScope(Collection<String> idList) {
+        setId_Terms(idList, null);
+    }
+
+    public void setId_InScope(Collection<String> idList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setId_Terms(idList, opLambda);
+    }
+
+    public void setId_Prefix(String id) {
+        setId_Prefix(id, null);
+    }
+
+    public void setId_Prefix(String id, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("id", id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Exists() {
+        setId_Exists(null);
+    }
+
+    public void setId_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("id");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Missing() {
+        setId_Missing(null);
+    }
+
+    public void setId_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("id");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_GreaterThan(String id) {
+        setId_GreaterThan(id, null);
+    }
+
+    public void setId_GreaterThan(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_THAN, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_LessThan(String id) {
+        setId_LessThan(id, null);
+    }
+
+    public void setId_LessThan(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_THAN, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_GreaterEqual(String id) {
+        setId_GreaterEqual(id, null);
+    }
+
+    public void setId_GreaterEqual(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_EQUAL, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_LessEqual(String id) {
+        setId_LessEqual(id, null);
+    }
+
+    public void setId_LessEqual(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_EQUAL, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRequestedTime_Term(Long requestedTime) {
+        setRequestedTime_Term(requestedTime, null);
+    }
+
+    public void setRequestedTime_Term(Long requestedTime, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("requestedTime", requestedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRequestedTime_Terms(Collection<Long> requestedTimeList) {
+        setRequestedTime_Terms(requestedTimeList, null);
+    }
+
+    public void setRequestedTime_Terms(Collection<Long> requestedTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("requestedTime", requestedTimeList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRequestedTime_InScope(Collection<Long> requestedTimeList) {
+        setRequestedTime_Terms(requestedTimeList, null);
+    }
+
+    public void setRequestedTime_InScope(Collection<Long> requestedTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setRequestedTime_Terms(requestedTimeList, opLambda);
+    }
+
+    public void setRequestedTime_Exists() {
+        setRequestedTime_Exists(null);
+    }
+
+    public void setRequestedTime_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("requestedTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRequestedTime_Missing() {
+        setRequestedTime_Missing(null);
+    }
+
+    public void setRequestedTime_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("requestedTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRequestedTime_GreaterThan(Long requestedTime) {
+        setRequestedTime_GreaterThan(requestedTime, null);
+    }
+
+    public void setRequestedTime_GreaterThan(Long requestedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("requestedTime", ConditionKey.CK_GREATER_THAN, requestedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRequestedTime_LessThan(Long requestedTime) {
+        setRequestedTime_LessThan(requestedTime, null);
+    }
+
+    public void setRequestedTime_LessThan(Long requestedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("requestedTime", ConditionKey.CK_LESS_THAN, requestedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRequestedTime_GreaterEqual(Long requestedTime) {
+        setRequestedTime_GreaterEqual(requestedTime, null);
+    }
+
+    public void setRequestedTime_GreaterEqual(Long requestedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("requestedTime", ConditionKey.CK_GREATER_EQUAL, requestedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRequestedTime_LessEqual(Long requestedTime) {
+        setRequestedTime_LessEqual(requestedTime, null);
+    }
+
+    public void setRequestedTime_LessEqual(Long requestedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("requestedTime", ConditionKey.CK_LESS_EQUAL, requestedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSearchLogId_Term(String searchLogId) {
+        setSearchLogId_Term(searchLogId, null);
+    }
+
+    public void setSearchLogId_Term(String searchLogId, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("searchLogId", searchLogId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSearchLogId_Terms(Collection<String> searchLogIdList) {
+        setSearchLogId_Terms(searchLogIdList, null);
+    }
+
+    public void setSearchLogId_Terms(Collection<String> searchLogIdList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("searchLogId", searchLogIdList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSearchLogId_InScope(Collection<String> searchLogIdList) {
+        setSearchLogId_Terms(searchLogIdList, null);
+    }
+
+    public void setSearchLogId_InScope(Collection<String> searchLogIdList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setSearchLogId_Terms(searchLogIdList, opLambda);
+    }
+
+    public void setSearchLogId_Prefix(String searchLogId) {
+        setSearchLogId_Prefix(searchLogId, null);
+    }
+
+    public void setSearchLogId_Prefix(String searchLogId, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("searchLogId", searchLogId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSearchLogId_Exists() {
+        setSearchLogId_Exists(null);
+    }
+
+    public void setSearchLogId_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("searchLogId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSearchLogId_Missing() {
+        setSearchLogId_Missing(null);
+    }
+
+    public void setSearchLogId_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("searchLogId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSearchLogId_GreaterThan(String searchLogId) {
+        setSearchLogId_GreaterThan(searchLogId, null);
+    }
+
+    public void setSearchLogId_GreaterThan(String searchLogId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("searchLogId", ConditionKey.CK_GREATER_THAN, searchLogId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSearchLogId_LessThan(String searchLogId) {
+        setSearchLogId_LessThan(searchLogId, null);
+    }
+
+    public void setSearchLogId_LessThan(String searchLogId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("searchLogId", ConditionKey.CK_LESS_THAN, searchLogId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSearchLogId_GreaterEqual(String searchLogId) {
+        setSearchLogId_GreaterEqual(searchLogId, null);
+    }
+
+    public void setSearchLogId_GreaterEqual(String searchLogId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("searchLogId", ConditionKey.CK_GREATER_EQUAL, searchLogId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSearchLogId_LessEqual(String searchLogId) {
+        setSearchLogId_LessEqual(searchLogId, null);
+    }
+
+    public void setSearchLogId_LessEqual(String searchLogId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("searchLogId", ConditionKey.CK_LESS_EQUAL, searchLogId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUrl_Term(String url) {
+        setUrl_Term(url, null);
+    }
+
+    public void setUrl_Term(String url, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("url", url);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUrl_Terms(Collection<String> urlList) {
+        setUrl_Terms(urlList, null);
+    }
+
+    public void setUrl_Terms(Collection<String> urlList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("url", urlList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUrl_InScope(Collection<String> urlList) {
+        setUrl_Terms(urlList, null);
+    }
+
+    public void setUrl_InScope(Collection<String> urlList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setUrl_Terms(urlList, opLambda);
+    }
+
+    public void setUrl_Prefix(String url) {
+        setUrl_Prefix(url, null);
+    }
+
+    public void setUrl_Prefix(String url, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("url", url);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUrl_Exists() {
+        setUrl_Exists(null);
+    }
+
+    public void setUrl_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("url");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUrl_Missing() {
+        setUrl_Missing(null);
+    }
+
+    public void setUrl_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("url");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUrl_GreaterThan(String url) {
+        setUrl_GreaterThan(url, null);
+    }
+
+    public void setUrl_GreaterThan(String url, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("url", ConditionKey.CK_GREATER_THAN, url);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUrl_LessThan(String url) {
+        setUrl_LessThan(url, null);
+    }
+
+    public void setUrl_LessThan(String url, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("url", ConditionKey.CK_LESS_THAN, url);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUrl_GreaterEqual(String url) {
+        setUrl_GreaterEqual(url, null);
+    }
+
+    public void setUrl_GreaterEqual(String url, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("url", ConditionKey.CK_GREATER_EQUAL, url);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUrl_LessEqual(String url) {
+        setUrl_LessEqual(url, null);
+    }
+
+    public void setUrl_LessEqual(String url, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("url", ConditionKey.CK_LESS_EQUAL, url);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+}

src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsCrawlingSessionCF.java

@@ -0,0 +1,622 @@
+package org.codelibs.fess.es.cbean.cf.bs;
+
+import java.util.Collection;
+
+import org.codelibs.fess.es.cbean.cf.CrawlingSessionCF;
+import org.codelibs.fess.es.cbean.cq.CrawlingSessionCQ;
+import org.dbflute.exception.IllegalConditionBeanOperationException;
+import org.dbflute.cbean.ckey.ConditionKey;
+import org.elasticsearch.index.query.AndFilterBuilder;
+import org.elasticsearch.index.query.BoolFilterBuilder;
+import org.elasticsearch.index.query.ExistsFilterBuilder;
+import org.elasticsearch.index.query.MissingFilterBuilder;
+import org.elasticsearch.index.query.NotFilterBuilder;
+import org.elasticsearch.index.query.OrFilterBuilder;
+import org.elasticsearch.index.query.PrefixFilterBuilder;
+import org.elasticsearch.index.query.QueryFilterBuilder;
+import org.elasticsearch.index.query.RangeFilterBuilder;
+import org.elasticsearch.index.query.TermFilterBuilder;
+import org.elasticsearch.index.query.TermsFilterBuilder;
+
+/**
+ * @author FreeGen
+ */
+public abstract class BsCrawlingSessionCF extends AbstractConditionFilter {
+
+    public void bool(BoolCall<CrawlingSessionCF> boolLambda) {
+        bool(boolLambda, null);
+    }
+
+    public void bool(BoolCall<CrawlingSessionCF> boolLambda, ConditionOptionCall<BoolFilterBuilder> opLambda) {
+        CrawlingSessionCF mustFilter = new CrawlingSessionCF();
+        CrawlingSessionCF shouldFilter = new CrawlingSessionCF();
+        CrawlingSessionCF mustNotFilter = new CrawlingSessionCF();
+        boolLambda.callback(mustFilter, shouldFilter, mustNotFilter);
+        if (mustFilter.hasFilters() || shouldFilter.hasFilters() || mustNotFilter.hasFilters()) {
+            BoolFilterBuilder builder =
+                    regBoolF(mustFilter.filterBuilderList, shouldFilter.filterBuilderList, mustNotFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void and(OperatorCall<CrawlingSessionCF> andLambda) {
+        and(andLambda, null);
+    }
+
+    public void and(OperatorCall<CrawlingSessionCF> andLambda, ConditionOptionCall<AndFilterBuilder> opLambda) {
+        CrawlingSessionCF andFilter = new CrawlingSessionCF();
+        andLambda.callback(andFilter);
+        if (andFilter.hasFilters()) {
+            AndFilterBuilder builder = regAndF(andFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void or(OperatorCall<CrawlingSessionCF> orLambda) {
+        or(orLambda, null);
+    }
+
+    public void or(OperatorCall<CrawlingSessionCF> orLambda, ConditionOptionCall<OrFilterBuilder> opLambda) {
+        CrawlingSessionCF orFilter = new CrawlingSessionCF();
+        orLambda.callback(orFilter);
+        if (orFilter.hasFilters()) {
+            OrFilterBuilder builder = regOrF(orFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void not(OperatorCall<CrawlingSessionCF> notLambda) {
+        not(notLambda, null);
+    }
+
+    public void not(OperatorCall<CrawlingSessionCF> notLambda, ConditionOptionCall<NotFilterBuilder> opLambda) {
+        CrawlingSessionCF notFilter = new CrawlingSessionCF();
+        notLambda.callback(notFilter);
+        if (notFilter.hasFilters()) {
+            if (notFilter.filterBuilderList.size() > 1) {
+                final String msg = "not filter must be one filter.";
+                throw new IllegalConditionBeanOperationException(msg);
+            }
+            NotFilterBuilder builder = regNotF(notFilter.filterBuilderList.get(0));
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall<CrawlingSessionCQ> queryLambda) {
+        query(queryLambda, null);
+    }
+
+    public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall<CrawlingSessionCQ> queryLambda,
+            ConditionOptionCall<QueryFilterBuilder> opLambda) {
+        CrawlingSessionCQ query = new CrawlingSessionCQ();
+        queryLambda.callback(query);
+        if (query.hasQueries()) {
+            QueryFilterBuilder builder = regQueryF(query.getQuery());
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void setCreatedTime_Term(Long createdTime) {
+        setCreatedTime_Term(createdTime, null);
+    }
+
+    public void setCreatedTime_Term(Long createdTime, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("createdTime", createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_Terms(Collection<Long> createdTimeList) {
+        setCreatedTime_Terms(createdTimeList, null);
+    }
+
+    public void setCreatedTime_Terms(Collection<Long> createdTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("createdTime", createdTimeList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_InScope(Collection<Long> createdTimeList) {
+        setCreatedTime_Terms(createdTimeList, null);
+    }
+
+    public void setCreatedTime_InScope(Collection<Long> createdTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setCreatedTime_Terms(createdTimeList, opLambda);
+    }
+
+    public void setCreatedTime_Exists() {
+        setCreatedTime_Exists(null);
+    }
+
+    public void setCreatedTime_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("createdTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_Missing() {
+        setCreatedTime_Missing(null);
+    }
+
+    public void setCreatedTime_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("createdTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_GreaterThan(Long createdTime) {
+        setCreatedTime_GreaterThan(createdTime, null);
+    }
+
+    public void setCreatedTime_GreaterThan(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_THAN, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_LessThan(Long createdTime) {
+        setCreatedTime_LessThan(createdTime, null);
+    }
+
+    public void setCreatedTime_LessThan(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_THAN, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_GreaterEqual(Long createdTime) {
+        setCreatedTime_GreaterEqual(createdTime, null);
+    }
+
+    public void setCreatedTime_GreaterEqual(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_LessEqual(Long createdTime) {
+        setCreatedTime_LessEqual(createdTime, null);
+    }
+
+    public void setCreatedTime_LessEqual(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setExpiredTime_Term(Long expiredTime) {
+        setExpiredTime_Term(expiredTime, null);
+    }
+
+    public void setExpiredTime_Term(Long expiredTime, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("expiredTime", expiredTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setExpiredTime_Terms(Collection<Long> expiredTimeList) {
+        setExpiredTime_Terms(expiredTimeList, null);
+    }
+
+    public void setExpiredTime_Terms(Collection<Long> expiredTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("expiredTime", expiredTimeList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setExpiredTime_InScope(Collection<Long> expiredTimeList) {
+        setExpiredTime_Terms(expiredTimeList, null);
+    }
+
+    public void setExpiredTime_InScope(Collection<Long> expiredTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setExpiredTime_Terms(expiredTimeList, opLambda);
+    }
+
+    public void setExpiredTime_Exists() {
+        setExpiredTime_Exists(null);
+    }
+
+    public void setExpiredTime_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("expiredTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setExpiredTime_Missing() {
+        setExpiredTime_Missing(null);
+    }
+
+    public void setExpiredTime_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("expiredTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setExpiredTime_GreaterThan(Long expiredTime) {
+        setExpiredTime_GreaterThan(expiredTime, null);
+    }
+
+    public void setExpiredTime_GreaterThan(Long expiredTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("expiredTime", ConditionKey.CK_GREATER_THAN, expiredTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setExpiredTime_LessThan(Long expiredTime) {
+        setExpiredTime_LessThan(expiredTime, null);
+    }
+
+    public void setExpiredTime_LessThan(Long expiredTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("expiredTime", ConditionKey.CK_LESS_THAN, expiredTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setExpiredTime_GreaterEqual(Long expiredTime) {
+        setExpiredTime_GreaterEqual(expiredTime, null);
+    }
+
+    public void setExpiredTime_GreaterEqual(Long expiredTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("expiredTime", ConditionKey.CK_GREATER_EQUAL, expiredTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setExpiredTime_LessEqual(Long expiredTime) {
+        setExpiredTime_LessEqual(expiredTime, null);
+    }
+
+    public void setExpiredTime_LessEqual(Long expiredTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("expiredTime", ConditionKey.CK_LESS_EQUAL, expiredTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Term(String id) {
+        setId_Term(id, null);
+    }
+
+    public void setId_Term(String id, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("id", id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Terms(Collection<String> idList) {
+        setId_Terms(idList, null);
+    }
+
+    public void setId_Terms(Collection<String> idList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("id", idList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_InScope(Collection<String> idList) {
+        setId_Terms(idList, null);
+    }
+
+    public void setId_InScope(Collection<String> idList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setId_Terms(idList, opLambda);
+    }
+
+    public void setId_Prefix(String id) {
+        setId_Prefix(id, null);
+    }
+
+    public void setId_Prefix(String id, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("id", id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Exists() {
+        setId_Exists(null);
+    }
+
+    public void setId_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("id");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Missing() {
+        setId_Missing(null);
+    }
+
+    public void setId_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("id");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_GreaterThan(String id) {
+        setId_GreaterThan(id, null);
+    }
+
+    public void setId_GreaterThan(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_THAN, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_LessThan(String id) {
+        setId_LessThan(id, null);
+    }
+
+    public void setId_LessThan(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_THAN, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_GreaterEqual(String id) {
+        setId_GreaterEqual(id, null);
+    }
+
+    public void setId_GreaterEqual(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_EQUAL, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_LessEqual(String id) {
+        setId_LessEqual(id, null);
+    }
+
+    public void setId_LessEqual(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_EQUAL, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_Term(String name) {
+        setName_Term(name, null);
+    }
+
+    public void setName_Term(String name, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("name", name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_Terms(Collection<String> nameList) {
+        setName_Terms(nameList, null);
+    }
+
+    public void setName_Terms(Collection<String> nameList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("name", nameList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_InScope(Collection<String> nameList) {
+        setName_Terms(nameList, null);
+    }
+
+    public void setName_InScope(Collection<String> nameList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setName_Terms(nameList, opLambda);
+    }
+
+    public void setName_Prefix(String name) {
+        setName_Prefix(name, null);
+    }
+
+    public void setName_Prefix(String name, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("name", name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_Exists() {
+        setName_Exists(null);
+    }
+
+    public void setName_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("name");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_Missing() {
+        setName_Missing(null);
+    }
+
+    public void setName_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("name");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_GreaterThan(String name) {
+        setName_GreaterThan(name, null);
+    }
+
+    public void setName_GreaterThan(String name, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_GREATER_THAN, name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_LessThan(String name) {
+        setName_LessThan(name, null);
+    }
+
+    public void setName_LessThan(String name, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_LESS_THAN, name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_GreaterEqual(String name) {
+        setName_GreaterEqual(name, null);
+    }
+
+    public void setName_GreaterEqual(String name, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_GREATER_EQUAL, name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_LessEqual(String name) {
+        setName_LessEqual(name, null);
+    }
+
+    public void setName_LessEqual(String name, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_LESS_EQUAL, name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSessionId_Term(String sessionId) {
+        setSessionId_Term(sessionId, null);
+    }
+
+    public void setSessionId_Term(String sessionId, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("sessionId", sessionId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSessionId_Terms(Collection<String> sessionIdList) {
+        setSessionId_Terms(sessionIdList, null);
+    }
+
+    public void setSessionId_Terms(Collection<String> sessionIdList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("sessionId", sessionIdList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSessionId_InScope(Collection<String> sessionIdList) {
+        setSessionId_Terms(sessionIdList, null);
+    }
+
+    public void setSessionId_InScope(Collection<String> sessionIdList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setSessionId_Terms(sessionIdList, opLambda);
+    }
+
+    public void setSessionId_Prefix(String sessionId) {
+        setSessionId_Prefix(sessionId, null);
+    }
+
+    public void setSessionId_Prefix(String sessionId, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("sessionId", sessionId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSessionId_Exists() {
+        setSessionId_Exists(null);
+    }
+
+    public void setSessionId_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("sessionId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSessionId_Missing() {
+        setSessionId_Missing(null);
+    }
+
+    public void setSessionId_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("sessionId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSessionId_GreaterThan(String sessionId) {
+        setSessionId_GreaterThan(sessionId, null);
+    }
+
+    public void setSessionId_GreaterThan(String sessionId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("sessionId", ConditionKey.CK_GREATER_THAN, sessionId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSessionId_LessThan(String sessionId) {
+        setSessionId_LessThan(sessionId, null);
+    }
+
+    public void setSessionId_LessThan(String sessionId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("sessionId", ConditionKey.CK_LESS_THAN, sessionId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSessionId_GreaterEqual(String sessionId) {
+        setSessionId_GreaterEqual(sessionId, null);
+    }
+
+    public void setSessionId_GreaterEqual(String sessionId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("sessionId", ConditionKey.CK_GREATER_EQUAL, sessionId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSessionId_LessEqual(String sessionId) {
+        setSessionId_LessEqual(sessionId, null);
+    }
+
+    public void setSessionId_LessEqual(String sessionId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("sessionId", ConditionKey.CK_LESS_EQUAL, sessionId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+}

src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsCrawlingSessionInfoCF.java

@@ -0,0 +1,633 @@
+package org.codelibs.fess.es.cbean.cf.bs;
+
+import java.util.Collection;
+
+import org.codelibs.fess.es.cbean.cf.CrawlingSessionInfoCF;
+import org.codelibs.fess.es.cbean.cq.CrawlingSessionInfoCQ;
+import org.dbflute.exception.IllegalConditionBeanOperationException;
+import org.dbflute.cbean.ckey.ConditionKey;
+import org.elasticsearch.index.query.AndFilterBuilder;
+import org.elasticsearch.index.query.BoolFilterBuilder;
+import org.elasticsearch.index.query.ExistsFilterBuilder;
+import org.elasticsearch.index.query.MissingFilterBuilder;
+import org.elasticsearch.index.query.NotFilterBuilder;
+import org.elasticsearch.index.query.OrFilterBuilder;
+import org.elasticsearch.index.query.PrefixFilterBuilder;
+import org.elasticsearch.index.query.QueryFilterBuilder;
+import org.elasticsearch.index.query.RangeFilterBuilder;
+import org.elasticsearch.index.query.TermFilterBuilder;
+import org.elasticsearch.index.query.TermsFilterBuilder;
+
+/**
+ * @author FreeGen
+ */
+public abstract class BsCrawlingSessionInfoCF extends AbstractConditionFilter {
+
+    public void bool(BoolCall<CrawlingSessionInfoCF> boolLambda) {
+        bool(boolLambda, null);
+    }
+
+    public void bool(BoolCall<CrawlingSessionInfoCF> boolLambda, ConditionOptionCall<BoolFilterBuilder> opLambda) {
+        CrawlingSessionInfoCF mustFilter = new CrawlingSessionInfoCF();
+        CrawlingSessionInfoCF shouldFilter = new CrawlingSessionInfoCF();
+        CrawlingSessionInfoCF mustNotFilter = new CrawlingSessionInfoCF();
+        boolLambda.callback(mustFilter, shouldFilter, mustNotFilter);
+        if (mustFilter.hasFilters() || shouldFilter.hasFilters() || mustNotFilter.hasFilters()) {
+            BoolFilterBuilder builder =
+                    regBoolF(mustFilter.filterBuilderList, shouldFilter.filterBuilderList, mustNotFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void and(OperatorCall<CrawlingSessionInfoCF> andLambda) {
+        and(andLambda, null);
+    }
+
+    public void and(OperatorCall<CrawlingSessionInfoCF> andLambda, ConditionOptionCall<AndFilterBuilder> opLambda) {
+        CrawlingSessionInfoCF andFilter = new CrawlingSessionInfoCF();
+        andLambda.callback(andFilter);
+        if (andFilter.hasFilters()) {
+            AndFilterBuilder builder = regAndF(andFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void or(OperatorCall<CrawlingSessionInfoCF> orLambda) {
+        or(orLambda, null);
+    }
+
+    public void or(OperatorCall<CrawlingSessionInfoCF> orLambda, ConditionOptionCall<OrFilterBuilder> opLambda) {
+        CrawlingSessionInfoCF orFilter = new CrawlingSessionInfoCF();
+        orLambda.callback(orFilter);
+        if (orFilter.hasFilters()) {
+            OrFilterBuilder builder = regOrF(orFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void not(OperatorCall<CrawlingSessionInfoCF> notLambda) {
+        not(notLambda, null);
+    }
+
+    public void not(OperatorCall<CrawlingSessionInfoCF> notLambda, ConditionOptionCall<NotFilterBuilder> opLambda) {
+        CrawlingSessionInfoCF notFilter = new CrawlingSessionInfoCF();
+        notLambda.callback(notFilter);
+        if (notFilter.hasFilters()) {
+            if (notFilter.filterBuilderList.size() > 1) {
+                final String msg = "not filter must be one filter.";
+                throw new IllegalConditionBeanOperationException(msg);
+            }
+            NotFilterBuilder builder = regNotF(notFilter.filterBuilderList.get(0));
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall<CrawlingSessionInfoCQ> queryLambda) {
+        query(queryLambda, null);
+    }
+
+    public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall<CrawlingSessionInfoCQ> queryLambda,
+            ConditionOptionCall<QueryFilterBuilder> opLambda) {
+        CrawlingSessionInfoCQ query = new CrawlingSessionInfoCQ();
+        queryLambda.callback(query);
+        if (query.hasQueries()) {
+            QueryFilterBuilder builder = regQueryF(query.getQuery());
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void setCrawlingSessionId_Term(String crawlingSessionId) {
+        setCrawlingSessionId_Term(crawlingSessionId, null);
+    }
+
+    public void setCrawlingSessionId_Term(String crawlingSessionId, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("crawlingSessionId", crawlingSessionId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCrawlingSessionId_Terms(Collection<String> crawlingSessionIdList) {
+        setCrawlingSessionId_Terms(crawlingSessionIdList, null);
+    }
+
+    public void setCrawlingSessionId_Terms(Collection<String> crawlingSessionIdList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("crawlingSessionId", crawlingSessionIdList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCrawlingSessionId_InScope(Collection<String> crawlingSessionIdList) {
+        setCrawlingSessionId_Terms(crawlingSessionIdList, null);
+    }
+
+    public void setCrawlingSessionId_InScope(Collection<String> crawlingSessionIdList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setCrawlingSessionId_Terms(crawlingSessionIdList, opLambda);
+    }
+
+    public void setCrawlingSessionId_Prefix(String crawlingSessionId) {
+        setCrawlingSessionId_Prefix(crawlingSessionId, null);
+    }
+
+    public void setCrawlingSessionId_Prefix(String crawlingSessionId, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("crawlingSessionId", crawlingSessionId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCrawlingSessionId_Exists() {
+        setCrawlingSessionId_Exists(null);
+    }
+
+    public void setCrawlingSessionId_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("crawlingSessionId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCrawlingSessionId_Missing() {
+        setCrawlingSessionId_Missing(null);
+    }
+
+    public void setCrawlingSessionId_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("crawlingSessionId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCrawlingSessionId_GreaterThan(String crawlingSessionId) {
+        setCrawlingSessionId_GreaterThan(crawlingSessionId, null);
+    }
+
+    public void setCrawlingSessionId_GreaterThan(String crawlingSessionId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("crawlingSessionId", ConditionKey.CK_GREATER_THAN, crawlingSessionId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCrawlingSessionId_LessThan(String crawlingSessionId) {
+        setCrawlingSessionId_LessThan(crawlingSessionId, null);
+    }
+
+    public void setCrawlingSessionId_LessThan(String crawlingSessionId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("crawlingSessionId", ConditionKey.CK_LESS_THAN, crawlingSessionId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCrawlingSessionId_GreaterEqual(String crawlingSessionId) {
+        setCrawlingSessionId_GreaterEqual(crawlingSessionId, null);
+    }
+
+    public void setCrawlingSessionId_GreaterEqual(String crawlingSessionId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("crawlingSessionId", ConditionKey.CK_GREATER_EQUAL, crawlingSessionId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCrawlingSessionId_LessEqual(String crawlingSessionId) {
+        setCrawlingSessionId_LessEqual(crawlingSessionId, null);
+    }
+
+    public void setCrawlingSessionId_LessEqual(String crawlingSessionId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("crawlingSessionId", ConditionKey.CK_LESS_EQUAL, crawlingSessionId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_Term(Long createdTime) {
+        setCreatedTime_Term(createdTime, null);
+    }
+
+    public void setCreatedTime_Term(Long createdTime, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("createdTime", createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_Terms(Collection<Long> createdTimeList) {
+        setCreatedTime_Terms(createdTimeList, null);
+    }
+
+    public void setCreatedTime_Terms(Collection<Long> createdTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("createdTime", createdTimeList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_InScope(Collection<Long> createdTimeList) {
+        setCreatedTime_Terms(createdTimeList, null);
+    }
+
+    public void setCreatedTime_InScope(Collection<Long> createdTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setCreatedTime_Terms(createdTimeList, opLambda);
+    }
+
+    public void setCreatedTime_Exists() {
+        setCreatedTime_Exists(null);
+    }
+
+    public void setCreatedTime_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("createdTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_Missing() {
+        setCreatedTime_Missing(null);
+    }
+
+    public void setCreatedTime_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("createdTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_GreaterThan(Long createdTime) {
+        setCreatedTime_GreaterThan(createdTime, null);
+    }
+
+    public void setCreatedTime_GreaterThan(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_THAN, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_LessThan(Long createdTime) {
+        setCreatedTime_LessThan(createdTime, null);
+    }
+
+    public void setCreatedTime_LessThan(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_THAN, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_GreaterEqual(Long createdTime) {
+        setCreatedTime_GreaterEqual(createdTime, null);
+    }
+
+    public void setCreatedTime_GreaterEqual(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_LessEqual(Long createdTime) {
+        setCreatedTime_LessEqual(createdTime, null);
+    }
+
+    public void setCreatedTime_LessEqual(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Term(String id) {
+        setId_Term(id, null);
+    }
+
+    public void setId_Term(String id, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("id", id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Terms(Collection<String> idList) {
+        setId_Terms(idList, null);
+    }
+
+    public void setId_Terms(Collection<String> idList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("id", idList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_InScope(Collection<String> idList) {
+        setId_Terms(idList, null);
+    }
+
+    public void setId_InScope(Collection<String> idList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setId_Terms(idList, opLambda);
+    }
+
+    public void setId_Prefix(String id) {
+        setId_Prefix(id, null);
+    }
+
+    public void setId_Prefix(String id, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("id", id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Exists() {
+        setId_Exists(null);
+    }
+
+    public void setId_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("id");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Missing() {
+        setId_Missing(null);
+    }
+
+    public void setId_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("id");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_GreaterThan(String id) {
+        setId_GreaterThan(id, null);
+    }
+
+    public void setId_GreaterThan(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_THAN, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_LessThan(String id) {
+        setId_LessThan(id, null);
+    }
+
+    public void setId_LessThan(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_THAN, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_GreaterEqual(String id) {
+        setId_GreaterEqual(id, null);
+    }
+
+    public void setId_GreaterEqual(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_EQUAL, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_LessEqual(String id) {
+        setId_LessEqual(id, null);
+    }
+
+    public void setId_LessEqual(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_EQUAL, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setKey_Term(String key) {
+        setKey_Term(key, null);
+    }
+
+    public void setKey_Term(String key, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("key", key);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setKey_Terms(Collection<String> keyList) {
+        setKey_Terms(keyList, null);
+    }
+
+    public void setKey_Terms(Collection<String> keyList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("key", keyList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setKey_InScope(Collection<String> keyList) {
+        setKey_Terms(keyList, null);
+    }
+
+    public void setKey_InScope(Collection<String> keyList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setKey_Terms(keyList, opLambda);
+    }
+
+    public void setKey_Prefix(String key) {
+        setKey_Prefix(key, null);
+    }
+
+    public void setKey_Prefix(String key, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("key", key);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setKey_Exists() {
+        setKey_Exists(null);
+    }
+
+    public void setKey_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("key");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setKey_Missing() {
+        setKey_Missing(null);
+    }
+
+    public void setKey_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("key");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setKey_GreaterThan(String key) {
+        setKey_GreaterThan(key, null);
+    }
+
+    public void setKey_GreaterThan(String key, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("key", ConditionKey.CK_GREATER_THAN, key);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setKey_LessThan(String key) {
+        setKey_LessThan(key, null);
+    }
+
+    public void setKey_LessThan(String key, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("key", ConditionKey.CK_LESS_THAN, key);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setKey_GreaterEqual(String key) {
+        setKey_GreaterEqual(key, null);
+    }
+
+    public void setKey_GreaterEqual(String key, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("key", ConditionKey.CK_GREATER_EQUAL, key);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setKey_LessEqual(String key) {
+        setKey_LessEqual(key, null);
+    }
+
+    public void setKey_LessEqual(String key, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("key", ConditionKey.CK_LESS_EQUAL, key);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setValue_Term(String value) {
+        setValue_Term(value, null);
+    }
+
+    public void setValue_Term(String value, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("value", value);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setValue_Terms(Collection<String> valueList) {
+        setValue_Terms(valueList, null);
+    }
+
+    public void setValue_Terms(Collection<String> valueList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("value", valueList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setValue_InScope(Collection<String> valueList) {
+        setValue_Terms(valueList, null);
+    }
+
+    public void setValue_InScope(Collection<String> valueList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setValue_Terms(valueList, opLambda);
+    }
+
+    public void setValue_Prefix(String value) {
+        setValue_Prefix(value, null);
+    }
+
+    public void setValue_Prefix(String value, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("value", value);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setValue_Exists() {
+        setValue_Exists(null);
+    }
+
+    public void setValue_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("value");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setValue_Missing() {
+        setValue_Missing(null);
+    }
+
+    public void setValue_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("value");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setValue_GreaterThan(String value) {
+        setValue_GreaterThan(value, null);
+    }
+
+    public void setValue_GreaterThan(String value, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("value", ConditionKey.CK_GREATER_THAN, value);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setValue_LessThan(String value) {
+        setValue_LessThan(value, null);
+    }
+
+    public void setValue_LessThan(String value, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("value", ConditionKey.CK_LESS_THAN, value);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setValue_GreaterEqual(String value) {
+        setValue_GreaterEqual(value, null);
+    }
+
+    public void setValue_GreaterEqual(String value, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("value", ConditionKey.CK_GREATER_EQUAL, value);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setValue_LessEqual(String value) {
+        setValue_LessEqual(value, null);
+    }
+
+    public void setValue_LessEqual(String value, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("value", ConditionKey.CK_LESS_EQUAL, value);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+}

src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsDataConfigCF.java

@@ -0,0 +1,1338 @@
+package org.codelibs.fess.es.cbean.cf.bs;
+
+import java.util.Collection;
+
+import org.codelibs.fess.es.cbean.cf.DataConfigCF;
+import org.codelibs.fess.es.cbean.cq.DataConfigCQ;
+import org.dbflute.exception.IllegalConditionBeanOperationException;
+import org.dbflute.cbean.ckey.ConditionKey;
+import org.elasticsearch.index.query.AndFilterBuilder;
+import org.elasticsearch.index.query.BoolFilterBuilder;
+import org.elasticsearch.index.query.ExistsFilterBuilder;
+import org.elasticsearch.index.query.MissingFilterBuilder;
+import org.elasticsearch.index.query.NotFilterBuilder;
+import org.elasticsearch.index.query.OrFilterBuilder;
+import org.elasticsearch.index.query.PrefixFilterBuilder;
+import org.elasticsearch.index.query.QueryFilterBuilder;
+import org.elasticsearch.index.query.RangeFilterBuilder;
+import org.elasticsearch.index.query.TermFilterBuilder;
+import org.elasticsearch.index.query.TermsFilterBuilder;
+
+/**
+ * @author FreeGen
+ */
+public abstract class BsDataConfigCF extends AbstractConditionFilter {
+
+    public void bool(BoolCall<DataConfigCF> boolLambda) {
+        bool(boolLambda, null);
+    }
+
+    public void bool(BoolCall<DataConfigCF> boolLambda, ConditionOptionCall<BoolFilterBuilder> opLambda) {
+        DataConfigCF mustFilter = new DataConfigCF();
+        DataConfigCF shouldFilter = new DataConfigCF();
+        DataConfigCF mustNotFilter = new DataConfigCF();
+        boolLambda.callback(mustFilter, shouldFilter, mustNotFilter);
+        if (mustFilter.hasFilters() || shouldFilter.hasFilters() || mustNotFilter.hasFilters()) {
+            BoolFilterBuilder builder =
+                    regBoolF(mustFilter.filterBuilderList, shouldFilter.filterBuilderList, mustNotFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void and(OperatorCall<DataConfigCF> andLambda) {
+        and(andLambda, null);
+    }
+
+    public void and(OperatorCall<DataConfigCF> andLambda, ConditionOptionCall<AndFilterBuilder> opLambda) {
+        DataConfigCF andFilter = new DataConfigCF();
+        andLambda.callback(andFilter);
+        if (andFilter.hasFilters()) {
+            AndFilterBuilder builder = regAndF(andFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void or(OperatorCall<DataConfigCF> orLambda) {
+        or(orLambda, null);
+    }
+
+    public void or(OperatorCall<DataConfigCF> orLambda, ConditionOptionCall<OrFilterBuilder> opLambda) {
+        DataConfigCF orFilter = new DataConfigCF();
+        orLambda.callback(orFilter);
+        if (orFilter.hasFilters()) {
+            OrFilterBuilder builder = regOrF(orFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void not(OperatorCall<DataConfigCF> notLambda) {
+        not(notLambda, null);
+    }
+
+    public void not(OperatorCall<DataConfigCF> notLambda, ConditionOptionCall<NotFilterBuilder> opLambda) {
+        DataConfigCF notFilter = new DataConfigCF();
+        notLambda.callback(notFilter);
+        if (notFilter.hasFilters()) {
+            if (notFilter.filterBuilderList.size() > 1) {
+                final String msg = "not filter must be one filter.";
+                throw new IllegalConditionBeanOperationException(msg);
+            }
+            NotFilterBuilder builder = regNotF(notFilter.filterBuilderList.get(0));
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall<DataConfigCQ> queryLambda) {
+        query(queryLambda, null);
+    }
+
+    public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall<DataConfigCQ> queryLambda,
+            ConditionOptionCall<QueryFilterBuilder> opLambda) {
+        DataConfigCQ query = new DataConfigCQ();
+        queryLambda.callback(query);
+        if (query.hasQueries()) {
+            QueryFilterBuilder builder = regQueryF(query.getQuery());
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void setAvailable_Term(Boolean available) {
+        setAvailable_Term(available, null);
+    }
+
+    public void setAvailable_Term(Boolean available, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("available", available);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setAvailable_Terms(Collection<Boolean> availableList) {
+        setAvailable_Terms(availableList, null);
+    }
+
+    public void setAvailable_Terms(Collection<Boolean> availableList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("available", availableList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setAvailable_InScope(Collection<Boolean> availableList) {
+        setAvailable_Terms(availableList, null);
+    }
+
+    public void setAvailable_InScope(Collection<Boolean> availableList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setAvailable_Terms(availableList, opLambda);
+    }
+
+    public void setAvailable_Exists() {
+        setAvailable_Exists(null);
+    }
+
+    public void setAvailable_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("available");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setAvailable_Missing() {
+        setAvailable_Missing(null);
+    }
+
+    public void setAvailable_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("available");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setAvailable_GreaterThan(Boolean available) {
+        setAvailable_GreaterThan(available, null);
+    }
+
+    public void setAvailable_GreaterThan(Boolean available, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("available", ConditionKey.CK_GREATER_THAN, available);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setAvailable_LessThan(Boolean available) {
+        setAvailable_LessThan(available, null);
+    }
+
+    public void setAvailable_LessThan(Boolean available, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("available", ConditionKey.CK_LESS_THAN, available);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setAvailable_GreaterEqual(Boolean available) {
+        setAvailable_GreaterEqual(available, null);
+    }
+
+    public void setAvailable_GreaterEqual(Boolean available, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("available", ConditionKey.CK_GREATER_EQUAL, available);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setAvailable_LessEqual(Boolean available) {
+        setAvailable_LessEqual(available, null);
+    }
+
+    public void setAvailable_LessEqual(Boolean available, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("available", ConditionKey.CK_LESS_EQUAL, available);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setBoost_Term(Float boost) {
+        setBoost_Term(boost, null);
+    }
+
+    public void setBoost_Term(Float boost, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("boost", boost);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setBoost_Terms(Collection<Float> boostList) {
+        setBoost_Terms(boostList, null);
+    }
+
+    public void setBoost_Terms(Collection<Float> boostList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("boost", boostList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setBoost_InScope(Collection<Float> boostList) {
+        setBoost_Terms(boostList, null);
+    }
+
+    public void setBoost_InScope(Collection<Float> boostList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setBoost_Terms(boostList, opLambda);
+    }
+
+    public void setBoost_Exists() {
+        setBoost_Exists(null);
+    }
+
+    public void setBoost_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("boost");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setBoost_Missing() {
+        setBoost_Missing(null);
+    }
+
+    public void setBoost_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("boost");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setBoost_GreaterThan(Float boost) {
+        setBoost_GreaterThan(boost, null);
+    }
+
+    public void setBoost_GreaterThan(Float boost, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("boost", ConditionKey.CK_GREATER_THAN, boost);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setBoost_LessThan(Float boost) {
+        setBoost_LessThan(boost, null);
+    }
+
+    public void setBoost_LessThan(Float boost, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("boost", ConditionKey.CK_LESS_THAN, boost);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setBoost_GreaterEqual(Float boost) {
+        setBoost_GreaterEqual(boost, null);
+    }
+
+    public void setBoost_GreaterEqual(Float boost, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("boost", ConditionKey.CK_GREATER_EQUAL, boost);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setBoost_LessEqual(Float boost) {
+        setBoost_LessEqual(boost, null);
+    }
+
+    public void setBoost_LessEqual(Float boost, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("boost", ConditionKey.CK_LESS_EQUAL, boost);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_Term(String createdBy) {
+        setCreatedBy_Term(createdBy, null);
+    }
+
+    public void setCreatedBy_Term(String createdBy, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_Terms(Collection<String> createdByList) {
+        setCreatedBy_Terms(createdByList, null);
+    }
+
+    public void setCreatedBy_Terms(Collection<String> createdByList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("createdBy", createdByList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_InScope(Collection<String> createdByList) {
+        setCreatedBy_Terms(createdByList, null);
+    }
+
+    public void setCreatedBy_InScope(Collection<String> createdByList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setCreatedBy_Terms(createdByList, opLambda);
+    }
+
+    public void setCreatedBy_Prefix(String createdBy) {
+        setCreatedBy_Prefix(createdBy, null);
+    }
+
+    public void setCreatedBy_Prefix(String createdBy, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_Exists() {
+        setCreatedBy_Exists(null);
+    }
+
+    public void setCreatedBy_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("createdBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_Missing() {
+        setCreatedBy_Missing(null);
+    }
+
+    public void setCreatedBy_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("createdBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_GreaterThan(String createdBy) {
+        setCreatedBy_GreaterThan(createdBy, null);
+    }
+
+    public void setCreatedBy_GreaterThan(String createdBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_GREATER_THAN, createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_LessThan(String createdBy) {
+        setCreatedBy_LessThan(createdBy, null);
+    }
+
+    public void setCreatedBy_LessThan(String createdBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_LESS_THAN, createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_GreaterEqual(String createdBy) {
+        setCreatedBy_GreaterEqual(createdBy, null);
+    }
+
+    public void setCreatedBy_GreaterEqual(String createdBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_LessEqual(String createdBy) {
+        setCreatedBy_LessEqual(createdBy, null);
+    }
+
+    public void setCreatedBy_LessEqual(String createdBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_Term(Long createdTime) {
+        setCreatedTime_Term(createdTime, null);
+    }
+
+    public void setCreatedTime_Term(Long createdTime, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("createdTime", createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_Terms(Collection<Long> createdTimeList) {
+        setCreatedTime_Terms(createdTimeList, null);
+    }
+
+    public void setCreatedTime_Terms(Collection<Long> createdTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("createdTime", createdTimeList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_InScope(Collection<Long> createdTimeList) {
+        setCreatedTime_Terms(createdTimeList, null);
+    }
+
+    public void setCreatedTime_InScope(Collection<Long> createdTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setCreatedTime_Terms(createdTimeList, opLambda);
+    }
+
+    public void setCreatedTime_Exists() {
+        setCreatedTime_Exists(null);
+    }
+
+    public void setCreatedTime_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("createdTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_Missing() {
+        setCreatedTime_Missing(null);
+    }
+
+    public void setCreatedTime_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("createdTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_GreaterThan(Long createdTime) {
+        setCreatedTime_GreaterThan(createdTime, null);
+    }
+
+    public void setCreatedTime_GreaterThan(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_THAN, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_LessThan(Long createdTime) {
+        setCreatedTime_LessThan(createdTime, null);
+    }
+
+    public void setCreatedTime_LessThan(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_THAN, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_GreaterEqual(Long createdTime) {
+        setCreatedTime_GreaterEqual(createdTime, null);
+    }
+
+    public void setCreatedTime_GreaterEqual(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_LessEqual(Long createdTime) {
+        setCreatedTime_LessEqual(createdTime, null);
+    }
+
+    public void setCreatedTime_LessEqual(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setHandlerName_Term(String handlerName) {
+        setHandlerName_Term(handlerName, null);
+    }
+
+    public void setHandlerName_Term(String handlerName, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("handlerName", handlerName);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setHandlerName_Terms(Collection<String> handlerNameList) {
+        setHandlerName_Terms(handlerNameList, null);
+    }
+
+    public void setHandlerName_Terms(Collection<String> handlerNameList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("handlerName", handlerNameList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setHandlerName_InScope(Collection<String> handlerNameList) {
+        setHandlerName_Terms(handlerNameList, null);
+    }
+
+    public void setHandlerName_InScope(Collection<String> handlerNameList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setHandlerName_Terms(handlerNameList, opLambda);
+    }
+
+    public void setHandlerName_Prefix(String handlerName) {
+        setHandlerName_Prefix(handlerName, null);
+    }
+
+    public void setHandlerName_Prefix(String handlerName, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("handlerName", handlerName);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setHandlerName_Exists() {
+        setHandlerName_Exists(null);
+    }
+
+    public void setHandlerName_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("handlerName");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setHandlerName_Missing() {
+        setHandlerName_Missing(null);
+    }
+
+    public void setHandlerName_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("handlerName");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setHandlerName_GreaterThan(String handlerName) {
+        setHandlerName_GreaterThan(handlerName, null);
+    }
+
+    public void setHandlerName_GreaterThan(String handlerName, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("handlerName", ConditionKey.CK_GREATER_THAN, handlerName);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setHandlerName_LessThan(String handlerName) {
+        setHandlerName_LessThan(handlerName, null);
+    }
+
+    public void setHandlerName_LessThan(String handlerName, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("handlerName", ConditionKey.CK_LESS_THAN, handlerName);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setHandlerName_GreaterEqual(String handlerName) {
+        setHandlerName_GreaterEqual(handlerName, null);
+    }
+
+    public void setHandlerName_GreaterEqual(String handlerName, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("handlerName", ConditionKey.CK_GREATER_EQUAL, handlerName);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setHandlerName_LessEqual(String handlerName) {
+        setHandlerName_LessEqual(handlerName, null);
+    }
+
+    public void setHandlerName_LessEqual(String handlerName, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("handlerName", ConditionKey.CK_LESS_EQUAL, handlerName);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setHandlerParameter_Term(String handlerParameter) {
+        setHandlerParameter_Term(handlerParameter, null);
+    }
+
+    public void setHandlerParameter_Term(String handlerParameter, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("handlerParameter", handlerParameter);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setHandlerParameter_Terms(Collection<String> handlerParameterList) {
+        setHandlerParameter_Terms(handlerParameterList, null);
+    }
+
+    public void setHandlerParameter_Terms(Collection<String> handlerParameterList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("handlerParameter", handlerParameterList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setHandlerParameter_InScope(Collection<String> handlerParameterList) {
+        setHandlerParameter_Terms(handlerParameterList, null);
+    }
+
+    public void setHandlerParameter_InScope(Collection<String> handlerParameterList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setHandlerParameter_Terms(handlerParameterList, opLambda);
+    }
+
+    public void setHandlerParameter_Prefix(String handlerParameter) {
+        setHandlerParameter_Prefix(handlerParameter, null);
+    }
+
+    public void setHandlerParameter_Prefix(String handlerParameter, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("handlerParameter", handlerParameter);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setHandlerParameter_Exists() {
+        setHandlerParameter_Exists(null);
+    }
+
+    public void setHandlerParameter_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("handlerParameter");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setHandlerParameter_Missing() {
+        setHandlerParameter_Missing(null);
+    }
+
+    public void setHandlerParameter_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("handlerParameter");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setHandlerParameter_GreaterThan(String handlerParameter) {
+        setHandlerParameter_GreaterThan(handlerParameter, null);
+    }
+
+    public void setHandlerParameter_GreaterThan(String handlerParameter, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("handlerParameter", ConditionKey.CK_GREATER_THAN, handlerParameter);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setHandlerParameter_LessThan(String handlerParameter) {
+        setHandlerParameter_LessThan(handlerParameter, null);
+    }
+
+    public void setHandlerParameter_LessThan(String handlerParameter, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("handlerParameter", ConditionKey.CK_LESS_THAN, handlerParameter);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setHandlerParameter_GreaterEqual(String handlerParameter) {
+        setHandlerParameter_GreaterEqual(handlerParameter, null);
+    }
+
+    public void setHandlerParameter_GreaterEqual(String handlerParameter, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("handlerParameter", ConditionKey.CK_GREATER_EQUAL, handlerParameter);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setHandlerParameter_LessEqual(String handlerParameter) {
+        setHandlerParameter_LessEqual(handlerParameter, null);
+    }
+
+    public void setHandlerParameter_LessEqual(String handlerParameter, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("handlerParameter", ConditionKey.CK_LESS_EQUAL, handlerParameter);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setHandlerScript_Term(String handlerScript) {
+        setHandlerScript_Term(handlerScript, null);
+    }
+
+    public void setHandlerScript_Term(String handlerScript, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("handlerScript", handlerScript);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setHandlerScript_Terms(Collection<String> handlerScriptList) {
+        setHandlerScript_Terms(handlerScriptList, null);
+    }
+
+    public void setHandlerScript_Terms(Collection<String> handlerScriptList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("handlerScript", handlerScriptList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setHandlerScript_InScope(Collection<String> handlerScriptList) {
+        setHandlerScript_Terms(handlerScriptList, null);
+    }
+
+    public void setHandlerScript_InScope(Collection<String> handlerScriptList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setHandlerScript_Terms(handlerScriptList, opLambda);
+    }
+
+    public void setHandlerScript_Prefix(String handlerScript) {
+        setHandlerScript_Prefix(handlerScript, null);
+    }
+
+    public void setHandlerScript_Prefix(String handlerScript, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("handlerScript", handlerScript);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setHandlerScript_Exists() {
+        setHandlerScript_Exists(null);
+    }
+
+    public void setHandlerScript_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("handlerScript");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setHandlerScript_Missing() {
+        setHandlerScript_Missing(null);
+    }
+
+    public void setHandlerScript_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("handlerScript");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setHandlerScript_GreaterThan(String handlerScript) {
+        setHandlerScript_GreaterThan(handlerScript, null);
+    }
+
+    public void setHandlerScript_GreaterThan(String handlerScript, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("handlerScript", ConditionKey.CK_GREATER_THAN, handlerScript);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setHandlerScript_LessThan(String handlerScript) {
+        setHandlerScript_LessThan(handlerScript, null);
+    }
+
+    public void setHandlerScript_LessThan(String handlerScript, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("handlerScript", ConditionKey.CK_LESS_THAN, handlerScript);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setHandlerScript_GreaterEqual(String handlerScript) {
+        setHandlerScript_GreaterEqual(handlerScript, null);
+    }
+
+    public void setHandlerScript_GreaterEqual(String handlerScript, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("handlerScript", ConditionKey.CK_GREATER_EQUAL, handlerScript);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setHandlerScript_LessEqual(String handlerScript) {
+        setHandlerScript_LessEqual(handlerScript, null);
+    }
+
+    public void setHandlerScript_LessEqual(String handlerScript, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("handlerScript", ConditionKey.CK_LESS_EQUAL, handlerScript);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Term(String id) {
+        setId_Term(id, null);
+    }
+
+    public void setId_Term(String id, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("id", id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Terms(Collection<String> idList) {
+        setId_Terms(idList, null);
+    }
+
+    public void setId_Terms(Collection<String> idList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("id", idList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_InScope(Collection<String> idList) {
+        setId_Terms(idList, null);
+    }
+
+    public void setId_InScope(Collection<String> idList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setId_Terms(idList, opLambda);
+    }
+
+    public void setId_Prefix(String id) {
+        setId_Prefix(id, null);
+    }
+
+    public void setId_Prefix(String id, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("id", id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Exists() {
+        setId_Exists(null);
+    }
+
+    public void setId_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("id");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Missing() {
+        setId_Missing(null);
+    }
+
+    public void setId_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("id");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_GreaterThan(String id) {
+        setId_GreaterThan(id, null);
+    }
+
+    public void setId_GreaterThan(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_THAN, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_LessThan(String id) {
+        setId_LessThan(id, null);
+    }
+
+    public void setId_LessThan(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_THAN, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_GreaterEqual(String id) {
+        setId_GreaterEqual(id, null);
+    }
+
+    public void setId_GreaterEqual(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_EQUAL, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_LessEqual(String id) {
+        setId_LessEqual(id, null);
+    }
+
+    public void setId_LessEqual(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_EQUAL, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_Term(String name) {
+        setName_Term(name, null);
+    }
+
+    public void setName_Term(String name, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("name", name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_Terms(Collection<String> nameList) {
+        setName_Terms(nameList, null);
+    }
+
+    public void setName_Terms(Collection<String> nameList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("name", nameList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_InScope(Collection<String> nameList) {
+        setName_Terms(nameList, null);
+    }
+
+    public void setName_InScope(Collection<String> nameList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setName_Terms(nameList, opLambda);
+    }
+
+    public void setName_Prefix(String name) {
+        setName_Prefix(name, null);
+    }
+
+    public void setName_Prefix(String name, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("name", name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_Exists() {
+        setName_Exists(null);
+    }
+
+    public void setName_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("name");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_Missing() {
+        setName_Missing(null);
+    }
+
+    public void setName_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("name");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_GreaterThan(String name) {
+        setName_GreaterThan(name, null);
+    }
+
+    public void setName_GreaterThan(String name, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_GREATER_THAN, name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_LessThan(String name) {
+        setName_LessThan(name, null);
+    }
+
+    public void setName_LessThan(String name, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_LESS_THAN, name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_GreaterEqual(String name) {
+        setName_GreaterEqual(name, null);
+    }
+
+    public void setName_GreaterEqual(String name, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_GREATER_EQUAL, name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_LessEqual(String name) {
+        setName_LessEqual(name, null);
+    }
+
+    public void setName_LessEqual(String name, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_LESS_EQUAL, name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_Term(Integer sortOrder) {
+        setSortOrder_Term(sortOrder, null);
+    }
+
+    public void setSortOrder_Term(Integer sortOrder, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("sortOrder", sortOrder);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_Terms(Collection<Integer> sortOrderList) {
+        setSortOrder_Terms(sortOrderList, null);
+    }
+
+    public void setSortOrder_Terms(Collection<Integer> sortOrderList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("sortOrder", sortOrderList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_InScope(Collection<Integer> sortOrderList) {
+        setSortOrder_Terms(sortOrderList, null);
+    }
+
+    public void setSortOrder_InScope(Collection<Integer> sortOrderList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setSortOrder_Terms(sortOrderList, opLambda);
+    }
+
+    public void setSortOrder_Exists() {
+        setSortOrder_Exists(null);
+    }
+
+    public void setSortOrder_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("sortOrder");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_Missing() {
+        setSortOrder_Missing(null);
+    }
+
+    public void setSortOrder_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("sortOrder");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_GreaterThan(Integer sortOrder) {
+        setSortOrder_GreaterThan(sortOrder, null);
+    }
+
+    public void setSortOrder_GreaterThan(Integer sortOrder, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_GREATER_THAN, sortOrder);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_LessThan(Integer sortOrder) {
+        setSortOrder_LessThan(sortOrder, null);
+    }
+
+    public void setSortOrder_LessThan(Integer sortOrder, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_LESS_THAN, sortOrder);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_GreaterEqual(Integer sortOrder) {
+        setSortOrder_GreaterEqual(sortOrder, null);
+    }
+
+    public void setSortOrder_GreaterEqual(Integer sortOrder, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_GREATER_EQUAL, sortOrder);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_LessEqual(Integer sortOrder) {
+        setSortOrder_LessEqual(sortOrder, null);
+    }
+
+    public void setSortOrder_LessEqual(Integer sortOrder, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_LESS_EQUAL, sortOrder);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Term(String updatedBy) {
+        setUpdatedBy_Term(updatedBy, null);
+    }
+
+    public void setUpdatedBy_Term(String updatedBy, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Terms(Collection<String> updatedByList) {
+        setUpdatedBy_Terms(updatedByList, null);
+    }
+
+    public void setUpdatedBy_Terms(Collection<String> updatedByList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("updatedBy", updatedByList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_InScope(Collection<String> updatedByList) {
+        setUpdatedBy_Terms(updatedByList, null);
+    }
+
+    public void setUpdatedBy_InScope(Collection<String> updatedByList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setUpdatedBy_Terms(updatedByList, opLambda);
+    }
+
+    public void setUpdatedBy_Prefix(String updatedBy) {
+        setUpdatedBy_Prefix(updatedBy, null);
+    }
+
+    public void setUpdatedBy_Prefix(String updatedBy, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Exists() {
+        setUpdatedBy_Exists(null);
+    }
+
+    public void setUpdatedBy_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("updatedBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Missing() {
+        setUpdatedBy_Missing(null);
+    }
+
+    public void setUpdatedBy_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("updatedBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_GreaterThan(String updatedBy) {
+        setUpdatedBy_GreaterThan(updatedBy, null);
+    }
+
+    public void setUpdatedBy_GreaterThan(String updatedBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_LessThan(String updatedBy) {
+        setUpdatedBy_LessThan(updatedBy, null);
+    }
+
+    public void setUpdatedBy_LessThan(String updatedBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_GreaterEqual(String updatedBy) {
+        setUpdatedBy_GreaterEqual(updatedBy, null);
+    }
+
+    public void setUpdatedBy_GreaterEqual(String updatedBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_LessEqual(String updatedBy) {
+        setUpdatedBy_LessEqual(updatedBy, null);
+    }
+
+    public void setUpdatedBy_LessEqual(String updatedBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_Term(Long updatedTime) {
+        setUpdatedTime_Term(updatedTime, null);
+    }
+
+    public void setUpdatedTime_Term(Long updatedTime, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("updatedTime", updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_Terms(Collection<Long> updatedTimeList) {
+        setUpdatedTime_Terms(updatedTimeList, null);
+    }
+
+    public void setUpdatedTime_Terms(Collection<Long> updatedTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("updatedTime", updatedTimeList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_InScope(Collection<Long> updatedTimeList) {
+        setUpdatedTime_Terms(updatedTimeList, null);
+    }
+
+    public void setUpdatedTime_InScope(Collection<Long> updatedTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setUpdatedTime_Terms(updatedTimeList, opLambda);
+    }
+
+    public void setUpdatedTime_Exists() {
+        setUpdatedTime_Exists(null);
+    }
+
+    public void setUpdatedTime_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("updatedTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_Missing() {
+        setUpdatedTime_Missing(null);
+    }
+
+    public void setUpdatedTime_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("updatedTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_GreaterThan(Long updatedTime) {
+        setUpdatedTime_GreaterThan(updatedTime, null);
+    }
+
+    public void setUpdatedTime_GreaterThan(Long updatedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_LessThan(Long updatedTime) {
+        setUpdatedTime_LessThan(updatedTime, null);
+    }
+
+    public void setUpdatedTime_LessThan(Long updatedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_GreaterEqual(Long updatedTime) {
+        setUpdatedTime_GreaterEqual(updatedTime, null);
+    }
+
+    public void setUpdatedTime_GreaterEqual(Long updatedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_LessEqual(Long updatedTime) {
+        setUpdatedTime_LessEqual(updatedTime, null);
+    }
+
+    public void setUpdatedTime_LessEqual(Long updatedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+}

src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsDataConfigToLabelCF.java

@@ -0,0 +1,430 @@
+package org.codelibs.fess.es.cbean.cf.bs;
+
+import java.util.Collection;
+
+import org.codelibs.fess.es.cbean.cf.DataConfigToLabelCF;
+import org.codelibs.fess.es.cbean.cq.DataConfigToLabelCQ;
+import org.dbflute.exception.IllegalConditionBeanOperationException;
+import org.dbflute.cbean.ckey.ConditionKey;
+import org.elasticsearch.index.query.AndFilterBuilder;
+import org.elasticsearch.index.query.BoolFilterBuilder;
+import org.elasticsearch.index.query.ExistsFilterBuilder;
+import org.elasticsearch.index.query.MissingFilterBuilder;
+import org.elasticsearch.index.query.NotFilterBuilder;
+import org.elasticsearch.index.query.OrFilterBuilder;
+import org.elasticsearch.index.query.PrefixFilterBuilder;
+import org.elasticsearch.index.query.QueryFilterBuilder;
+import org.elasticsearch.index.query.RangeFilterBuilder;
+import org.elasticsearch.index.query.TermFilterBuilder;
+import org.elasticsearch.index.query.TermsFilterBuilder;
+
+/**
+ * @author FreeGen
+ */
+public abstract class BsDataConfigToLabelCF extends AbstractConditionFilter {
+
+    public void bool(BoolCall<DataConfigToLabelCF> boolLambda) {
+        bool(boolLambda, null);
+    }
+
+    public void bool(BoolCall<DataConfigToLabelCF> boolLambda, ConditionOptionCall<BoolFilterBuilder> opLambda) {
+        DataConfigToLabelCF mustFilter = new DataConfigToLabelCF();
+        DataConfigToLabelCF shouldFilter = new DataConfigToLabelCF();
+        DataConfigToLabelCF mustNotFilter = new DataConfigToLabelCF();
+        boolLambda.callback(mustFilter, shouldFilter, mustNotFilter);
+        if (mustFilter.hasFilters() || shouldFilter.hasFilters() || mustNotFilter.hasFilters()) {
+            BoolFilterBuilder builder =
+                    regBoolF(mustFilter.filterBuilderList, shouldFilter.filterBuilderList, mustNotFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void and(OperatorCall<DataConfigToLabelCF> andLambda) {
+        and(andLambda, null);
+    }
+
+    public void and(OperatorCall<DataConfigToLabelCF> andLambda, ConditionOptionCall<AndFilterBuilder> opLambda) {
+        DataConfigToLabelCF andFilter = new DataConfigToLabelCF();
+        andLambda.callback(andFilter);
+        if (andFilter.hasFilters()) {
+            AndFilterBuilder builder = regAndF(andFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void or(OperatorCall<DataConfigToLabelCF> orLambda) {
+        or(orLambda, null);
+    }
+
+    public void or(OperatorCall<DataConfigToLabelCF> orLambda, ConditionOptionCall<OrFilterBuilder> opLambda) {
+        DataConfigToLabelCF orFilter = new DataConfigToLabelCF();
+        orLambda.callback(orFilter);
+        if (orFilter.hasFilters()) {
+            OrFilterBuilder builder = regOrF(orFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void not(OperatorCall<DataConfigToLabelCF> notLambda) {
+        not(notLambda, null);
+    }
+
+    public void not(OperatorCall<DataConfigToLabelCF> notLambda, ConditionOptionCall<NotFilterBuilder> opLambda) {
+        DataConfigToLabelCF notFilter = new DataConfigToLabelCF();
+        notLambda.callback(notFilter);
+        if (notFilter.hasFilters()) {
+            if (notFilter.filterBuilderList.size() > 1) {
+                final String msg = "not filter must be one filter.";
+                throw new IllegalConditionBeanOperationException(msg);
+            }
+            NotFilterBuilder builder = regNotF(notFilter.filterBuilderList.get(0));
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall<DataConfigToLabelCQ> queryLambda) {
+        query(queryLambda, null);
+    }
+
+    public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall<DataConfigToLabelCQ> queryLambda,
+            ConditionOptionCall<QueryFilterBuilder> opLambda) {
+        DataConfigToLabelCQ query = new DataConfigToLabelCQ();
+        queryLambda.callback(query);
+        if (query.hasQueries()) {
+            QueryFilterBuilder builder = regQueryF(query.getQuery());
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void setDataConfigId_Term(String dataConfigId) {
+        setDataConfigId_Term(dataConfigId, null);
+    }
+
+    public void setDataConfigId_Term(String dataConfigId, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("dataConfigId", dataConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setDataConfigId_Terms(Collection<String> dataConfigIdList) {
+        setDataConfigId_Terms(dataConfigIdList, null);
+    }
+
+    public void setDataConfigId_Terms(Collection<String> dataConfigIdList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("dataConfigId", dataConfigIdList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setDataConfigId_InScope(Collection<String> dataConfigIdList) {
+        setDataConfigId_Terms(dataConfigIdList, null);
+    }
+
+    public void setDataConfigId_InScope(Collection<String> dataConfigIdList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setDataConfigId_Terms(dataConfigIdList, opLambda);
+    }
+
+    public void setDataConfigId_Prefix(String dataConfigId) {
+        setDataConfigId_Prefix(dataConfigId, null);
+    }
+
+    public void setDataConfigId_Prefix(String dataConfigId, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("dataConfigId", dataConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setDataConfigId_Exists() {
+        setDataConfigId_Exists(null);
+    }
+
+    public void setDataConfigId_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("dataConfigId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setDataConfigId_Missing() {
+        setDataConfigId_Missing(null);
+    }
+
+    public void setDataConfigId_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("dataConfigId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setDataConfigId_GreaterThan(String dataConfigId) {
+        setDataConfigId_GreaterThan(dataConfigId, null);
+    }
+
+    public void setDataConfigId_GreaterThan(String dataConfigId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("dataConfigId", ConditionKey.CK_GREATER_THAN, dataConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setDataConfigId_LessThan(String dataConfigId) {
+        setDataConfigId_LessThan(dataConfigId, null);
+    }
+
+    public void setDataConfigId_LessThan(String dataConfigId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("dataConfigId", ConditionKey.CK_LESS_THAN, dataConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setDataConfigId_GreaterEqual(String dataConfigId) {
+        setDataConfigId_GreaterEqual(dataConfigId, null);
+    }
+
+    public void setDataConfigId_GreaterEqual(String dataConfigId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("dataConfigId", ConditionKey.CK_GREATER_EQUAL, dataConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setDataConfigId_LessEqual(String dataConfigId) {
+        setDataConfigId_LessEqual(dataConfigId, null);
+    }
+
+    public void setDataConfigId_LessEqual(String dataConfigId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("dataConfigId", ConditionKey.CK_LESS_EQUAL, dataConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Term(String id) {
+        setId_Term(id, null);
+    }
+
+    public void setId_Term(String id, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("id", id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Terms(Collection<String> idList) {
+        setId_Terms(idList, null);
+    }
+
+    public void setId_Terms(Collection<String> idList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("id", idList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_InScope(Collection<String> idList) {
+        setId_Terms(idList, null);
+    }
+
+    public void setId_InScope(Collection<String> idList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setId_Terms(idList, opLambda);
+    }
+
+    public void setId_Prefix(String id) {
+        setId_Prefix(id, null);
+    }
+
+    public void setId_Prefix(String id, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("id", id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Exists() {
+        setId_Exists(null);
+    }
+
+    public void setId_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("id");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Missing() {
+        setId_Missing(null);
+    }
+
+    public void setId_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("id");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_GreaterThan(String id) {
+        setId_GreaterThan(id, null);
+    }
+
+    public void setId_GreaterThan(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_THAN, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_LessThan(String id) {
+        setId_LessThan(id, null);
+    }
+
+    public void setId_LessThan(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_THAN, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_GreaterEqual(String id) {
+        setId_GreaterEqual(id, null);
+    }
+
+    public void setId_GreaterEqual(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_EQUAL, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_LessEqual(String id) {
+        setId_LessEqual(id, null);
+    }
+
+    public void setId_LessEqual(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_EQUAL, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setLabelTypeId_Term(String labelTypeId) {
+        setLabelTypeId_Term(labelTypeId, null);
+    }
+
+    public void setLabelTypeId_Term(String labelTypeId, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("labelTypeId", labelTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setLabelTypeId_Terms(Collection<String> labelTypeIdList) {
+        setLabelTypeId_Terms(labelTypeIdList, null);
+    }
+
+    public void setLabelTypeId_Terms(Collection<String> labelTypeIdList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("labelTypeId", labelTypeIdList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setLabelTypeId_InScope(Collection<String> labelTypeIdList) {
+        setLabelTypeId_Terms(labelTypeIdList, null);
+    }
+
+    public void setLabelTypeId_InScope(Collection<String> labelTypeIdList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setLabelTypeId_Terms(labelTypeIdList, opLambda);
+    }
+
+    public void setLabelTypeId_Prefix(String labelTypeId) {
+        setLabelTypeId_Prefix(labelTypeId, null);
+    }
+
+    public void setLabelTypeId_Prefix(String labelTypeId, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("labelTypeId", labelTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setLabelTypeId_Exists() {
+        setLabelTypeId_Exists(null);
+    }
+
+    public void setLabelTypeId_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("labelTypeId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setLabelTypeId_Missing() {
+        setLabelTypeId_Missing(null);
+    }
+
+    public void setLabelTypeId_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("labelTypeId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setLabelTypeId_GreaterThan(String labelTypeId) {
+        setLabelTypeId_GreaterThan(labelTypeId, null);
+    }
+
+    public void setLabelTypeId_GreaterThan(String labelTypeId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("labelTypeId", ConditionKey.CK_GREATER_THAN, labelTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setLabelTypeId_LessThan(String labelTypeId) {
+        setLabelTypeId_LessThan(labelTypeId, null);
+    }
+
+    public void setLabelTypeId_LessThan(String labelTypeId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("labelTypeId", ConditionKey.CK_LESS_THAN, labelTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setLabelTypeId_GreaterEqual(String labelTypeId) {
+        setLabelTypeId_GreaterEqual(labelTypeId, null);
+    }
+
+    public void setLabelTypeId_GreaterEqual(String labelTypeId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("labelTypeId", ConditionKey.CK_GREATER_EQUAL, labelTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setLabelTypeId_LessEqual(String labelTypeId) {
+        setLabelTypeId_LessEqual(labelTypeId, null);
+    }
+
+    public void setLabelTypeId_LessEqual(String labelTypeId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("labelTypeId", ConditionKey.CK_LESS_EQUAL, labelTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+}

src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsDataConfigToRoleCF.java

@@ -0,0 +1,430 @@
+package org.codelibs.fess.es.cbean.cf.bs;
+
+import java.util.Collection;
+
+import org.codelibs.fess.es.cbean.cf.DataConfigToRoleCF;
+import org.codelibs.fess.es.cbean.cq.DataConfigToRoleCQ;
+import org.dbflute.exception.IllegalConditionBeanOperationException;
+import org.dbflute.cbean.ckey.ConditionKey;
+import org.elasticsearch.index.query.AndFilterBuilder;
+import org.elasticsearch.index.query.BoolFilterBuilder;
+import org.elasticsearch.index.query.ExistsFilterBuilder;
+import org.elasticsearch.index.query.MissingFilterBuilder;
+import org.elasticsearch.index.query.NotFilterBuilder;
+import org.elasticsearch.index.query.OrFilterBuilder;
+import org.elasticsearch.index.query.PrefixFilterBuilder;
+import org.elasticsearch.index.query.QueryFilterBuilder;
+import org.elasticsearch.index.query.RangeFilterBuilder;
+import org.elasticsearch.index.query.TermFilterBuilder;
+import org.elasticsearch.index.query.TermsFilterBuilder;
+
+/**
+ * @author FreeGen
+ */
+public abstract class BsDataConfigToRoleCF extends AbstractConditionFilter {
+
+    public void bool(BoolCall<DataConfigToRoleCF> boolLambda) {
+        bool(boolLambda, null);
+    }
+
+    public void bool(BoolCall<DataConfigToRoleCF> boolLambda, ConditionOptionCall<BoolFilterBuilder> opLambda) {
+        DataConfigToRoleCF mustFilter = new DataConfigToRoleCF();
+        DataConfigToRoleCF shouldFilter = new DataConfigToRoleCF();
+        DataConfigToRoleCF mustNotFilter = new DataConfigToRoleCF();
+        boolLambda.callback(mustFilter, shouldFilter, mustNotFilter);
+        if (mustFilter.hasFilters() || shouldFilter.hasFilters() || mustNotFilter.hasFilters()) {
+            BoolFilterBuilder builder =
+                    regBoolF(mustFilter.filterBuilderList, shouldFilter.filterBuilderList, mustNotFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void and(OperatorCall<DataConfigToRoleCF> andLambda) {
+        and(andLambda, null);
+    }
+
+    public void and(OperatorCall<DataConfigToRoleCF> andLambda, ConditionOptionCall<AndFilterBuilder> opLambda) {
+        DataConfigToRoleCF andFilter = new DataConfigToRoleCF();
+        andLambda.callback(andFilter);
+        if (andFilter.hasFilters()) {
+            AndFilterBuilder builder = regAndF(andFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void or(OperatorCall<DataConfigToRoleCF> orLambda) {
+        or(orLambda, null);
+    }
+
+    public void or(OperatorCall<DataConfigToRoleCF> orLambda, ConditionOptionCall<OrFilterBuilder> opLambda) {
+        DataConfigToRoleCF orFilter = new DataConfigToRoleCF();
+        orLambda.callback(orFilter);
+        if (orFilter.hasFilters()) {
+            OrFilterBuilder builder = regOrF(orFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void not(OperatorCall<DataConfigToRoleCF> notLambda) {
+        not(notLambda, null);
+    }
+
+    public void not(OperatorCall<DataConfigToRoleCF> notLambda, ConditionOptionCall<NotFilterBuilder> opLambda) {
+        DataConfigToRoleCF notFilter = new DataConfigToRoleCF();
+        notLambda.callback(notFilter);
+        if (notFilter.hasFilters()) {
+            if (notFilter.filterBuilderList.size() > 1) {
+                final String msg = "not filter must be one filter.";
+                throw new IllegalConditionBeanOperationException(msg);
+            }
+            NotFilterBuilder builder = regNotF(notFilter.filterBuilderList.get(0));
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall<DataConfigToRoleCQ> queryLambda) {
+        query(queryLambda, null);
+    }
+
+    public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall<DataConfigToRoleCQ> queryLambda,
+            ConditionOptionCall<QueryFilterBuilder> opLambda) {
+        DataConfigToRoleCQ query = new DataConfigToRoleCQ();
+        queryLambda.callback(query);
+        if (query.hasQueries()) {
+            QueryFilterBuilder builder = regQueryF(query.getQuery());
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void setDataConfigId_Term(String dataConfigId) {
+        setDataConfigId_Term(dataConfigId, null);
+    }
+
+    public void setDataConfigId_Term(String dataConfigId, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("dataConfigId", dataConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setDataConfigId_Terms(Collection<String> dataConfigIdList) {
+        setDataConfigId_Terms(dataConfigIdList, null);
+    }
+
+    public void setDataConfigId_Terms(Collection<String> dataConfigIdList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("dataConfigId", dataConfigIdList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setDataConfigId_InScope(Collection<String> dataConfigIdList) {
+        setDataConfigId_Terms(dataConfigIdList, null);
+    }
+
+    public void setDataConfigId_InScope(Collection<String> dataConfigIdList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setDataConfigId_Terms(dataConfigIdList, opLambda);
+    }
+
+    public void setDataConfigId_Prefix(String dataConfigId) {
+        setDataConfigId_Prefix(dataConfigId, null);
+    }
+
+    public void setDataConfigId_Prefix(String dataConfigId, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("dataConfigId", dataConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setDataConfigId_Exists() {
+        setDataConfigId_Exists(null);
+    }
+
+    public void setDataConfigId_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("dataConfigId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setDataConfigId_Missing() {
+        setDataConfigId_Missing(null);
+    }
+
+    public void setDataConfigId_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("dataConfigId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setDataConfigId_GreaterThan(String dataConfigId) {
+        setDataConfigId_GreaterThan(dataConfigId, null);
+    }
+
+    public void setDataConfigId_GreaterThan(String dataConfigId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("dataConfigId", ConditionKey.CK_GREATER_THAN, dataConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setDataConfigId_LessThan(String dataConfigId) {
+        setDataConfigId_LessThan(dataConfigId, null);
+    }
+
+    public void setDataConfigId_LessThan(String dataConfigId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("dataConfigId", ConditionKey.CK_LESS_THAN, dataConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setDataConfigId_GreaterEqual(String dataConfigId) {
+        setDataConfigId_GreaterEqual(dataConfigId, null);
+    }
+
+    public void setDataConfigId_GreaterEqual(String dataConfigId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("dataConfigId", ConditionKey.CK_GREATER_EQUAL, dataConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setDataConfigId_LessEqual(String dataConfigId) {
+        setDataConfigId_LessEqual(dataConfigId, null);
+    }
+
+    public void setDataConfigId_LessEqual(String dataConfigId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("dataConfigId", ConditionKey.CK_LESS_EQUAL, dataConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Term(String id) {
+        setId_Term(id, null);
+    }
+
+    public void setId_Term(String id, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("id", id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Terms(Collection<String> idList) {
+        setId_Terms(idList, null);
+    }
+
+    public void setId_Terms(Collection<String> idList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("id", idList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_InScope(Collection<String> idList) {
+        setId_Terms(idList, null);
+    }
+
+    public void setId_InScope(Collection<String> idList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setId_Terms(idList, opLambda);
+    }
+
+    public void setId_Prefix(String id) {
+        setId_Prefix(id, null);
+    }
+
+    public void setId_Prefix(String id, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("id", id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Exists() {
+        setId_Exists(null);
+    }
+
+    public void setId_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("id");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Missing() {
+        setId_Missing(null);
+    }
+
+    public void setId_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("id");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_GreaterThan(String id) {
+        setId_GreaterThan(id, null);
+    }
+
+    public void setId_GreaterThan(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_THAN, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_LessThan(String id) {
+        setId_LessThan(id, null);
+    }
+
+    public void setId_LessThan(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_THAN, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_GreaterEqual(String id) {
+        setId_GreaterEqual(id, null);
+    }
+
+    public void setId_GreaterEqual(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_EQUAL, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_LessEqual(String id) {
+        setId_LessEqual(id, null);
+    }
+
+    public void setId_LessEqual(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_EQUAL, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRoleTypeId_Term(String roleTypeId) {
+        setRoleTypeId_Term(roleTypeId, null);
+    }
+
+    public void setRoleTypeId_Term(String roleTypeId, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("roleTypeId", roleTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRoleTypeId_Terms(Collection<String> roleTypeIdList) {
+        setRoleTypeId_Terms(roleTypeIdList, null);
+    }
+
+    public void setRoleTypeId_Terms(Collection<String> roleTypeIdList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("roleTypeId", roleTypeIdList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRoleTypeId_InScope(Collection<String> roleTypeIdList) {
+        setRoleTypeId_Terms(roleTypeIdList, null);
+    }
+
+    public void setRoleTypeId_InScope(Collection<String> roleTypeIdList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setRoleTypeId_Terms(roleTypeIdList, opLambda);
+    }
+
+    public void setRoleTypeId_Prefix(String roleTypeId) {
+        setRoleTypeId_Prefix(roleTypeId, null);
+    }
+
+    public void setRoleTypeId_Prefix(String roleTypeId, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("roleTypeId", roleTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRoleTypeId_Exists() {
+        setRoleTypeId_Exists(null);
+    }
+
+    public void setRoleTypeId_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("roleTypeId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRoleTypeId_Missing() {
+        setRoleTypeId_Missing(null);
+    }
+
+    public void setRoleTypeId_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("roleTypeId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRoleTypeId_GreaterThan(String roleTypeId) {
+        setRoleTypeId_GreaterThan(roleTypeId, null);
+    }
+
+    public void setRoleTypeId_GreaterThan(String roleTypeId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("roleTypeId", ConditionKey.CK_GREATER_THAN, roleTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRoleTypeId_LessThan(String roleTypeId) {
+        setRoleTypeId_LessThan(roleTypeId, null);
+    }
+
+    public void setRoleTypeId_LessThan(String roleTypeId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("roleTypeId", ConditionKey.CK_LESS_THAN, roleTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRoleTypeId_GreaterEqual(String roleTypeId) {
+        setRoleTypeId_GreaterEqual(roleTypeId, null);
+    }
+
+    public void setRoleTypeId_GreaterEqual(String roleTypeId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("roleTypeId", ConditionKey.CK_GREATER_EQUAL, roleTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRoleTypeId_LessEqual(String roleTypeId) {
+        setRoleTypeId_LessEqual(roleTypeId, null);
+    }
+
+    public void setRoleTypeId_LessEqual(String roleTypeId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("roleTypeId", ConditionKey.CK_LESS_EQUAL, roleTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+}

src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsFailureUrlCF.java

@@ -0,0 +1,943 @@
+package org.codelibs.fess.es.cbean.cf.bs;
+
+import java.util.Collection;
+
+import org.codelibs.fess.es.cbean.cf.FailureUrlCF;
+import org.codelibs.fess.es.cbean.cq.FailureUrlCQ;
+import org.dbflute.exception.IllegalConditionBeanOperationException;
+import org.dbflute.cbean.ckey.ConditionKey;
+import org.elasticsearch.index.query.AndFilterBuilder;
+import org.elasticsearch.index.query.BoolFilterBuilder;
+import org.elasticsearch.index.query.ExistsFilterBuilder;
+import org.elasticsearch.index.query.MissingFilterBuilder;
+import org.elasticsearch.index.query.NotFilterBuilder;
+import org.elasticsearch.index.query.OrFilterBuilder;
+import org.elasticsearch.index.query.PrefixFilterBuilder;
+import org.elasticsearch.index.query.QueryFilterBuilder;
+import org.elasticsearch.index.query.RangeFilterBuilder;
+import org.elasticsearch.index.query.TermFilterBuilder;
+import org.elasticsearch.index.query.TermsFilterBuilder;
+
+/**
+ * @author FreeGen
+ */
+public abstract class BsFailureUrlCF extends AbstractConditionFilter {
+
+    public void bool(BoolCall<FailureUrlCF> boolLambda) {
+        bool(boolLambda, null);
+    }
+
+    public void bool(BoolCall<FailureUrlCF> boolLambda, ConditionOptionCall<BoolFilterBuilder> opLambda) {
+        FailureUrlCF mustFilter = new FailureUrlCF();
+        FailureUrlCF shouldFilter = new FailureUrlCF();
+        FailureUrlCF mustNotFilter = new FailureUrlCF();
+        boolLambda.callback(mustFilter, shouldFilter, mustNotFilter);
+        if (mustFilter.hasFilters() || shouldFilter.hasFilters() || mustNotFilter.hasFilters()) {
+            BoolFilterBuilder builder =
+                    regBoolF(mustFilter.filterBuilderList, shouldFilter.filterBuilderList, mustNotFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void and(OperatorCall<FailureUrlCF> andLambda) {
+        and(andLambda, null);
+    }
+
+    public void and(OperatorCall<FailureUrlCF> andLambda, ConditionOptionCall<AndFilterBuilder> opLambda) {
+        FailureUrlCF andFilter = new FailureUrlCF();
+        andLambda.callback(andFilter);
+        if (andFilter.hasFilters()) {
+            AndFilterBuilder builder = regAndF(andFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void or(OperatorCall<FailureUrlCF> orLambda) {
+        or(orLambda, null);
+    }
+
+    public void or(OperatorCall<FailureUrlCF> orLambda, ConditionOptionCall<OrFilterBuilder> opLambda) {
+        FailureUrlCF orFilter = new FailureUrlCF();
+        orLambda.callback(orFilter);
+        if (orFilter.hasFilters()) {
+            OrFilterBuilder builder = regOrF(orFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void not(OperatorCall<FailureUrlCF> notLambda) {
+        not(notLambda, null);
+    }
+
+    public void not(OperatorCall<FailureUrlCF> notLambda, ConditionOptionCall<NotFilterBuilder> opLambda) {
+        FailureUrlCF notFilter = new FailureUrlCF();
+        notLambda.callback(notFilter);
+        if (notFilter.hasFilters()) {
+            if (notFilter.filterBuilderList.size() > 1) {
+                final String msg = "not filter must be one filter.";
+                throw new IllegalConditionBeanOperationException(msg);
+            }
+            NotFilterBuilder builder = regNotF(notFilter.filterBuilderList.get(0));
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall<FailureUrlCQ> queryLambda) {
+        query(queryLambda, null);
+    }
+
+    public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall<FailureUrlCQ> queryLambda,
+            ConditionOptionCall<QueryFilterBuilder> opLambda) {
+        FailureUrlCQ query = new FailureUrlCQ();
+        queryLambda.callback(query);
+        if (query.hasQueries()) {
+            QueryFilterBuilder builder = regQueryF(query.getQuery());
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void setConfigId_Term(String configId) {
+        setConfigId_Term(configId, null);
+    }
+
+    public void setConfigId_Term(String configId, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("configId", configId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setConfigId_Terms(Collection<String> configIdList) {
+        setConfigId_Terms(configIdList, null);
+    }
+
+    public void setConfigId_Terms(Collection<String> configIdList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("configId", configIdList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setConfigId_InScope(Collection<String> configIdList) {
+        setConfigId_Terms(configIdList, null);
+    }
+
+    public void setConfigId_InScope(Collection<String> configIdList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setConfigId_Terms(configIdList, opLambda);
+    }
+
+    public void setConfigId_Prefix(String configId) {
+        setConfigId_Prefix(configId, null);
+    }
+
+    public void setConfigId_Prefix(String configId, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("configId", configId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setConfigId_Exists() {
+        setConfigId_Exists(null);
+    }
+
+    public void setConfigId_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("configId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setConfigId_Missing() {
+        setConfigId_Missing(null);
+    }
+
+    public void setConfigId_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("configId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setConfigId_GreaterThan(String configId) {
+        setConfigId_GreaterThan(configId, null);
+    }
+
+    public void setConfigId_GreaterThan(String configId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("configId", ConditionKey.CK_GREATER_THAN, configId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setConfigId_LessThan(String configId) {
+        setConfigId_LessThan(configId, null);
+    }
+
+    public void setConfigId_LessThan(String configId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("configId", ConditionKey.CK_LESS_THAN, configId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setConfigId_GreaterEqual(String configId) {
+        setConfigId_GreaterEqual(configId, null);
+    }
+
+    public void setConfigId_GreaterEqual(String configId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("configId", ConditionKey.CK_GREATER_EQUAL, configId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setConfigId_LessEqual(String configId) {
+        setConfigId_LessEqual(configId, null);
+    }
+
+    public void setConfigId_LessEqual(String configId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("configId", ConditionKey.CK_LESS_EQUAL, configId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setErrorCount_Term(Integer errorCount) {
+        setErrorCount_Term(errorCount, null);
+    }
+
+    public void setErrorCount_Term(Integer errorCount, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("errorCount", errorCount);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setErrorCount_Terms(Collection<Integer> errorCountList) {
+        setErrorCount_Terms(errorCountList, null);
+    }
+
+    public void setErrorCount_Terms(Collection<Integer> errorCountList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("errorCount", errorCountList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setErrorCount_InScope(Collection<Integer> errorCountList) {
+        setErrorCount_Terms(errorCountList, null);
+    }
+
+    public void setErrorCount_InScope(Collection<Integer> errorCountList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setErrorCount_Terms(errorCountList, opLambda);
+    }
+
+    public void setErrorCount_Exists() {
+        setErrorCount_Exists(null);
+    }
+
+    public void setErrorCount_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("errorCount");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setErrorCount_Missing() {
+        setErrorCount_Missing(null);
+    }
+
+    public void setErrorCount_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("errorCount");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setErrorCount_GreaterThan(Integer errorCount) {
+        setErrorCount_GreaterThan(errorCount, null);
+    }
+
+    public void setErrorCount_GreaterThan(Integer errorCount, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("errorCount", ConditionKey.CK_GREATER_THAN, errorCount);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setErrorCount_LessThan(Integer errorCount) {
+        setErrorCount_LessThan(errorCount, null);
+    }
+
+    public void setErrorCount_LessThan(Integer errorCount, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("errorCount", ConditionKey.CK_LESS_THAN, errorCount);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setErrorCount_GreaterEqual(Integer errorCount) {
+        setErrorCount_GreaterEqual(errorCount, null);
+    }
+
+    public void setErrorCount_GreaterEqual(Integer errorCount, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("errorCount", ConditionKey.CK_GREATER_EQUAL, errorCount);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setErrorCount_LessEqual(Integer errorCount) {
+        setErrorCount_LessEqual(errorCount, null);
+    }
+
+    public void setErrorCount_LessEqual(Integer errorCount, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("errorCount", ConditionKey.CK_LESS_EQUAL, errorCount);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setErrorLog_Term(String errorLog) {
+        setErrorLog_Term(errorLog, null);
+    }
+
+    public void setErrorLog_Term(String errorLog, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("errorLog", errorLog);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setErrorLog_Terms(Collection<String> errorLogList) {
+        setErrorLog_Terms(errorLogList, null);
+    }
+
+    public void setErrorLog_Terms(Collection<String> errorLogList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("errorLog", errorLogList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setErrorLog_InScope(Collection<String> errorLogList) {
+        setErrorLog_Terms(errorLogList, null);
+    }
+
+    public void setErrorLog_InScope(Collection<String> errorLogList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setErrorLog_Terms(errorLogList, opLambda);
+    }
+
+    public void setErrorLog_Prefix(String errorLog) {
+        setErrorLog_Prefix(errorLog, null);
+    }
+
+    public void setErrorLog_Prefix(String errorLog, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("errorLog", errorLog);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setErrorLog_Exists() {
+        setErrorLog_Exists(null);
+    }
+
+    public void setErrorLog_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("errorLog");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setErrorLog_Missing() {
+        setErrorLog_Missing(null);
+    }
+
+    public void setErrorLog_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("errorLog");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setErrorLog_GreaterThan(String errorLog) {
+        setErrorLog_GreaterThan(errorLog, null);
+    }
+
+    public void setErrorLog_GreaterThan(String errorLog, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("errorLog", ConditionKey.CK_GREATER_THAN, errorLog);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setErrorLog_LessThan(String errorLog) {
+        setErrorLog_LessThan(errorLog, null);
+    }
+
+    public void setErrorLog_LessThan(String errorLog, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("errorLog", ConditionKey.CK_LESS_THAN, errorLog);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setErrorLog_GreaterEqual(String errorLog) {
+        setErrorLog_GreaterEqual(errorLog, null);
+    }
+
+    public void setErrorLog_GreaterEqual(String errorLog, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("errorLog", ConditionKey.CK_GREATER_EQUAL, errorLog);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setErrorLog_LessEqual(String errorLog) {
+        setErrorLog_LessEqual(errorLog, null);
+    }
+
+    public void setErrorLog_LessEqual(String errorLog, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("errorLog", ConditionKey.CK_LESS_EQUAL, errorLog);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setErrorName_Term(String errorName) {
+        setErrorName_Term(errorName, null);
+    }
+
+    public void setErrorName_Term(String errorName, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("errorName", errorName);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setErrorName_Terms(Collection<String> errorNameList) {
+        setErrorName_Terms(errorNameList, null);
+    }
+
+    public void setErrorName_Terms(Collection<String> errorNameList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("errorName", errorNameList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setErrorName_InScope(Collection<String> errorNameList) {
+        setErrorName_Terms(errorNameList, null);
+    }
+
+    public void setErrorName_InScope(Collection<String> errorNameList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setErrorName_Terms(errorNameList, opLambda);
+    }
+
+    public void setErrorName_Prefix(String errorName) {
+        setErrorName_Prefix(errorName, null);
+    }
+
+    public void setErrorName_Prefix(String errorName, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("errorName", errorName);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setErrorName_Exists() {
+        setErrorName_Exists(null);
+    }
+
+    public void setErrorName_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("errorName");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setErrorName_Missing() {
+        setErrorName_Missing(null);
+    }
+
+    public void setErrorName_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("errorName");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setErrorName_GreaterThan(String errorName) {
+        setErrorName_GreaterThan(errorName, null);
+    }
+
+    public void setErrorName_GreaterThan(String errorName, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("errorName", ConditionKey.CK_GREATER_THAN, errorName);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setErrorName_LessThan(String errorName) {
+        setErrorName_LessThan(errorName, null);
+    }
+
+    public void setErrorName_LessThan(String errorName, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("errorName", ConditionKey.CK_LESS_THAN, errorName);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setErrorName_GreaterEqual(String errorName) {
+        setErrorName_GreaterEqual(errorName, null);
+    }
+
+    public void setErrorName_GreaterEqual(String errorName, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("errorName", ConditionKey.CK_GREATER_EQUAL, errorName);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setErrorName_LessEqual(String errorName) {
+        setErrorName_LessEqual(errorName, null);
+    }
+
+    public void setErrorName_LessEqual(String errorName, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("errorName", ConditionKey.CK_LESS_EQUAL, errorName);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Term(String id) {
+        setId_Term(id, null);
+    }
+
+    public void setId_Term(String id, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("id", id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Terms(Collection<String> idList) {
+        setId_Terms(idList, null);
+    }
+
+    public void setId_Terms(Collection<String> idList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("id", idList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_InScope(Collection<String> idList) {
+        setId_Terms(idList, null);
+    }
+
+    public void setId_InScope(Collection<String> idList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setId_Terms(idList, opLambda);
+    }
+
+    public void setId_Prefix(String id) {
+        setId_Prefix(id, null);
+    }
+
+    public void setId_Prefix(String id, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("id", id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Exists() {
+        setId_Exists(null);
+    }
+
+    public void setId_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("id");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Missing() {
+        setId_Missing(null);
+    }
+
+    public void setId_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("id");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_GreaterThan(String id) {
+        setId_GreaterThan(id, null);
+    }
+
+    public void setId_GreaterThan(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_THAN, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_LessThan(String id) {
+        setId_LessThan(id, null);
+    }
+
+    public void setId_LessThan(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_THAN, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_GreaterEqual(String id) {
+        setId_GreaterEqual(id, null);
+    }
+
+    public void setId_GreaterEqual(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_EQUAL, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_LessEqual(String id) {
+        setId_LessEqual(id, null);
+    }
+
+    public void setId_LessEqual(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_EQUAL, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setLastAccessTime_Term(Long lastAccessTime) {
+        setLastAccessTime_Term(lastAccessTime, null);
+    }
+
+    public void setLastAccessTime_Term(Long lastAccessTime, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("lastAccessTime", lastAccessTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setLastAccessTime_Terms(Collection<Long> lastAccessTimeList) {
+        setLastAccessTime_Terms(lastAccessTimeList, null);
+    }
+
+    public void setLastAccessTime_Terms(Collection<Long> lastAccessTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("lastAccessTime", lastAccessTimeList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setLastAccessTime_InScope(Collection<Long> lastAccessTimeList) {
+        setLastAccessTime_Terms(lastAccessTimeList, null);
+    }
+
+    public void setLastAccessTime_InScope(Collection<Long> lastAccessTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setLastAccessTime_Terms(lastAccessTimeList, opLambda);
+    }
+
+    public void setLastAccessTime_Exists() {
+        setLastAccessTime_Exists(null);
+    }
+
+    public void setLastAccessTime_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("lastAccessTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setLastAccessTime_Missing() {
+        setLastAccessTime_Missing(null);
+    }
+
+    public void setLastAccessTime_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("lastAccessTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setLastAccessTime_GreaterThan(Long lastAccessTime) {
+        setLastAccessTime_GreaterThan(lastAccessTime, null);
+    }
+
+    public void setLastAccessTime_GreaterThan(Long lastAccessTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("lastAccessTime", ConditionKey.CK_GREATER_THAN, lastAccessTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setLastAccessTime_LessThan(Long lastAccessTime) {
+        setLastAccessTime_LessThan(lastAccessTime, null);
+    }
+
+    public void setLastAccessTime_LessThan(Long lastAccessTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("lastAccessTime", ConditionKey.CK_LESS_THAN, lastAccessTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setLastAccessTime_GreaterEqual(Long lastAccessTime) {
+        setLastAccessTime_GreaterEqual(lastAccessTime, null);
+    }
+
+    public void setLastAccessTime_GreaterEqual(Long lastAccessTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("lastAccessTime", ConditionKey.CK_GREATER_EQUAL, lastAccessTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setLastAccessTime_LessEqual(Long lastAccessTime) {
+        setLastAccessTime_LessEqual(lastAccessTime, null);
+    }
+
+    public void setLastAccessTime_LessEqual(Long lastAccessTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("lastAccessTime", ConditionKey.CK_LESS_EQUAL, lastAccessTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setThreadName_Term(String threadName) {
+        setThreadName_Term(threadName, null);
+    }
+
+    public void setThreadName_Term(String threadName, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("threadName", threadName);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setThreadName_Terms(Collection<String> threadNameList) {
+        setThreadName_Terms(threadNameList, null);
+    }
+
+    public void setThreadName_Terms(Collection<String> threadNameList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("threadName", threadNameList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setThreadName_InScope(Collection<String> threadNameList) {
+        setThreadName_Terms(threadNameList, null);
+    }
+
+    public void setThreadName_InScope(Collection<String> threadNameList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setThreadName_Terms(threadNameList, opLambda);
+    }
+
+    public void setThreadName_Prefix(String threadName) {
+        setThreadName_Prefix(threadName, null);
+    }
+
+    public void setThreadName_Prefix(String threadName, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("threadName", threadName);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setThreadName_Exists() {
+        setThreadName_Exists(null);
+    }
+
+    public void setThreadName_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("threadName");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setThreadName_Missing() {
+        setThreadName_Missing(null);
+    }
+
+    public void setThreadName_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("threadName");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setThreadName_GreaterThan(String threadName) {
+        setThreadName_GreaterThan(threadName, null);
+    }
+
+    public void setThreadName_GreaterThan(String threadName, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("threadName", ConditionKey.CK_GREATER_THAN, threadName);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setThreadName_LessThan(String threadName) {
+        setThreadName_LessThan(threadName, null);
+    }
+
+    public void setThreadName_LessThan(String threadName, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("threadName", ConditionKey.CK_LESS_THAN, threadName);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setThreadName_GreaterEqual(String threadName) {
+        setThreadName_GreaterEqual(threadName, null);
+    }
+
+    public void setThreadName_GreaterEqual(String threadName, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("threadName", ConditionKey.CK_GREATER_EQUAL, threadName);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setThreadName_LessEqual(String threadName) {
+        setThreadName_LessEqual(threadName, null);
+    }
+
+    public void setThreadName_LessEqual(String threadName, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("threadName", ConditionKey.CK_LESS_EQUAL, threadName);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUrl_Term(String url) {
+        setUrl_Term(url, null);
+    }
+
+    public void setUrl_Term(String url, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("url", url);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUrl_Terms(Collection<String> urlList) {
+        setUrl_Terms(urlList, null);
+    }
+
+    public void setUrl_Terms(Collection<String> urlList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("url", urlList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUrl_InScope(Collection<String> urlList) {
+        setUrl_Terms(urlList, null);
+    }
+
+    public void setUrl_InScope(Collection<String> urlList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setUrl_Terms(urlList, opLambda);
+    }
+
+    public void setUrl_Prefix(String url) {
+        setUrl_Prefix(url, null);
+    }
+
+    public void setUrl_Prefix(String url, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("url", url);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUrl_Exists() {
+        setUrl_Exists(null);
+    }
+
+    public void setUrl_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("url");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUrl_Missing() {
+        setUrl_Missing(null);
+    }
+
+    public void setUrl_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("url");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUrl_GreaterThan(String url) {
+        setUrl_GreaterThan(url, null);
+    }
+
+    public void setUrl_GreaterThan(String url, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("url", ConditionKey.CK_GREATER_THAN, url);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUrl_LessThan(String url) {
+        setUrl_LessThan(url, null);
+    }
+
+    public void setUrl_LessThan(String url, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("url", ConditionKey.CK_LESS_THAN, url);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUrl_GreaterEqual(String url) {
+        setUrl_GreaterEqual(url, null);
+    }
+
+    public void setUrl_GreaterEqual(String url, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("url", ConditionKey.CK_GREATER_EQUAL, url);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUrl_LessEqual(String url) {
+        setUrl_LessEqual(url, null);
+    }
+
+    public void setUrl_LessEqual(String url, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("url", ConditionKey.CK_LESS_EQUAL, url);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+}

src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsFavoriteLogCF.java

@@ -0,0 +1,526 @@
+package org.codelibs.fess.es.cbean.cf.bs;
+
+import java.util.Collection;
+
+import org.codelibs.fess.es.cbean.cf.FavoriteLogCF;
+import org.codelibs.fess.es.cbean.cq.FavoriteLogCQ;
+import org.dbflute.exception.IllegalConditionBeanOperationException;
+import org.dbflute.cbean.ckey.ConditionKey;
+import org.elasticsearch.index.query.AndFilterBuilder;
+import org.elasticsearch.index.query.BoolFilterBuilder;
+import org.elasticsearch.index.query.ExistsFilterBuilder;
+import org.elasticsearch.index.query.MissingFilterBuilder;
+import org.elasticsearch.index.query.NotFilterBuilder;
+import org.elasticsearch.index.query.OrFilterBuilder;
+import org.elasticsearch.index.query.PrefixFilterBuilder;
+import org.elasticsearch.index.query.QueryFilterBuilder;
+import org.elasticsearch.index.query.RangeFilterBuilder;
+import org.elasticsearch.index.query.TermFilterBuilder;
+import org.elasticsearch.index.query.TermsFilterBuilder;
+
+/**
+ * @author FreeGen
+ */
+public abstract class BsFavoriteLogCF extends AbstractConditionFilter {
+
+    public void bool(BoolCall<FavoriteLogCF> boolLambda) {
+        bool(boolLambda, null);
+    }
+
+    public void bool(BoolCall<FavoriteLogCF> boolLambda, ConditionOptionCall<BoolFilterBuilder> opLambda) {
+        FavoriteLogCF mustFilter = new FavoriteLogCF();
+        FavoriteLogCF shouldFilter = new FavoriteLogCF();
+        FavoriteLogCF mustNotFilter = new FavoriteLogCF();
+        boolLambda.callback(mustFilter, shouldFilter, mustNotFilter);
+        if (mustFilter.hasFilters() || shouldFilter.hasFilters() || mustNotFilter.hasFilters()) {
+            BoolFilterBuilder builder =
+                    regBoolF(mustFilter.filterBuilderList, shouldFilter.filterBuilderList, mustNotFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void and(OperatorCall<FavoriteLogCF> andLambda) {
+        and(andLambda, null);
+    }
+
+    public void and(OperatorCall<FavoriteLogCF> andLambda, ConditionOptionCall<AndFilterBuilder> opLambda) {
+        FavoriteLogCF andFilter = new FavoriteLogCF();
+        andLambda.callback(andFilter);
+        if (andFilter.hasFilters()) {
+            AndFilterBuilder builder = regAndF(andFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void or(OperatorCall<FavoriteLogCF> orLambda) {
+        or(orLambda, null);
+    }
+
+    public void or(OperatorCall<FavoriteLogCF> orLambda, ConditionOptionCall<OrFilterBuilder> opLambda) {
+        FavoriteLogCF orFilter = new FavoriteLogCF();
+        orLambda.callback(orFilter);
+        if (orFilter.hasFilters()) {
+            OrFilterBuilder builder = regOrF(orFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void not(OperatorCall<FavoriteLogCF> notLambda) {
+        not(notLambda, null);
+    }
+
+    public void not(OperatorCall<FavoriteLogCF> notLambda, ConditionOptionCall<NotFilterBuilder> opLambda) {
+        FavoriteLogCF notFilter = new FavoriteLogCF();
+        notLambda.callback(notFilter);
+        if (notFilter.hasFilters()) {
+            if (notFilter.filterBuilderList.size() > 1) {
+                final String msg = "not filter must be one filter.";
+                throw new IllegalConditionBeanOperationException(msg);
+            }
+            NotFilterBuilder builder = regNotF(notFilter.filterBuilderList.get(0));
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall<FavoriteLogCQ> queryLambda) {
+        query(queryLambda, null);
+    }
+
+    public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall<FavoriteLogCQ> queryLambda,
+            ConditionOptionCall<QueryFilterBuilder> opLambda) {
+        FavoriteLogCQ query = new FavoriteLogCQ();
+        queryLambda.callback(query);
+        if (query.hasQueries()) {
+            QueryFilterBuilder builder = regQueryF(query.getQuery());
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void setCreatedTime_Term(Long createdTime) {
+        setCreatedTime_Term(createdTime, null);
+    }
+
+    public void setCreatedTime_Term(Long createdTime, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("createdTime", createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_Terms(Collection<Long> createdTimeList) {
+        setCreatedTime_Terms(createdTimeList, null);
+    }
+
+    public void setCreatedTime_Terms(Collection<Long> createdTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("createdTime", createdTimeList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_InScope(Collection<Long> createdTimeList) {
+        setCreatedTime_Terms(createdTimeList, null);
+    }
+
+    public void setCreatedTime_InScope(Collection<Long> createdTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setCreatedTime_Terms(createdTimeList, opLambda);
+    }
+
+    public void setCreatedTime_Exists() {
+        setCreatedTime_Exists(null);
+    }
+
+    public void setCreatedTime_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("createdTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_Missing() {
+        setCreatedTime_Missing(null);
+    }
+
+    public void setCreatedTime_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("createdTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_GreaterThan(Long createdTime) {
+        setCreatedTime_GreaterThan(createdTime, null);
+    }
+
+    public void setCreatedTime_GreaterThan(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_THAN, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_LessThan(Long createdTime) {
+        setCreatedTime_LessThan(createdTime, null);
+    }
+
+    public void setCreatedTime_LessThan(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_THAN, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_GreaterEqual(Long createdTime) {
+        setCreatedTime_GreaterEqual(createdTime, null);
+    }
+
+    public void setCreatedTime_GreaterEqual(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_LessEqual(Long createdTime) {
+        setCreatedTime_LessEqual(createdTime, null);
+    }
+
+    public void setCreatedTime_LessEqual(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Term(String id) {
+        setId_Term(id, null);
+    }
+
+    public void setId_Term(String id, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("id", id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Terms(Collection<String> idList) {
+        setId_Terms(idList, null);
+    }
+
+    public void setId_Terms(Collection<String> idList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("id", idList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_InScope(Collection<String> idList) {
+        setId_Terms(idList, null);
+    }
+
+    public void setId_InScope(Collection<String> idList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setId_Terms(idList, opLambda);
+    }
+
+    public void setId_Prefix(String id) {
+        setId_Prefix(id, null);
+    }
+
+    public void setId_Prefix(String id, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("id", id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Exists() {
+        setId_Exists(null);
+    }
+
+    public void setId_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("id");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Missing() {
+        setId_Missing(null);
+    }
+
+    public void setId_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("id");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_GreaterThan(String id) {
+        setId_GreaterThan(id, null);
+    }
+
+    public void setId_GreaterThan(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_THAN, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_LessThan(String id) {
+        setId_LessThan(id, null);
+    }
+
+    public void setId_LessThan(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_THAN, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_GreaterEqual(String id) {
+        setId_GreaterEqual(id, null);
+    }
+
+    public void setId_GreaterEqual(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_EQUAL, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_LessEqual(String id) {
+        setId_LessEqual(id, null);
+    }
+
+    public void setId_LessEqual(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_EQUAL, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUrl_Term(String url) {
+        setUrl_Term(url, null);
+    }
+
+    public void setUrl_Term(String url, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("url", url);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUrl_Terms(Collection<String> urlList) {
+        setUrl_Terms(urlList, null);
+    }
+
+    public void setUrl_Terms(Collection<String> urlList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("url", urlList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUrl_InScope(Collection<String> urlList) {
+        setUrl_Terms(urlList, null);
+    }
+
+    public void setUrl_InScope(Collection<String> urlList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setUrl_Terms(urlList, opLambda);
+    }
+
+    public void setUrl_Prefix(String url) {
+        setUrl_Prefix(url, null);
+    }
+
+    public void setUrl_Prefix(String url, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("url", url);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUrl_Exists() {
+        setUrl_Exists(null);
+    }
+
+    public void setUrl_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("url");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUrl_Missing() {
+        setUrl_Missing(null);
+    }
+
+    public void setUrl_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("url");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUrl_GreaterThan(String url) {
+        setUrl_GreaterThan(url, null);
+    }
+
+    public void setUrl_GreaterThan(String url, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("url", ConditionKey.CK_GREATER_THAN, url);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUrl_LessThan(String url) {
+        setUrl_LessThan(url, null);
+    }
+
+    public void setUrl_LessThan(String url, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("url", ConditionKey.CK_LESS_THAN, url);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUrl_GreaterEqual(String url) {
+        setUrl_GreaterEqual(url, null);
+    }
+
+    public void setUrl_GreaterEqual(String url, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("url", ConditionKey.CK_GREATER_EQUAL, url);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUrl_LessEqual(String url) {
+        setUrl_LessEqual(url, null);
+    }
+
+    public void setUrl_LessEqual(String url, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("url", ConditionKey.CK_LESS_EQUAL, url);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUserInfoId_Term(String userInfoId) {
+        setUserInfoId_Term(userInfoId, null);
+    }
+
+    public void setUserInfoId_Term(String userInfoId, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("userInfoId", userInfoId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUserInfoId_Terms(Collection<String> userInfoIdList) {
+        setUserInfoId_Terms(userInfoIdList, null);
+    }
+
+    public void setUserInfoId_Terms(Collection<String> userInfoIdList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("userInfoId", userInfoIdList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUserInfoId_InScope(Collection<String> userInfoIdList) {
+        setUserInfoId_Terms(userInfoIdList, null);
+    }
+
+    public void setUserInfoId_InScope(Collection<String> userInfoIdList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setUserInfoId_Terms(userInfoIdList, opLambda);
+    }
+
+    public void setUserInfoId_Prefix(String userInfoId) {
+        setUserInfoId_Prefix(userInfoId, null);
+    }
+
+    public void setUserInfoId_Prefix(String userInfoId, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("userInfoId", userInfoId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUserInfoId_Exists() {
+        setUserInfoId_Exists(null);
+    }
+
+    public void setUserInfoId_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("userInfoId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUserInfoId_Missing() {
+        setUserInfoId_Missing(null);
+    }
+
+    public void setUserInfoId_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("userInfoId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUserInfoId_GreaterThan(String userInfoId) {
+        setUserInfoId_GreaterThan(userInfoId, null);
+    }
+
+    public void setUserInfoId_GreaterThan(String userInfoId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("userInfoId", ConditionKey.CK_GREATER_THAN, userInfoId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUserInfoId_LessThan(String userInfoId) {
+        setUserInfoId_LessThan(userInfoId, null);
+    }
+
+    public void setUserInfoId_LessThan(String userInfoId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("userInfoId", ConditionKey.CK_LESS_THAN, userInfoId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUserInfoId_GreaterEqual(String userInfoId) {
+        setUserInfoId_GreaterEqual(userInfoId, null);
+    }
+
+    public void setUserInfoId_GreaterEqual(String userInfoId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("userInfoId", ConditionKey.CK_GREATER_EQUAL, userInfoId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUserInfoId_LessEqual(String userInfoId) {
+        setUserInfoId_LessEqual(userInfoId, null);
+    }
+
+    public void setUserInfoId_LessEqual(String userInfoId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("userInfoId", ConditionKey.CK_LESS_EQUAL, userInfoId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+}

src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsFileAuthenticationCF.java

@@ -0,0 +1,1360 @@
+package org.codelibs.fess.es.cbean.cf.bs;
+
+import java.util.Collection;
+
+import org.codelibs.fess.es.cbean.cf.FileAuthenticationCF;
+import org.codelibs.fess.es.cbean.cq.FileAuthenticationCQ;
+import org.dbflute.exception.IllegalConditionBeanOperationException;
+import org.dbflute.cbean.ckey.ConditionKey;
+import org.elasticsearch.index.query.AndFilterBuilder;
+import org.elasticsearch.index.query.BoolFilterBuilder;
+import org.elasticsearch.index.query.ExistsFilterBuilder;
+import org.elasticsearch.index.query.MissingFilterBuilder;
+import org.elasticsearch.index.query.NotFilterBuilder;
+import org.elasticsearch.index.query.OrFilterBuilder;
+import org.elasticsearch.index.query.PrefixFilterBuilder;
+import org.elasticsearch.index.query.QueryFilterBuilder;
+import org.elasticsearch.index.query.RangeFilterBuilder;
+import org.elasticsearch.index.query.TermFilterBuilder;
+import org.elasticsearch.index.query.TermsFilterBuilder;
+
+/**
+ * @author FreeGen
+ */
+public abstract class BsFileAuthenticationCF extends AbstractConditionFilter {
+
+    public void bool(BoolCall<FileAuthenticationCF> boolLambda) {
+        bool(boolLambda, null);
+    }
+
+    public void bool(BoolCall<FileAuthenticationCF> boolLambda, ConditionOptionCall<BoolFilterBuilder> opLambda) {
+        FileAuthenticationCF mustFilter = new FileAuthenticationCF();
+        FileAuthenticationCF shouldFilter = new FileAuthenticationCF();
+        FileAuthenticationCF mustNotFilter = new FileAuthenticationCF();
+        boolLambda.callback(mustFilter, shouldFilter, mustNotFilter);
+        if (mustFilter.hasFilters() || shouldFilter.hasFilters() || mustNotFilter.hasFilters()) {
+            BoolFilterBuilder builder =
+                    regBoolF(mustFilter.filterBuilderList, shouldFilter.filterBuilderList, mustNotFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void and(OperatorCall<FileAuthenticationCF> andLambda) {
+        and(andLambda, null);
+    }
+
+    public void and(OperatorCall<FileAuthenticationCF> andLambda, ConditionOptionCall<AndFilterBuilder> opLambda) {
+        FileAuthenticationCF andFilter = new FileAuthenticationCF();
+        andLambda.callback(andFilter);
+        if (andFilter.hasFilters()) {
+            AndFilterBuilder builder = regAndF(andFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void or(OperatorCall<FileAuthenticationCF> orLambda) {
+        or(orLambda, null);
+    }
+
+    public void or(OperatorCall<FileAuthenticationCF> orLambda, ConditionOptionCall<OrFilterBuilder> opLambda) {
+        FileAuthenticationCF orFilter = new FileAuthenticationCF();
+        orLambda.callback(orFilter);
+        if (orFilter.hasFilters()) {
+            OrFilterBuilder builder = regOrF(orFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void not(OperatorCall<FileAuthenticationCF> notLambda) {
+        not(notLambda, null);
+    }
+
+    public void not(OperatorCall<FileAuthenticationCF> notLambda, ConditionOptionCall<NotFilterBuilder> opLambda) {
+        FileAuthenticationCF notFilter = new FileAuthenticationCF();
+        notLambda.callback(notFilter);
+        if (notFilter.hasFilters()) {
+            if (notFilter.filterBuilderList.size() > 1) {
+                final String msg = "not filter must be one filter.";
+                throw new IllegalConditionBeanOperationException(msg);
+            }
+            NotFilterBuilder builder = regNotF(notFilter.filterBuilderList.get(0));
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall<FileAuthenticationCQ> queryLambda) {
+        query(queryLambda, null);
+    }
+
+    public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall<FileAuthenticationCQ> queryLambda,
+            ConditionOptionCall<QueryFilterBuilder> opLambda) {
+        FileAuthenticationCQ query = new FileAuthenticationCQ();
+        queryLambda.callback(query);
+        if (query.hasQueries()) {
+            QueryFilterBuilder builder = regQueryF(query.getQuery());
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void setCreatedBy_Term(String createdBy) {
+        setCreatedBy_Term(createdBy, null);
+    }
+
+    public void setCreatedBy_Term(String createdBy, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_Terms(Collection<String> createdByList) {
+        setCreatedBy_Terms(createdByList, null);
+    }
+
+    public void setCreatedBy_Terms(Collection<String> createdByList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("createdBy", createdByList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_InScope(Collection<String> createdByList) {
+        setCreatedBy_Terms(createdByList, null);
+    }
+
+    public void setCreatedBy_InScope(Collection<String> createdByList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setCreatedBy_Terms(createdByList, opLambda);
+    }
+
+    public void setCreatedBy_Prefix(String createdBy) {
+        setCreatedBy_Prefix(createdBy, null);
+    }
+
+    public void setCreatedBy_Prefix(String createdBy, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_Exists() {
+        setCreatedBy_Exists(null);
+    }
+
+    public void setCreatedBy_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("createdBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_Missing() {
+        setCreatedBy_Missing(null);
+    }
+
+    public void setCreatedBy_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("createdBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_GreaterThan(String createdBy) {
+        setCreatedBy_GreaterThan(createdBy, null);
+    }
+
+    public void setCreatedBy_GreaterThan(String createdBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_GREATER_THAN, createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_LessThan(String createdBy) {
+        setCreatedBy_LessThan(createdBy, null);
+    }
+
+    public void setCreatedBy_LessThan(String createdBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_LESS_THAN, createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_GreaterEqual(String createdBy) {
+        setCreatedBy_GreaterEqual(createdBy, null);
+    }
+
+    public void setCreatedBy_GreaterEqual(String createdBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_LessEqual(String createdBy) {
+        setCreatedBy_LessEqual(createdBy, null);
+    }
+
+    public void setCreatedBy_LessEqual(String createdBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_Term(Long createdTime) {
+        setCreatedTime_Term(createdTime, null);
+    }
+
+    public void setCreatedTime_Term(Long createdTime, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("createdTime", createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_Terms(Collection<Long> createdTimeList) {
+        setCreatedTime_Terms(createdTimeList, null);
+    }
+
+    public void setCreatedTime_Terms(Collection<Long> createdTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("createdTime", createdTimeList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_InScope(Collection<Long> createdTimeList) {
+        setCreatedTime_Terms(createdTimeList, null);
+    }
+
+    public void setCreatedTime_InScope(Collection<Long> createdTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setCreatedTime_Terms(createdTimeList, opLambda);
+    }
+
+    public void setCreatedTime_Exists() {
+        setCreatedTime_Exists(null);
+    }
+
+    public void setCreatedTime_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("createdTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_Missing() {
+        setCreatedTime_Missing(null);
+    }
+
+    public void setCreatedTime_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("createdTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_GreaterThan(Long createdTime) {
+        setCreatedTime_GreaterThan(createdTime, null);
+    }
+
+    public void setCreatedTime_GreaterThan(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_THAN, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_LessThan(Long createdTime) {
+        setCreatedTime_LessThan(createdTime, null);
+    }
+
+    public void setCreatedTime_LessThan(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_THAN, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_GreaterEqual(Long createdTime) {
+        setCreatedTime_GreaterEqual(createdTime, null);
+    }
+
+    public void setCreatedTime_GreaterEqual(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_LessEqual(Long createdTime) {
+        setCreatedTime_LessEqual(createdTime, null);
+    }
+
+    public void setCreatedTime_LessEqual(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setFileConfigId_Term(String fileConfigId) {
+        setFileConfigId_Term(fileConfigId, null);
+    }
+
+    public void setFileConfigId_Term(String fileConfigId, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("fileConfigId", fileConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setFileConfigId_Terms(Collection<String> fileConfigIdList) {
+        setFileConfigId_Terms(fileConfigIdList, null);
+    }
+
+    public void setFileConfigId_Terms(Collection<String> fileConfigIdList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("fileConfigId", fileConfigIdList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setFileConfigId_InScope(Collection<String> fileConfigIdList) {
+        setFileConfigId_Terms(fileConfigIdList, null);
+    }
+
+    public void setFileConfigId_InScope(Collection<String> fileConfigIdList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setFileConfigId_Terms(fileConfigIdList, opLambda);
+    }
+
+    public void setFileConfigId_Prefix(String fileConfigId) {
+        setFileConfigId_Prefix(fileConfigId, null);
+    }
+
+    public void setFileConfigId_Prefix(String fileConfigId, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("fileConfigId", fileConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setFileConfigId_Exists() {
+        setFileConfigId_Exists(null);
+    }
+
+    public void setFileConfigId_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("fileConfigId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setFileConfigId_Missing() {
+        setFileConfigId_Missing(null);
+    }
+
+    public void setFileConfigId_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("fileConfigId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setFileConfigId_GreaterThan(String fileConfigId) {
+        setFileConfigId_GreaterThan(fileConfigId, null);
+    }
+
+    public void setFileConfigId_GreaterThan(String fileConfigId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("fileConfigId", ConditionKey.CK_GREATER_THAN, fileConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setFileConfigId_LessThan(String fileConfigId) {
+        setFileConfigId_LessThan(fileConfigId, null);
+    }
+
+    public void setFileConfigId_LessThan(String fileConfigId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("fileConfigId", ConditionKey.CK_LESS_THAN, fileConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setFileConfigId_GreaterEqual(String fileConfigId) {
+        setFileConfigId_GreaterEqual(fileConfigId, null);
+    }
+
+    public void setFileConfigId_GreaterEqual(String fileConfigId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("fileConfigId", ConditionKey.CK_GREATER_EQUAL, fileConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setFileConfigId_LessEqual(String fileConfigId) {
+        setFileConfigId_LessEqual(fileConfigId, null);
+    }
+
+    public void setFileConfigId_LessEqual(String fileConfigId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("fileConfigId", ConditionKey.CK_LESS_EQUAL, fileConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setHostname_Term(String hostname) {
+        setHostname_Term(hostname, null);
+    }
+
+    public void setHostname_Term(String hostname, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("hostname", hostname);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setHostname_Terms(Collection<String> hostnameList) {
+        setHostname_Terms(hostnameList, null);
+    }
+
+    public void setHostname_Terms(Collection<String> hostnameList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("hostname", hostnameList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setHostname_InScope(Collection<String> hostnameList) {
+        setHostname_Terms(hostnameList, null);
+    }
+
+    public void setHostname_InScope(Collection<String> hostnameList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setHostname_Terms(hostnameList, opLambda);
+    }
+
+    public void setHostname_Prefix(String hostname) {
+        setHostname_Prefix(hostname, null);
+    }
+
+    public void setHostname_Prefix(String hostname, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("hostname", hostname);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setHostname_Exists() {
+        setHostname_Exists(null);
+    }
+
+    public void setHostname_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("hostname");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setHostname_Missing() {
+        setHostname_Missing(null);
+    }
+
+    public void setHostname_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("hostname");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setHostname_GreaterThan(String hostname) {
+        setHostname_GreaterThan(hostname, null);
+    }
+
+    public void setHostname_GreaterThan(String hostname, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("hostname", ConditionKey.CK_GREATER_THAN, hostname);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setHostname_LessThan(String hostname) {
+        setHostname_LessThan(hostname, null);
+    }
+
+    public void setHostname_LessThan(String hostname, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("hostname", ConditionKey.CK_LESS_THAN, hostname);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setHostname_GreaterEqual(String hostname) {
+        setHostname_GreaterEqual(hostname, null);
+    }
+
+    public void setHostname_GreaterEqual(String hostname, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("hostname", ConditionKey.CK_GREATER_EQUAL, hostname);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setHostname_LessEqual(String hostname) {
+        setHostname_LessEqual(hostname, null);
+    }
+
+    public void setHostname_LessEqual(String hostname, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("hostname", ConditionKey.CK_LESS_EQUAL, hostname);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Term(String id) {
+        setId_Term(id, null);
+    }
+
+    public void setId_Term(String id, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("id", id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Terms(Collection<String> idList) {
+        setId_Terms(idList, null);
+    }
+
+    public void setId_Terms(Collection<String> idList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("id", idList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_InScope(Collection<String> idList) {
+        setId_Terms(idList, null);
+    }
+
+    public void setId_InScope(Collection<String> idList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setId_Terms(idList, opLambda);
+    }
+
+    public void setId_Prefix(String id) {
+        setId_Prefix(id, null);
+    }
+
+    public void setId_Prefix(String id, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("id", id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Exists() {
+        setId_Exists(null);
+    }
+
+    public void setId_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("id");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Missing() {
+        setId_Missing(null);
+    }
+
+    public void setId_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("id");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_GreaterThan(String id) {
+        setId_GreaterThan(id, null);
+    }
+
+    public void setId_GreaterThan(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_THAN, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_LessThan(String id) {
+        setId_LessThan(id, null);
+    }
+
+    public void setId_LessThan(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_THAN, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_GreaterEqual(String id) {
+        setId_GreaterEqual(id, null);
+    }
+
+    public void setId_GreaterEqual(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_EQUAL, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_LessEqual(String id) {
+        setId_LessEqual(id, null);
+    }
+
+    public void setId_LessEqual(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_EQUAL, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setParameters_Term(String parameters) {
+        setParameters_Term(parameters, null);
+    }
+
+    public void setParameters_Term(String parameters, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("parameters", parameters);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setParameters_Terms(Collection<String> parametersList) {
+        setParameters_Terms(parametersList, null);
+    }
+
+    public void setParameters_Terms(Collection<String> parametersList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("parameters", parametersList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setParameters_InScope(Collection<String> parametersList) {
+        setParameters_Terms(parametersList, null);
+    }
+
+    public void setParameters_InScope(Collection<String> parametersList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setParameters_Terms(parametersList, opLambda);
+    }
+
+    public void setParameters_Prefix(String parameters) {
+        setParameters_Prefix(parameters, null);
+    }
+
+    public void setParameters_Prefix(String parameters, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("parameters", parameters);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setParameters_Exists() {
+        setParameters_Exists(null);
+    }
+
+    public void setParameters_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("parameters");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setParameters_Missing() {
+        setParameters_Missing(null);
+    }
+
+    public void setParameters_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("parameters");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setParameters_GreaterThan(String parameters) {
+        setParameters_GreaterThan(parameters, null);
+    }
+
+    public void setParameters_GreaterThan(String parameters, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("parameters", ConditionKey.CK_GREATER_THAN, parameters);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setParameters_LessThan(String parameters) {
+        setParameters_LessThan(parameters, null);
+    }
+
+    public void setParameters_LessThan(String parameters, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("parameters", ConditionKey.CK_LESS_THAN, parameters);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setParameters_GreaterEqual(String parameters) {
+        setParameters_GreaterEqual(parameters, null);
+    }
+
+    public void setParameters_GreaterEqual(String parameters, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("parameters", ConditionKey.CK_GREATER_EQUAL, parameters);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setParameters_LessEqual(String parameters) {
+        setParameters_LessEqual(parameters, null);
+    }
+
+    public void setParameters_LessEqual(String parameters, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("parameters", ConditionKey.CK_LESS_EQUAL, parameters);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setPassword_Term(String password) {
+        setPassword_Term(password, null);
+    }
+
+    public void setPassword_Term(String password, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("password", password);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setPassword_Terms(Collection<String> passwordList) {
+        setPassword_Terms(passwordList, null);
+    }
+
+    public void setPassword_Terms(Collection<String> passwordList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("password", passwordList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setPassword_InScope(Collection<String> passwordList) {
+        setPassword_Terms(passwordList, null);
+    }
+
+    public void setPassword_InScope(Collection<String> passwordList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setPassword_Terms(passwordList, opLambda);
+    }
+
+    public void setPassword_Prefix(String password) {
+        setPassword_Prefix(password, null);
+    }
+
+    public void setPassword_Prefix(String password, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("password", password);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setPassword_Exists() {
+        setPassword_Exists(null);
+    }
+
+    public void setPassword_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("password");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setPassword_Missing() {
+        setPassword_Missing(null);
+    }
+
+    public void setPassword_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("password");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setPassword_GreaterThan(String password) {
+        setPassword_GreaterThan(password, null);
+    }
+
+    public void setPassword_GreaterThan(String password, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("password", ConditionKey.CK_GREATER_THAN, password);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setPassword_LessThan(String password) {
+        setPassword_LessThan(password, null);
+    }
+
+    public void setPassword_LessThan(String password, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("password", ConditionKey.CK_LESS_THAN, password);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setPassword_GreaterEqual(String password) {
+        setPassword_GreaterEqual(password, null);
+    }
+
+    public void setPassword_GreaterEqual(String password, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("password", ConditionKey.CK_GREATER_EQUAL, password);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setPassword_LessEqual(String password) {
+        setPassword_LessEqual(password, null);
+    }
+
+    public void setPassword_LessEqual(String password, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("password", ConditionKey.CK_LESS_EQUAL, password);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setPort_Term(Integer port) {
+        setPort_Term(port, null);
+    }
+
+    public void setPort_Term(Integer port, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("port", port);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setPort_Terms(Collection<Integer> portList) {
+        setPort_Terms(portList, null);
+    }
+
+    public void setPort_Terms(Collection<Integer> portList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("port", portList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setPort_InScope(Collection<Integer> portList) {
+        setPort_Terms(portList, null);
+    }
+
+    public void setPort_InScope(Collection<Integer> portList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setPort_Terms(portList, opLambda);
+    }
+
+    public void setPort_Exists() {
+        setPort_Exists(null);
+    }
+
+    public void setPort_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("port");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setPort_Missing() {
+        setPort_Missing(null);
+    }
+
+    public void setPort_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("port");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setPort_GreaterThan(Integer port) {
+        setPort_GreaterThan(port, null);
+    }
+
+    public void setPort_GreaterThan(Integer port, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("port", ConditionKey.CK_GREATER_THAN, port);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setPort_LessThan(Integer port) {
+        setPort_LessThan(port, null);
+    }
+
+    public void setPort_LessThan(Integer port, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("port", ConditionKey.CK_LESS_THAN, port);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setPort_GreaterEqual(Integer port) {
+        setPort_GreaterEqual(port, null);
+    }
+
+    public void setPort_GreaterEqual(Integer port, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("port", ConditionKey.CK_GREATER_EQUAL, port);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setPort_LessEqual(Integer port) {
+        setPort_LessEqual(port, null);
+    }
+
+    public void setPort_LessEqual(Integer port, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("port", ConditionKey.CK_LESS_EQUAL, port);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setProtocolScheme_Term(String protocolScheme) {
+        setProtocolScheme_Term(protocolScheme, null);
+    }
+
+    public void setProtocolScheme_Term(String protocolScheme, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("protocolScheme", protocolScheme);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setProtocolScheme_Terms(Collection<String> protocolSchemeList) {
+        setProtocolScheme_Terms(protocolSchemeList, null);
+    }
+
+    public void setProtocolScheme_Terms(Collection<String> protocolSchemeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("protocolScheme", protocolSchemeList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setProtocolScheme_InScope(Collection<String> protocolSchemeList) {
+        setProtocolScheme_Terms(protocolSchemeList, null);
+    }
+
+    public void setProtocolScheme_InScope(Collection<String> protocolSchemeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setProtocolScheme_Terms(protocolSchemeList, opLambda);
+    }
+
+    public void setProtocolScheme_Prefix(String protocolScheme) {
+        setProtocolScheme_Prefix(protocolScheme, null);
+    }
+
+    public void setProtocolScheme_Prefix(String protocolScheme, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("protocolScheme", protocolScheme);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setProtocolScheme_Exists() {
+        setProtocolScheme_Exists(null);
+    }
+
+    public void setProtocolScheme_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("protocolScheme");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setProtocolScheme_Missing() {
+        setProtocolScheme_Missing(null);
+    }
+
+    public void setProtocolScheme_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("protocolScheme");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setProtocolScheme_GreaterThan(String protocolScheme) {
+        setProtocolScheme_GreaterThan(protocolScheme, null);
+    }
+
+    public void setProtocolScheme_GreaterThan(String protocolScheme, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("protocolScheme", ConditionKey.CK_GREATER_THAN, protocolScheme);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setProtocolScheme_LessThan(String protocolScheme) {
+        setProtocolScheme_LessThan(protocolScheme, null);
+    }
+
+    public void setProtocolScheme_LessThan(String protocolScheme, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("protocolScheme", ConditionKey.CK_LESS_THAN, protocolScheme);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setProtocolScheme_GreaterEqual(String protocolScheme) {
+        setProtocolScheme_GreaterEqual(protocolScheme, null);
+    }
+
+    public void setProtocolScheme_GreaterEqual(String protocolScheme, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("protocolScheme", ConditionKey.CK_GREATER_EQUAL, protocolScheme);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setProtocolScheme_LessEqual(String protocolScheme) {
+        setProtocolScheme_LessEqual(protocolScheme, null);
+    }
+
+    public void setProtocolScheme_LessEqual(String protocolScheme, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("protocolScheme", ConditionKey.CK_LESS_EQUAL, protocolScheme);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Term(String updatedBy) {
+        setUpdatedBy_Term(updatedBy, null);
+    }
+
+    public void setUpdatedBy_Term(String updatedBy, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Terms(Collection<String> updatedByList) {
+        setUpdatedBy_Terms(updatedByList, null);
+    }
+
+    public void setUpdatedBy_Terms(Collection<String> updatedByList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("updatedBy", updatedByList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_InScope(Collection<String> updatedByList) {
+        setUpdatedBy_Terms(updatedByList, null);
+    }
+
+    public void setUpdatedBy_InScope(Collection<String> updatedByList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setUpdatedBy_Terms(updatedByList, opLambda);
+    }
+
+    public void setUpdatedBy_Prefix(String updatedBy) {
+        setUpdatedBy_Prefix(updatedBy, null);
+    }
+
+    public void setUpdatedBy_Prefix(String updatedBy, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Exists() {
+        setUpdatedBy_Exists(null);
+    }
+
+    public void setUpdatedBy_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("updatedBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Missing() {
+        setUpdatedBy_Missing(null);
+    }
+
+    public void setUpdatedBy_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("updatedBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_GreaterThan(String updatedBy) {
+        setUpdatedBy_GreaterThan(updatedBy, null);
+    }
+
+    public void setUpdatedBy_GreaterThan(String updatedBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_LessThan(String updatedBy) {
+        setUpdatedBy_LessThan(updatedBy, null);
+    }
+
+    public void setUpdatedBy_LessThan(String updatedBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_GreaterEqual(String updatedBy) {
+        setUpdatedBy_GreaterEqual(updatedBy, null);
+    }
+
+    public void setUpdatedBy_GreaterEqual(String updatedBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_LessEqual(String updatedBy) {
+        setUpdatedBy_LessEqual(updatedBy, null);
+    }
+
+    public void setUpdatedBy_LessEqual(String updatedBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_Term(Long updatedTime) {
+        setUpdatedTime_Term(updatedTime, null);
+    }
+
+    public void setUpdatedTime_Term(Long updatedTime, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("updatedTime", updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_Terms(Collection<Long> updatedTimeList) {
+        setUpdatedTime_Terms(updatedTimeList, null);
+    }
+
+    public void setUpdatedTime_Terms(Collection<Long> updatedTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("updatedTime", updatedTimeList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_InScope(Collection<Long> updatedTimeList) {
+        setUpdatedTime_Terms(updatedTimeList, null);
+    }
+
+    public void setUpdatedTime_InScope(Collection<Long> updatedTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setUpdatedTime_Terms(updatedTimeList, opLambda);
+    }
+
+    public void setUpdatedTime_Exists() {
+        setUpdatedTime_Exists(null);
+    }
+
+    public void setUpdatedTime_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("updatedTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_Missing() {
+        setUpdatedTime_Missing(null);
+    }
+
+    public void setUpdatedTime_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("updatedTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_GreaterThan(Long updatedTime) {
+        setUpdatedTime_GreaterThan(updatedTime, null);
+    }
+
+    public void setUpdatedTime_GreaterThan(Long updatedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_LessThan(Long updatedTime) {
+        setUpdatedTime_LessThan(updatedTime, null);
+    }
+
+    public void setUpdatedTime_LessThan(Long updatedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_GreaterEqual(Long updatedTime) {
+        setUpdatedTime_GreaterEqual(updatedTime, null);
+    }
+
+    public void setUpdatedTime_GreaterEqual(Long updatedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_LessEqual(Long updatedTime) {
+        setUpdatedTime_LessEqual(updatedTime, null);
+    }
+
+    public void setUpdatedTime_LessEqual(Long updatedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUsername_Term(String username) {
+        setUsername_Term(username, null);
+    }
+
+    public void setUsername_Term(String username, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("username", username);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUsername_Terms(Collection<String> usernameList) {
+        setUsername_Terms(usernameList, null);
+    }
+
+    public void setUsername_Terms(Collection<String> usernameList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("username", usernameList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUsername_InScope(Collection<String> usernameList) {
+        setUsername_Terms(usernameList, null);
+    }
+
+    public void setUsername_InScope(Collection<String> usernameList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setUsername_Terms(usernameList, opLambda);
+    }
+
+    public void setUsername_Prefix(String username) {
+        setUsername_Prefix(username, null);
+    }
+
+    public void setUsername_Prefix(String username, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("username", username);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUsername_Exists() {
+        setUsername_Exists(null);
+    }
+
+    public void setUsername_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("username");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUsername_Missing() {
+        setUsername_Missing(null);
+    }
+
+    public void setUsername_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("username");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUsername_GreaterThan(String username) {
+        setUsername_GreaterThan(username, null);
+    }
+
+    public void setUsername_GreaterThan(String username, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("username", ConditionKey.CK_GREATER_THAN, username);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUsername_LessThan(String username) {
+        setUsername_LessThan(username, null);
+    }
+
+    public void setUsername_LessThan(String username, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("username", ConditionKey.CK_LESS_THAN, username);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUsername_GreaterEqual(String username) {
+        setUsername_GreaterEqual(username, null);
+    }
+
+    public void setUsername_GreaterEqual(String username, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("username", ConditionKey.CK_GREATER_EQUAL, username);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUsername_LessEqual(String username) {
+        setUsername_LessEqual(username, null);
+    }
+
+    public void setUsername_LessEqual(String username, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("username", ConditionKey.CK_LESS_EQUAL, username);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+}

src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsFileConfigCF.java

@@ -0,0 +1,2043 @@
+package org.codelibs.fess.es.cbean.cf.bs;
+
+import java.util.Collection;
+
+import org.codelibs.fess.es.cbean.cf.FileConfigCF;
+import org.codelibs.fess.es.cbean.cq.FileConfigCQ;
+import org.dbflute.exception.IllegalConditionBeanOperationException;
+import org.dbflute.cbean.ckey.ConditionKey;
+import org.elasticsearch.index.query.AndFilterBuilder;
+import org.elasticsearch.index.query.BoolFilterBuilder;
+import org.elasticsearch.index.query.ExistsFilterBuilder;
+import org.elasticsearch.index.query.MissingFilterBuilder;
+import org.elasticsearch.index.query.NotFilterBuilder;
+import org.elasticsearch.index.query.OrFilterBuilder;
+import org.elasticsearch.index.query.PrefixFilterBuilder;
+import org.elasticsearch.index.query.QueryFilterBuilder;
+import org.elasticsearch.index.query.RangeFilterBuilder;
+import org.elasticsearch.index.query.TermFilterBuilder;
+import org.elasticsearch.index.query.TermsFilterBuilder;
+
+/**
+ * @author FreeGen
+ */
+public abstract class BsFileConfigCF extends AbstractConditionFilter {
+
+    public void bool(BoolCall<FileConfigCF> boolLambda) {
+        bool(boolLambda, null);
+    }
+
+    public void bool(BoolCall<FileConfigCF> boolLambda, ConditionOptionCall<BoolFilterBuilder> opLambda) {
+        FileConfigCF mustFilter = new FileConfigCF();
+        FileConfigCF shouldFilter = new FileConfigCF();
+        FileConfigCF mustNotFilter = new FileConfigCF();
+        boolLambda.callback(mustFilter, shouldFilter, mustNotFilter);
+        if (mustFilter.hasFilters() || shouldFilter.hasFilters() || mustNotFilter.hasFilters()) {
+            BoolFilterBuilder builder =
+                    regBoolF(mustFilter.filterBuilderList, shouldFilter.filterBuilderList, mustNotFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void and(OperatorCall<FileConfigCF> andLambda) {
+        and(andLambda, null);
+    }
+
+    public void and(OperatorCall<FileConfigCF> andLambda, ConditionOptionCall<AndFilterBuilder> opLambda) {
+        FileConfigCF andFilter = new FileConfigCF();
+        andLambda.callback(andFilter);
+        if (andFilter.hasFilters()) {
+            AndFilterBuilder builder = regAndF(andFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void or(OperatorCall<FileConfigCF> orLambda) {
+        or(orLambda, null);
+    }
+
+    public void or(OperatorCall<FileConfigCF> orLambda, ConditionOptionCall<OrFilterBuilder> opLambda) {
+        FileConfigCF orFilter = new FileConfigCF();
+        orLambda.callback(orFilter);
+        if (orFilter.hasFilters()) {
+            OrFilterBuilder builder = regOrF(orFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void not(OperatorCall<FileConfigCF> notLambda) {
+        not(notLambda, null);
+    }
+
+    public void not(OperatorCall<FileConfigCF> notLambda, ConditionOptionCall<NotFilterBuilder> opLambda) {
+        FileConfigCF notFilter = new FileConfigCF();
+        notLambda.callback(notFilter);
+        if (notFilter.hasFilters()) {
+            if (notFilter.filterBuilderList.size() > 1) {
+                final String msg = "not filter must be one filter.";
+                throw new IllegalConditionBeanOperationException(msg);
+            }
+            NotFilterBuilder builder = regNotF(notFilter.filterBuilderList.get(0));
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall<FileConfigCQ> queryLambda) {
+        query(queryLambda, null);
+    }
+
+    public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall<FileConfigCQ> queryLambda,
+            ConditionOptionCall<QueryFilterBuilder> opLambda) {
+        FileConfigCQ query = new FileConfigCQ();
+        queryLambda.callback(query);
+        if (query.hasQueries()) {
+            QueryFilterBuilder builder = regQueryF(query.getQuery());
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void setAvailable_Term(Boolean available) {
+        setAvailable_Term(available, null);
+    }
+
+    public void setAvailable_Term(Boolean available, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("available", available);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setAvailable_Terms(Collection<Boolean> availableList) {
+        setAvailable_Terms(availableList, null);
+    }
+
+    public void setAvailable_Terms(Collection<Boolean> availableList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("available", availableList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setAvailable_InScope(Collection<Boolean> availableList) {
+        setAvailable_Terms(availableList, null);
+    }
+
+    public void setAvailable_InScope(Collection<Boolean> availableList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setAvailable_Terms(availableList, opLambda);
+    }
+
+    public void setAvailable_Exists() {
+        setAvailable_Exists(null);
+    }
+
+    public void setAvailable_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("available");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setAvailable_Missing() {
+        setAvailable_Missing(null);
+    }
+
+    public void setAvailable_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("available");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setAvailable_GreaterThan(Boolean available) {
+        setAvailable_GreaterThan(available, null);
+    }
+
+    public void setAvailable_GreaterThan(Boolean available, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("available", ConditionKey.CK_GREATER_THAN, available);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setAvailable_LessThan(Boolean available) {
+        setAvailable_LessThan(available, null);
+    }
+
+    public void setAvailable_LessThan(Boolean available, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("available", ConditionKey.CK_LESS_THAN, available);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setAvailable_GreaterEqual(Boolean available) {
+        setAvailable_GreaterEqual(available, null);
+    }
+
+    public void setAvailable_GreaterEqual(Boolean available, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("available", ConditionKey.CK_GREATER_EQUAL, available);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setAvailable_LessEqual(Boolean available) {
+        setAvailable_LessEqual(available, null);
+    }
+
+    public void setAvailable_LessEqual(Boolean available, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("available", ConditionKey.CK_LESS_EQUAL, available);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setBoost_Term(Float boost) {
+        setBoost_Term(boost, null);
+    }
+
+    public void setBoost_Term(Float boost, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("boost", boost);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setBoost_Terms(Collection<Float> boostList) {
+        setBoost_Terms(boostList, null);
+    }
+
+    public void setBoost_Terms(Collection<Float> boostList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("boost", boostList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setBoost_InScope(Collection<Float> boostList) {
+        setBoost_Terms(boostList, null);
+    }
+
+    public void setBoost_InScope(Collection<Float> boostList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setBoost_Terms(boostList, opLambda);
+    }
+
+    public void setBoost_Exists() {
+        setBoost_Exists(null);
+    }
+
+    public void setBoost_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("boost");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setBoost_Missing() {
+        setBoost_Missing(null);
+    }
+
+    public void setBoost_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("boost");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setBoost_GreaterThan(Float boost) {
+        setBoost_GreaterThan(boost, null);
+    }
+
+    public void setBoost_GreaterThan(Float boost, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("boost", ConditionKey.CK_GREATER_THAN, boost);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setBoost_LessThan(Float boost) {
+        setBoost_LessThan(boost, null);
+    }
+
+    public void setBoost_LessThan(Float boost, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("boost", ConditionKey.CK_LESS_THAN, boost);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setBoost_GreaterEqual(Float boost) {
+        setBoost_GreaterEqual(boost, null);
+    }
+
+    public void setBoost_GreaterEqual(Float boost, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("boost", ConditionKey.CK_GREATER_EQUAL, boost);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setBoost_LessEqual(Float boost) {
+        setBoost_LessEqual(boost, null);
+    }
+
+    public void setBoost_LessEqual(Float boost, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("boost", ConditionKey.CK_LESS_EQUAL, boost);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setConfigParameter_Term(String configParameter) {
+        setConfigParameter_Term(configParameter, null);
+    }
+
+    public void setConfigParameter_Term(String configParameter, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("configParameter", configParameter);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setConfigParameter_Terms(Collection<String> configParameterList) {
+        setConfigParameter_Terms(configParameterList, null);
+    }
+
+    public void setConfigParameter_Terms(Collection<String> configParameterList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("configParameter", configParameterList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setConfigParameter_InScope(Collection<String> configParameterList) {
+        setConfigParameter_Terms(configParameterList, null);
+    }
+
+    public void setConfigParameter_InScope(Collection<String> configParameterList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setConfigParameter_Terms(configParameterList, opLambda);
+    }
+
+    public void setConfigParameter_Prefix(String configParameter) {
+        setConfigParameter_Prefix(configParameter, null);
+    }
+
+    public void setConfigParameter_Prefix(String configParameter, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("configParameter", configParameter);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setConfigParameter_Exists() {
+        setConfigParameter_Exists(null);
+    }
+
+    public void setConfigParameter_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("configParameter");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setConfigParameter_Missing() {
+        setConfigParameter_Missing(null);
+    }
+
+    public void setConfigParameter_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("configParameter");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setConfigParameter_GreaterThan(String configParameter) {
+        setConfigParameter_GreaterThan(configParameter, null);
+    }
+
+    public void setConfigParameter_GreaterThan(String configParameter, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("configParameter", ConditionKey.CK_GREATER_THAN, configParameter);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setConfigParameter_LessThan(String configParameter) {
+        setConfigParameter_LessThan(configParameter, null);
+    }
+
+    public void setConfigParameter_LessThan(String configParameter, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("configParameter", ConditionKey.CK_LESS_THAN, configParameter);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setConfigParameter_GreaterEqual(String configParameter) {
+        setConfigParameter_GreaterEqual(configParameter, null);
+    }
+
+    public void setConfigParameter_GreaterEqual(String configParameter, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("configParameter", ConditionKey.CK_GREATER_EQUAL, configParameter);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setConfigParameter_LessEqual(String configParameter) {
+        setConfigParameter_LessEqual(configParameter, null);
+    }
+
+    public void setConfigParameter_LessEqual(String configParameter, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("configParameter", ConditionKey.CK_LESS_EQUAL, configParameter);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_Term(String createdBy) {
+        setCreatedBy_Term(createdBy, null);
+    }
+
+    public void setCreatedBy_Term(String createdBy, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_Terms(Collection<String> createdByList) {
+        setCreatedBy_Terms(createdByList, null);
+    }
+
+    public void setCreatedBy_Terms(Collection<String> createdByList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("createdBy", createdByList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_InScope(Collection<String> createdByList) {
+        setCreatedBy_Terms(createdByList, null);
+    }
+
+    public void setCreatedBy_InScope(Collection<String> createdByList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setCreatedBy_Terms(createdByList, opLambda);
+    }
+
+    public void setCreatedBy_Prefix(String createdBy) {
+        setCreatedBy_Prefix(createdBy, null);
+    }
+
+    public void setCreatedBy_Prefix(String createdBy, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_Exists() {
+        setCreatedBy_Exists(null);
+    }
+
+    public void setCreatedBy_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("createdBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_Missing() {
+        setCreatedBy_Missing(null);
+    }
+
+    public void setCreatedBy_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("createdBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_GreaterThan(String createdBy) {
+        setCreatedBy_GreaterThan(createdBy, null);
+    }
+
+    public void setCreatedBy_GreaterThan(String createdBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_GREATER_THAN, createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_LessThan(String createdBy) {
+        setCreatedBy_LessThan(createdBy, null);
+    }
+
+    public void setCreatedBy_LessThan(String createdBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_LESS_THAN, createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_GreaterEqual(String createdBy) {
+        setCreatedBy_GreaterEqual(createdBy, null);
+    }
+
+    public void setCreatedBy_GreaterEqual(String createdBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_LessEqual(String createdBy) {
+        setCreatedBy_LessEqual(createdBy, null);
+    }
+
+    public void setCreatedBy_LessEqual(String createdBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_Term(Long createdTime) {
+        setCreatedTime_Term(createdTime, null);
+    }
+
+    public void setCreatedTime_Term(Long createdTime, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("createdTime", createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_Terms(Collection<Long> createdTimeList) {
+        setCreatedTime_Terms(createdTimeList, null);
+    }
+
+    public void setCreatedTime_Terms(Collection<Long> createdTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("createdTime", createdTimeList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_InScope(Collection<Long> createdTimeList) {
+        setCreatedTime_Terms(createdTimeList, null);
+    }
+
+    public void setCreatedTime_InScope(Collection<Long> createdTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setCreatedTime_Terms(createdTimeList, opLambda);
+    }
+
+    public void setCreatedTime_Exists() {
+        setCreatedTime_Exists(null);
+    }
+
+    public void setCreatedTime_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("createdTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_Missing() {
+        setCreatedTime_Missing(null);
+    }
+
+    public void setCreatedTime_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("createdTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_GreaterThan(Long createdTime) {
+        setCreatedTime_GreaterThan(createdTime, null);
+    }
+
+    public void setCreatedTime_GreaterThan(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_THAN, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_LessThan(Long createdTime) {
+        setCreatedTime_LessThan(createdTime, null);
+    }
+
+    public void setCreatedTime_LessThan(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_THAN, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_GreaterEqual(Long createdTime) {
+        setCreatedTime_GreaterEqual(createdTime, null);
+    }
+
+    public void setCreatedTime_GreaterEqual(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_LessEqual(Long createdTime) {
+        setCreatedTime_LessEqual(createdTime, null);
+    }
+
+    public void setCreatedTime_LessEqual(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setDepth_Term(Integer depth) {
+        setDepth_Term(depth, null);
+    }
+
+    public void setDepth_Term(Integer depth, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("depth", depth);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setDepth_Terms(Collection<Integer> depthList) {
+        setDepth_Terms(depthList, null);
+    }
+
+    public void setDepth_Terms(Collection<Integer> depthList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("depth", depthList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setDepth_InScope(Collection<Integer> depthList) {
+        setDepth_Terms(depthList, null);
+    }
+
+    public void setDepth_InScope(Collection<Integer> depthList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setDepth_Terms(depthList, opLambda);
+    }
+
+    public void setDepth_Exists() {
+        setDepth_Exists(null);
+    }
+
+    public void setDepth_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("depth");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setDepth_Missing() {
+        setDepth_Missing(null);
+    }
+
+    public void setDepth_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("depth");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setDepth_GreaterThan(Integer depth) {
+        setDepth_GreaterThan(depth, null);
+    }
+
+    public void setDepth_GreaterThan(Integer depth, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("depth", ConditionKey.CK_GREATER_THAN, depth);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setDepth_LessThan(Integer depth) {
+        setDepth_LessThan(depth, null);
+    }
+
+    public void setDepth_LessThan(Integer depth, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("depth", ConditionKey.CK_LESS_THAN, depth);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setDepth_GreaterEqual(Integer depth) {
+        setDepth_GreaterEqual(depth, null);
+    }
+
+    public void setDepth_GreaterEqual(Integer depth, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("depth", ConditionKey.CK_GREATER_EQUAL, depth);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setDepth_LessEqual(Integer depth) {
+        setDepth_LessEqual(depth, null);
+    }
+
+    public void setDepth_LessEqual(Integer depth, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("depth", ConditionKey.CK_LESS_EQUAL, depth);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setExcludedDocPaths_Term(String excludedDocPaths) {
+        setExcludedDocPaths_Term(excludedDocPaths, null);
+    }
+
+    public void setExcludedDocPaths_Term(String excludedDocPaths, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("excludedDocPaths", excludedDocPaths);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setExcludedDocPaths_Terms(Collection<String> excludedDocPathsList) {
+        setExcludedDocPaths_Terms(excludedDocPathsList, null);
+    }
+
+    public void setExcludedDocPaths_Terms(Collection<String> excludedDocPathsList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("excludedDocPaths", excludedDocPathsList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setExcludedDocPaths_InScope(Collection<String> excludedDocPathsList) {
+        setExcludedDocPaths_Terms(excludedDocPathsList, null);
+    }
+
+    public void setExcludedDocPaths_InScope(Collection<String> excludedDocPathsList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setExcludedDocPaths_Terms(excludedDocPathsList, opLambda);
+    }
+
+    public void setExcludedDocPaths_Prefix(String excludedDocPaths) {
+        setExcludedDocPaths_Prefix(excludedDocPaths, null);
+    }
+
+    public void setExcludedDocPaths_Prefix(String excludedDocPaths, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("excludedDocPaths", excludedDocPaths);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setExcludedDocPaths_Exists() {
+        setExcludedDocPaths_Exists(null);
+    }
+
+    public void setExcludedDocPaths_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("excludedDocPaths");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setExcludedDocPaths_Missing() {
+        setExcludedDocPaths_Missing(null);
+    }
+
+    public void setExcludedDocPaths_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("excludedDocPaths");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setExcludedDocPaths_GreaterThan(String excludedDocPaths) {
+        setExcludedDocPaths_GreaterThan(excludedDocPaths, null);
+    }
+
+    public void setExcludedDocPaths_GreaterThan(String excludedDocPaths, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("excludedDocPaths", ConditionKey.CK_GREATER_THAN, excludedDocPaths);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setExcludedDocPaths_LessThan(String excludedDocPaths) {
+        setExcludedDocPaths_LessThan(excludedDocPaths, null);
+    }
+
+    public void setExcludedDocPaths_LessThan(String excludedDocPaths, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("excludedDocPaths", ConditionKey.CK_LESS_THAN, excludedDocPaths);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setExcludedDocPaths_GreaterEqual(String excludedDocPaths) {
+        setExcludedDocPaths_GreaterEqual(excludedDocPaths, null);
+    }
+
+    public void setExcludedDocPaths_GreaterEqual(String excludedDocPaths, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("excludedDocPaths", ConditionKey.CK_GREATER_EQUAL, excludedDocPaths);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setExcludedDocPaths_LessEqual(String excludedDocPaths) {
+        setExcludedDocPaths_LessEqual(excludedDocPaths, null);
+    }
+
+    public void setExcludedDocPaths_LessEqual(String excludedDocPaths, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("excludedDocPaths", ConditionKey.CK_LESS_EQUAL, excludedDocPaths);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setExcludedPaths_Term(String excludedPaths) {
+        setExcludedPaths_Term(excludedPaths, null);
+    }
+
+    public void setExcludedPaths_Term(String excludedPaths, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("excludedPaths", excludedPaths);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setExcludedPaths_Terms(Collection<String> excludedPathsList) {
+        setExcludedPaths_Terms(excludedPathsList, null);
+    }
+
+    public void setExcludedPaths_Terms(Collection<String> excludedPathsList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("excludedPaths", excludedPathsList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setExcludedPaths_InScope(Collection<String> excludedPathsList) {
+        setExcludedPaths_Terms(excludedPathsList, null);
+    }
+
+    public void setExcludedPaths_InScope(Collection<String> excludedPathsList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setExcludedPaths_Terms(excludedPathsList, opLambda);
+    }
+
+    public void setExcludedPaths_Prefix(String excludedPaths) {
+        setExcludedPaths_Prefix(excludedPaths, null);
+    }
+
+    public void setExcludedPaths_Prefix(String excludedPaths, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("excludedPaths", excludedPaths);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setExcludedPaths_Exists() {
+        setExcludedPaths_Exists(null);
+    }
+
+    public void setExcludedPaths_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("excludedPaths");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setExcludedPaths_Missing() {
+        setExcludedPaths_Missing(null);
+    }
+
+    public void setExcludedPaths_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("excludedPaths");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setExcludedPaths_GreaterThan(String excludedPaths) {
+        setExcludedPaths_GreaterThan(excludedPaths, null);
+    }
+
+    public void setExcludedPaths_GreaterThan(String excludedPaths, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("excludedPaths", ConditionKey.CK_GREATER_THAN, excludedPaths);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setExcludedPaths_LessThan(String excludedPaths) {
+        setExcludedPaths_LessThan(excludedPaths, null);
+    }
+
+    public void setExcludedPaths_LessThan(String excludedPaths, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("excludedPaths", ConditionKey.CK_LESS_THAN, excludedPaths);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setExcludedPaths_GreaterEqual(String excludedPaths) {
+        setExcludedPaths_GreaterEqual(excludedPaths, null);
+    }
+
+    public void setExcludedPaths_GreaterEqual(String excludedPaths, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("excludedPaths", ConditionKey.CK_GREATER_EQUAL, excludedPaths);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setExcludedPaths_LessEqual(String excludedPaths) {
+        setExcludedPaths_LessEqual(excludedPaths, null);
+    }
+
+    public void setExcludedPaths_LessEqual(String excludedPaths, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("excludedPaths", ConditionKey.CK_LESS_EQUAL, excludedPaths);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Term(String id) {
+        setId_Term(id, null);
+    }
+
+    public void setId_Term(String id, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("id", id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Terms(Collection<String> idList) {
+        setId_Terms(idList, null);
+    }
+
+    public void setId_Terms(Collection<String> idList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("id", idList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_InScope(Collection<String> idList) {
+        setId_Terms(idList, null);
+    }
+
+    public void setId_InScope(Collection<String> idList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setId_Terms(idList, opLambda);
+    }
+
+    public void setId_Prefix(String id) {
+        setId_Prefix(id, null);
+    }
+
+    public void setId_Prefix(String id, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("id", id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Exists() {
+        setId_Exists(null);
+    }
+
+    public void setId_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("id");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Missing() {
+        setId_Missing(null);
+    }
+
+    public void setId_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("id");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_GreaterThan(String id) {
+        setId_GreaterThan(id, null);
+    }
+
+    public void setId_GreaterThan(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_THAN, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_LessThan(String id) {
+        setId_LessThan(id, null);
+    }
+
+    public void setId_LessThan(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_THAN, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_GreaterEqual(String id) {
+        setId_GreaterEqual(id, null);
+    }
+
+    public void setId_GreaterEqual(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_EQUAL, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_LessEqual(String id) {
+        setId_LessEqual(id, null);
+    }
+
+    public void setId_LessEqual(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_EQUAL, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIncludedDocPaths_Term(String includedDocPaths) {
+        setIncludedDocPaths_Term(includedDocPaths, null);
+    }
+
+    public void setIncludedDocPaths_Term(String includedDocPaths, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("includedDocPaths", includedDocPaths);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIncludedDocPaths_Terms(Collection<String> includedDocPathsList) {
+        setIncludedDocPaths_Terms(includedDocPathsList, null);
+    }
+
+    public void setIncludedDocPaths_Terms(Collection<String> includedDocPathsList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("includedDocPaths", includedDocPathsList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIncludedDocPaths_InScope(Collection<String> includedDocPathsList) {
+        setIncludedDocPaths_Terms(includedDocPathsList, null);
+    }
+
+    public void setIncludedDocPaths_InScope(Collection<String> includedDocPathsList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setIncludedDocPaths_Terms(includedDocPathsList, opLambda);
+    }
+
+    public void setIncludedDocPaths_Prefix(String includedDocPaths) {
+        setIncludedDocPaths_Prefix(includedDocPaths, null);
+    }
+
+    public void setIncludedDocPaths_Prefix(String includedDocPaths, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("includedDocPaths", includedDocPaths);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIncludedDocPaths_Exists() {
+        setIncludedDocPaths_Exists(null);
+    }
+
+    public void setIncludedDocPaths_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("includedDocPaths");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIncludedDocPaths_Missing() {
+        setIncludedDocPaths_Missing(null);
+    }
+
+    public void setIncludedDocPaths_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("includedDocPaths");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIncludedDocPaths_GreaterThan(String includedDocPaths) {
+        setIncludedDocPaths_GreaterThan(includedDocPaths, null);
+    }
+
+    public void setIncludedDocPaths_GreaterThan(String includedDocPaths, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("includedDocPaths", ConditionKey.CK_GREATER_THAN, includedDocPaths);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIncludedDocPaths_LessThan(String includedDocPaths) {
+        setIncludedDocPaths_LessThan(includedDocPaths, null);
+    }
+
+    public void setIncludedDocPaths_LessThan(String includedDocPaths, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("includedDocPaths", ConditionKey.CK_LESS_THAN, includedDocPaths);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIncludedDocPaths_GreaterEqual(String includedDocPaths) {
+        setIncludedDocPaths_GreaterEqual(includedDocPaths, null);
+    }
+
+    public void setIncludedDocPaths_GreaterEqual(String includedDocPaths, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("includedDocPaths", ConditionKey.CK_GREATER_EQUAL, includedDocPaths);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIncludedDocPaths_LessEqual(String includedDocPaths) {
+        setIncludedDocPaths_LessEqual(includedDocPaths, null);
+    }
+
+    public void setIncludedDocPaths_LessEqual(String includedDocPaths, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("includedDocPaths", ConditionKey.CK_LESS_EQUAL, includedDocPaths);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIncludedPaths_Term(String includedPaths) {
+        setIncludedPaths_Term(includedPaths, null);
+    }
+
+    public void setIncludedPaths_Term(String includedPaths, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("includedPaths", includedPaths);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIncludedPaths_Terms(Collection<String> includedPathsList) {
+        setIncludedPaths_Terms(includedPathsList, null);
+    }
+
+    public void setIncludedPaths_Terms(Collection<String> includedPathsList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("includedPaths", includedPathsList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIncludedPaths_InScope(Collection<String> includedPathsList) {
+        setIncludedPaths_Terms(includedPathsList, null);
+    }
+
+    public void setIncludedPaths_InScope(Collection<String> includedPathsList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setIncludedPaths_Terms(includedPathsList, opLambda);
+    }
+
+    public void setIncludedPaths_Prefix(String includedPaths) {
+        setIncludedPaths_Prefix(includedPaths, null);
+    }
+
+    public void setIncludedPaths_Prefix(String includedPaths, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("includedPaths", includedPaths);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIncludedPaths_Exists() {
+        setIncludedPaths_Exists(null);
+    }
+
+    public void setIncludedPaths_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("includedPaths");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIncludedPaths_Missing() {
+        setIncludedPaths_Missing(null);
+    }
+
+    public void setIncludedPaths_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("includedPaths");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIncludedPaths_GreaterThan(String includedPaths) {
+        setIncludedPaths_GreaterThan(includedPaths, null);
+    }
+
+    public void setIncludedPaths_GreaterThan(String includedPaths, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("includedPaths", ConditionKey.CK_GREATER_THAN, includedPaths);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIncludedPaths_LessThan(String includedPaths) {
+        setIncludedPaths_LessThan(includedPaths, null);
+    }
+
+    public void setIncludedPaths_LessThan(String includedPaths, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("includedPaths", ConditionKey.CK_LESS_THAN, includedPaths);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIncludedPaths_GreaterEqual(String includedPaths) {
+        setIncludedPaths_GreaterEqual(includedPaths, null);
+    }
+
+    public void setIncludedPaths_GreaterEqual(String includedPaths, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("includedPaths", ConditionKey.CK_GREATER_EQUAL, includedPaths);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIncludedPaths_LessEqual(String includedPaths) {
+        setIncludedPaths_LessEqual(includedPaths, null);
+    }
+
+    public void setIncludedPaths_LessEqual(String includedPaths, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("includedPaths", ConditionKey.CK_LESS_EQUAL, includedPaths);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIntervalTime_Term(Integer intervalTime) {
+        setIntervalTime_Term(intervalTime, null);
+    }
+
+    public void setIntervalTime_Term(Integer intervalTime, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("intervalTime", intervalTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIntervalTime_Terms(Collection<Integer> intervalTimeList) {
+        setIntervalTime_Terms(intervalTimeList, null);
+    }
+
+    public void setIntervalTime_Terms(Collection<Integer> intervalTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("intervalTime", intervalTimeList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIntervalTime_InScope(Collection<Integer> intervalTimeList) {
+        setIntervalTime_Terms(intervalTimeList, null);
+    }
+
+    public void setIntervalTime_InScope(Collection<Integer> intervalTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setIntervalTime_Terms(intervalTimeList, opLambda);
+    }
+
+    public void setIntervalTime_Exists() {
+        setIntervalTime_Exists(null);
+    }
+
+    public void setIntervalTime_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("intervalTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIntervalTime_Missing() {
+        setIntervalTime_Missing(null);
+    }
+
+    public void setIntervalTime_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("intervalTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIntervalTime_GreaterThan(Integer intervalTime) {
+        setIntervalTime_GreaterThan(intervalTime, null);
+    }
+
+    public void setIntervalTime_GreaterThan(Integer intervalTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("intervalTime", ConditionKey.CK_GREATER_THAN, intervalTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIntervalTime_LessThan(Integer intervalTime) {
+        setIntervalTime_LessThan(intervalTime, null);
+    }
+
+    public void setIntervalTime_LessThan(Integer intervalTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("intervalTime", ConditionKey.CK_LESS_THAN, intervalTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIntervalTime_GreaterEqual(Integer intervalTime) {
+        setIntervalTime_GreaterEqual(intervalTime, null);
+    }
+
+    public void setIntervalTime_GreaterEqual(Integer intervalTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("intervalTime", ConditionKey.CK_GREATER_EQUAL, intervalTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIntervalTime_LessEqual(Integer intervalTime) {
+        setIntervalTime_LessEqual(intervalTime, null);
+    }
+
+    public void setIntervalTime_LessEqual(Integer intervalTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("intervalTime", ConditionKey.CK_LESS_EQUAL, intervalTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setMaxAccessCount_Term(Long maxAccessCount) {
+        setMaxAccessCount_Term(maxAccessCount, null);
+    }
+
+    public void setMaxAccessCount_Term(Long maxAccessCount, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("maxAccessCount", maxAccessCount);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setMaxAccessCount_Terms(Collection<Long> maxAccessCountList) {
+        setMaxAccessCount_Terms(maxAccessCountList, null);
+    }
+
+    public void setMaxAccessCount_Terms(Collection<Long> maxAccessCountList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("maxAccessCount", maxAccessCountList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setMaxAccessCount_InScope(Collection<Long> maxAccessCountList) {
+        setMaxAccessCount_Terms(maxAccessCountList, null);
+    }
+
+    public void setMaxAccessCount_InScope(Collection<Long> maxAccessCountList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setMaxAccessCount_Terms(maxAccessCountList, opLambda);
+    }
+
+    public void setMaxAccessCount_Exists() {
+        setMaxAccessCount_Exists(null);
+    }
+
+    public void setMaxAccessCount_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("maxAccessCount");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setMaxAccessCount_Missing() {
+        setMaxAccessCount_Missing(null);
+    }
+
+    public void setMaxAccessCount_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("maxAccessCount");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setMaxAccessCount_GreaterThan(Long maxAccessCount) {
+        setMaxAccessCount_GreaterThan(maxAccessCount, null);
+    }
+
+    public void setMaxAccessCount_GreaterThan(Long maxAccessCount, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("maxAccessCount", ConditionKey.CK_GREATER_THAN, maxAccessCount);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setMaxAccessCount_LessThan(Long maxAccessCount) {
+        setMaxAccessCount_LessThan(maxAccessCount, null);
+    }
+
+    public void setMaxAccessCount_LessThan(Long maxAccessCount, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("maxAccessCount", ConditionKey.CK_LESS_THAN, maxAccessCount);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setMaxAccessCount_GreaterEqual(Long maxAccessCount) {
+        setMaxAccessCount_GreaterEqual(maxAccessCount, null);
+    }
+
+    public void setMaxAccessCount_GreaterEqual(Long maxAccessCount, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("maxAccessCount", ConditionKey.CK_GREATER_EQUAL, maxAccessCount);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setMaxAccessCount_LessEqual(Long maxAccessCount) {
+        setMaxAccessCount_LessEqual(maxAccessCount, null);
+    }
+
+    public void setMaxAccessCount_LessEqual(Long maxAccessCount, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("maxAccessCount", ConditionKey.CK_LESS_EQUAL, maxAccessCount);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_Term(String name) {
+        setName_Term(name, null);
+    }
+
+    public void setName_Term(String name, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("name", name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_Terms(Collection<String> nameList) {
+        setName_Terms(nameList, null);
+    }
+
+    public void setName_Terms(Collection<String> nameList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("name", nameList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_InScope(Collection<String> nameList) {
+        setName_Terms(nameList, null);
+    }
+
+    public void setName_InScope(Collection<String> nameList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setName_Terms(nameList, opLambda);
+    }
+
+    public void setName_Prefix(String name) {
+        setName_Prefix(name, null);
+    }
+
+    public void setName_Prefix(String name, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("name", name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_Exists() {
+        setName_Exists(null);
+    }
+
+    public void setName_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("name");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_Missing() {
+        setName_Missing(null);
+    }
+
+    public void setName_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("name");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_GreaterThan(String name) {
+        setName_GreaterThan(name, null);
+    }
+
+    public void setName_GreaterThan(String name, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_GREATER_THAN, name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_LessThan(String name) {
+        setName_LessThan(name, null);
+    }
+
+    public void setName_LessThan(String name, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_LESS_THAN, name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_GreaterEqual(String name) {
+        setName_GreaterEqual(name, null);
+    }
+
+    public void setName_GreaterEqual(String name, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_GREATER_EQUAL, name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_LessEqual(String name) {
+        setName_LessEqual(name, null);
+    }
+
+    public void setName_LessEqual(String name, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_LESS_EQUAL, name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setNumOfThread_Term(Integer numOfThread) {
+        setNumOfThread_Term(numOfThread, null);
+    }
+
+    public void setNumOfThread_Term(Integer numOfThread, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("numOfThread", numOfThread);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setNumOfThread_Terms(Collection<Integer> numOfThreadList) {
+        setNumOfThread_Terms(numOfThreadList, null);
+    }
+
+    public void setNumOfThread_Terms(Collection<Integer> numOfThreadList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("numOfThread", numOfThreadList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setNumOfThread_InScope(Collection<Integer> numOfThreadList) {
+        setNumOfThread_Terms(numOfThreadList, null);
+    }
+
+    public void setNumOfThread_InScope(Collection<Integer> numOfThreadList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setNumOfThread_Terms(numOfThreadList, opLambda);
+    }
+
+    public void setNumOfThread_Exists() {
+        setNumOfThread_Exists(null);
+    }
+
+    public void setNumOfThread_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("numOfThread");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setNumOfThread_Missing() {
+        setNumOfThread_Missing(null);
+    }
+
+    public void setNumOfThread_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("numOfThread");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setNumOfThread_GreaterThan(Integer numOfThread) {
+        setNumOfThread_GreaterThan(numOfThread, null);
+    }
+
+    public void setNumOfThread_GreaterThan(Integer numOfThread, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("numOfThread", ConditionKey.CK_GREATER_THAN, numOfThread);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setNumOfThread_LessThan(Integer numOfThread) {
+        setNumOfThread_LessThan(numOfThread, null);
+    }
+
+    public void setNumOfThread_LessThan(Integer numOfThread, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("numOfThread", ConditionKey.CK_LESS_THAN, numOfThread);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setNumOfThread_GreaterEqual(Integer numOfThread) {
+        setNumOfThread_GreaterEqual(numOfThread, null);
+    }
+
+    public void setNumOfThread_GreaterEqual(Integer numOfThread, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("numOfThread", ConditionKey.CK_GREATER_EQUAL, numOfThread);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setNumOfThread_LessEqual(Integer numOfThread) {
+        setNumOfThread_LessEqual(numOfThread, null);
+    }
+
+    public void setNumOfThread_LessEqual(Integer numOfThread, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("numOfThread", ConditionKey.CK_LESS_EQUAL, numOfThread);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setPaths_Term(String paths) {
+        setPaths_Term(paths, null);
+    }
+
+    public void setPaths_Term(String paths, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("paths", paths);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setPaths_Terms(Collection<String> pathsList) {
+        setPaths_Terms(pathsList, null);
+    }
+
+    public void setPaths_Terms(Collection<String> pathsList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("paths", pathsList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setPaths_InScope(Collection<String> pathsList) {
+        setPaths_Terms(pathsList, null);
+    }
+
+    public void setPaths_InScope(Collection<String> pathsList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setPaths_Terms(pathsList, opLambda);
+    }
+
+    public void setPaths_Prefix(String paths) {
+        setPaths_Prefix(paths, null);
+    }
+
+    public void setPaths_Prefix(String paths, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("paths", paths);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setPaths_Exists() {
+        setPaths_Exists(null);
+    }
+
+    public void setPaths_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("paths");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setPaths_Missing() {
+        setPaths_Missing(null);
+    }
+
+    public void setPaths_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("paths");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setPaths_GreaterThan(String paths) {
+        setPaths_GreaterThan(paths, null);
+    }
+
+    public void setPaths_GreaterThan(String paths, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("paths", ConditionKey.CK_GREATER_THAN, paths);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setPaths_LessThan(String paths) {
+        setPaths_LessThan(paths, null);
+    }
+
+    public void setPaths_LessThan(String paths, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("paths", ConditionKey.CK_LESS_THAN, paths);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setPaths_GreaterEqual(String paths) {
+        setPaths_GreaterEqual(paths, null);
+    }
+
+    public void setPaths_GreaterEqual(String paths, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("paths", ConditionKey.CK_GREATER_EQUAL, paths);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setPaths_LessEqual(String paths) {
+        setPaths_LessEqual(paths, null);
+    }
+
+    public void setPaths_LessEqual(String paths, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("paths", ConditionKey.CK_LESS_EQUAL, paths);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_Term(Integer sortOrder) {
+        setSortOrder_Term(sortOrder, null);
+    }
+
+    public void setSortOrder_Term(Integer sortOrder, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("sortOrder", sortOrder);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_Terms(Collection<Integer> sortOrderList) {
+        setSortOrder_Terms(sortOrderList, null);
+    }
+
+    public void setSortOrder_Terms(Collection<Integer> sortOrderList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("sortOrder", sortOrderList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_InScope(Collection<Integer> sortOrderList) {
+        setSortOrder_Terms(sortOrderList, null);
+    }
+
+    public void setSortOrder_InScope(Collection<Integer> sortOrderList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setSortOrder_Terms(sortOrderList, opLambda);
+    }
+
+    public void setSortOrder_Exists() {
+        setSortOrder_Exists(null);
+    }
+
+    public void setSortOrder_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("sortOrder");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_Missing() {
+        setSortOrder_Missing(null);
+    }
+
+    public void setSortOrder_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("sortOrder");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_GreaterThan(Integer sortOrder) {
+        setSortOrder_GreaterThan(sortOrder, null);
+    }
+
+    public void setSortOrder_GreaterThan(Integer sortOrder, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_GREATER_THAN, sortOrder);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_LessThan(Integer sortOrder) {
+        setSortOrder_LessThan(sortOrder, null);
+    }
+
+    public void setSortOrder_LessThan(Integer sortOrder, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_LESS_THAN, sortOrder);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_GreaterEqual(Integer sortOrder) {
+        setSortOrder_GreaterEqual(sortOrder, null);
+    }
+
+    public void setSortOrder_GreaterEqual(Integer sortOrder, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_GREATER_EQUAL, sortOrder);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_LessEqual(Integer sortOrder) {
+        setSortOrder_LessEqual(sortOrder, null);
+    }
+
+    public void setSortOrder_LessEqual(Integer sortOrder, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_LESS_EQUAL, sortOrder);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Term(String updatedBy) {
+        setUpdatedBy_Term(updatedBy, null);
+    }
+
+    public void setUpdatedBy_Term(String updatedBy, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Terms(Collection<String> updatedByList) {
+        setUpdatedBy_Terms(updatedByList, null);
+    }
+
+    public void setUpdatedBy_Terms(Collection<String> updatedByList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("updatedBy", updatedByList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_InScope(Collection<String> updatedByList) {
+        setUpdatedBy_Terms(updatedByList, null);
+    }
+
+    public void setUpdatedBy_InScope(Collection<String> updatedByList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setUpdatedBy_Terms(updatedByList, opLambda);
+    }
+
+    public void setUpdatedBy_Prefix(String updatedBy) {
+        setUpdatedBy_Prefix(updatedBy, null);
+    }
+
+    public void setUpdatedBy_Prefix(String updatedBy, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Exists() {
+        setUpdatedBy_Exists(null);
+    }
+
+    public void setUpdatedBy_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("updatedBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Missing() {
+        setUpdatedBy_Missing(null);
+    }
+
+    public void setUpdatedBy_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("updatedBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_GreaterThan(String updatedBy) {
+        setUpdatedBy_GreaterThan(updatedBy, null);
+    }
+
+    public void setUpdatedBy_GreaterThan(String updatedBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_LessThan(String updatedBy) {
+        setUpdatedBy_LessThan(updatedBy, null);
+    }
+
+    public void setUpdatedBy_LessThan(String updatedBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_GreaterEqual(String updatedBy) {
+        setUpdatedBy_GreaterEqual(updatedBy, null);
+    }
+
+    public void setUpdatedBy_GreaterEqual(String updatedBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_LessEqual(String updatedBy) {
+        setUpdatedBy_LessEqual(updatedBy, null);
+    }
+
+    public void setUpdatedBy_LessEqual(String updatedBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_Term(Long updatedTime) {
+        setUpdatedTime_Term(updatedTime, null);
+    }
+
+    public void setUpdatedTime_Term(Long updatedTime, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("updatedTime", updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_Terms(Collection<Long> updatedTimeList) {
+        setUpdatedTime_Terms(updatedTimeList, null);
+    }
+
+    public void setUpdatedTime_Terms(Collection<Long> updatedTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("updatedTime", updatedTimeList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_InScope(Collection<Long> updatedTimeList) {
+        setUpdatedTime_Terms(updatedTimeList, null);
+    }
+
+    public void setUpdatedTime_InScope(Collection<Long> updatedTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setUpdatedTime_Terms(updatedTimeList, opLambda);
+    }
+
+    public void setUpdatedTime_Exists() {
+        setUpdatedTime_Exists(null);
+    }
+
+    public void setUpdatedTime_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("updatedTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_Missing() {
+        setUpdatedTime_Missing(null);
+    }
+
+    public void setUpdatedTime_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("updatedTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_GreaterThan(Long updatedTime) {
+        setUpdatedTime_GreaterThan(updatedTime, null);
+    }
+
+    public void setUpdatedTime_GreaterThan(Long updatedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_LessThan(Long updatedTime) {
+        setUpdatedTime_LessThan(updatedTime, null);
+    }
+
+    public void setUpdatedTime_LessThan(Long updatedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_GreaterEqual(Long updatedTime) {
+        setUpdatedTime_GreaterEqual(updatedTime, null);
+    }
+
+    public void setUpdatedTime_GreaterEqual(Long updatedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_LessEqual(Long updatedTime) {
+        setUpdatedTime_LessEqual(updatedTime, null);
+    }
+
+    public void setUpdatedTime_LessEqual(Long updatedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+}

src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsFileConfigToLabelCF.java

@@ -0,0 +1,430 @@
+package org.codelibs.fess.es.cbean.cf.bs;
+
+import java.util.Collection;
+
+import org.codelibs.fess.es.cbean.cf.FileConfigToLabelCF;
+import org.codelibs.fess.es.cbean.cq.FileConfigToLabelCQ;
+import org.dbflute.exception.IllegalConditionBeanOperationException;
+import org.dbflute.cbean.ckey.ConditionKey;
+import org.elasticsearch.index.query.AndFilterBuilder;
+import org.elasticsearch.index.query.BoolFilterBuilder;
+import org.elasticsearch.index.query.ExistsFilterBuilder;
+import org.elasticsearch.index.query.MissingFilterBuilder;
+import org.elasticsearch.index.query.NotFilterBuilder;
+import org.elasticsearch.index.query.OrFilterBuilder;
+import org.elasticsearch.index.query.PrefixFilterBuilder;
+import org.elasticsearch.index.query.QueryFilterBuilder;
+import org.elasticsearch.index.query.RangeFilterBuilder;
+import org.elasticsearch.index.query.TermFilterBuilder;
+import org.elasticsearch.index.query.TermsFilterBuilder;
+
+/**
+ * @author FreeGen
+ */
+public abstract class BsFileConfigToLabelCF extends AbstractConditionFilter {
+
+    public void bool(BoolCall<FileConfigToLabelCF> boolLambda) {
+        bool(boolLambda, null);
+    }
+
+    public void bool(BoolCall<FileConfigToLabelCF> boolLambda, ConditionOptionCall<BoolFilterBuilder> opLambda) {
+        FileConfigToLabelCF mustFilter = new FileConfigToLabelCF();
+        FileConfigToLabelCF shouldFilter = new FileConfigToLabelCF();
+        FileConfigToLabelCF mustNotFilter = new FileConfigToLabelCF();
+        boolLambda.callback(mustFilter, shouldFilter, mustNotFilter);
+        if (mustFilter.hasFilters() || shouldFilter.hasFilters() || mustNotFilter.hasFilters()) {
+            BoolFilterBuilder builder =
+                    regBoolF(mustFilter.filterBuilderList, shouldFilter.filterBuilderList, mustNotFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void and(OperatorCall<FileConfigToLabelCF> andLambda) {
+        and(andLambda, null);
+    }
+
+    public void and(OperatorCall<FileConfigToLabelCF> andLambda, ConditionOptionCall<AndFilterBuilder> opLambda) {
+        FileConfigToLabelCF andFilter = new FileConfigToLabelCF();
+        andLambda.callback(andFilter);
+        if (andFilter.hasFilters()) {
+            AndFilterBuilder builder = regAndF(andFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void or(OperatorCall<FileConfigToLabelCF> orLambda) {
+        or(orLambda, null);
+    }
+
+    public void or(OperatorCall<FileConfigToLabelCF> orLambda, ConditionOptionCall<OrFilterBuilder> opLambda) {
+        FileConfigToLabelCF orFilter = new FileConfigToLabelCF();
+        orLambda.callback(orFilter);
+        if (orFilter.hasFilters()) {
+            OrFilterBuilder builder = regOrF(orFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void not(OperatorCall<FileConfigToLabelCF> notLambda) {
+        not(notLambda, null);
+    }
+
+    public void not(OperatorCall<FileConfigToLabelCF> notLambda, ConditionOptionCall<NotFilterBuilder> opLambda) {
+        FileConfigToLabelCF notFilter = new FileConfigToLabelCF();
+        notLambda.callback(notFilter);
+        if (notFilter.hasFilters()) {
+            if (notFilter.filterBuilderList.size() > 1) {
+                final String msg = "not filter must be one filter.";
+                throw new IllegalConditionBeanOperationException(msg);
+            }
+            NotFilterBuilder builder = regNotF(notFilter.filterBuilderList.get(0));
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall<FileConfigToLabelCQ> queryLambda) {
+        query(queryLambda, null);
+    }
+
+    public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall<FileConfigToLabelCQ> queryLambda,
+            ConditionOptionCall<QueryFilterBuilder> opLambda) {
+        FileConfigToLabelCQ query = new FileConfigToLabelCQ();
+        queryLambda.callback(query);
+        if (query.hasQueries()) {
+            QueryFilterBuilder builder = regQueryF(query.getQuery());
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void setFileConfigId_Term(String fileConfigId) {
+        setFileConfigId_Term(fileConfigId, null);
+    }
+
+    public void setFileConfigId_Term(String fileConfigId, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("fileConfigId", fileConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setFileConfigId_Terms(Collection<String> fileConfigIdList) {
+        setFileConfigId_Terms(fileConfigIdList, null);
+    }
+
+    public void setFileConfigId_Terms(Collection<String> fileConfigIdList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("fileConfigId", fileConfigIdList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setFileConfigId_InScope(Collection<String> fileConfigIdList) {
+        setFileConfigId_Terms(fileConfigIdList, null);
+    }
+
+    public void setFileConfigId_InScope(Collection<String> fileConfigIdList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setFileConfigId_Terms(fileConfigIdList, opLambda);
+    }
+
+    public void setFileConfigId_Prefix(String fileConfigId) {
+        setFileConfigId_Prefix(fileConfigId, null);
+    }
+
+    public void setFileConfigId_Prefix(String fileConfigId, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("fileConfigId", fileConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setFileConfigId_Exists() {
+        setFileConfigId_Exists(null);
+    }
+
+    public void setFileConfigId_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("fileConfigId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setFileConfigId_Missing() {
+        setFileConfigId_Missing(null);
+    }
+
+    public void setFileConfigId_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("fileConfigId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setFileConfigId_GreaterThan(String fileConfigId) {
+        setFileConfigId_GreaterThan(fileConfigId, null);
+    }
+
+    public void setFileConfigId_GreaterThan(String fileConfigId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("fileConfigId", ConditionKey.CK_GREATER_THAN, fileConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setFileConfigId_LessThan(String fileConfigId) {
+        setFileConfigId_LessThan(fileConfigId, null);
+    }
+
+    public void setFileConfigId_LessThan(String fileConfigId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("fileConfigId", ConditionKey.CK_LESS_THAN, fileConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setFileConfigId_GreaterEqual(String fileConfigId) {
+        setFileConfigId_GreaterEqual(fileConfigId, null);
+    }
+
+    public void setFileConfigId_GreaterEqual(String fileConfigId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("fileConfigId", ConditionKey.CK_GREATER_EQUAL, fileConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setFileConfigId_LessEqual(String fileConfigId) {
+        setFileConfigId_LessEqual(fileConfigId, null);
+    }
+
+    public void setFileConfigId_LessEqual(String fileConfigId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("fileConfigId", ConditionKey.CK_LESS_EQUAL, fileConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Term(String id) {
+        setId_Term(id, null);
+    }
+
+    public void setId_Term(String id, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("id", id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Terms(Collection<String> idList) {
+        setId_Terms(idList, null);
+    }
+
+    public void setId_Terms(Collection<String> idList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("id", idList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_InScope(Collection<String> idList) {
+        setId_Terms(idList, null);
+    }
+
+    public void setId_InScope(Collection<String> idList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setId_Terms(idList, opLambda);
+    }
+
+    public void setId_Prefix(String id) {
+        setId_Prefix(id, null);
+    }
+
+    public void setId_Prefix(String id, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("id", id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Exists() {
+        setId_Exists(null);
+    }
+
+    public void setId_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("id");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Missing() {
+        setId_Missing(null);
+    }
+
+    public void setId_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("id");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_GreaterThan(String id) {
+        setId_GreaterThan(id, null);
+    }
+
+    public void setId_GreaterThan(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_THAN, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_LessThan(String id) {
+        setId_LessThan(id, null);
+    }
+
+    public void setId_LessThan(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_THAN, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_GreaterEqual(String id) {
+        setId_GreaterEqual(id, null);
+    }
+
+    public void setId_GreaterEqual(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_EQUAL, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_LessEqual(String id) {
+        setId_LessEqual(id, null);
+    }
+
+    public void setId_LessEqual(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_EQUAL, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setLabelTypeId_Term(String labelTypeId) {
+        setLabelTypeId_Term(labelTypeId, null);
+    }
+
+    public void setLabelTypeId_Term(String labelTypeId, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("labelTypeId", labelTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setLabelTypeId_Terms(Collection<String> labelTypeIdList) {
+        setLabelTypeId_Terms(labelTypeIdList, null);
+    }
+
+    public void setLabelTypeId_Terms(Collection<String> labelTypeIdList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("labelTypeId", labelTypeIdList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setLabelTypeId_InScope(Collection<String> labelTypeIdList) {
+        setLabelTypeId_Terms(labelTypeIdList, null);
+    }
+
+    public void setLabelTypeId_InScope(Collection<String> labelTypeIdList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setLabelTypeId_Terms(labelTypeIdList, opLambda);
+    }
+
+    public void setLabelTypeId_Prefix(String labelTypeId) {
+        setLabelTypeId_Prefix(labelTypeId, null);
+    }
+
+    public void setLabelTypeId_Prefix(String labelTypeId, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("labelTypeId", labelTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setLabelTypeId_Exists() {
+        setLabelTypeId_Exists(null);
+    }
+
+    public void setLabelTypeId_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("labelTypeId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setLabelTypeId_Missing() {
+        setLabelTypeId_Missing(null);
+    }
+
+    public void setLabelTypeId_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("labelTypeId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setLabelTypeId_GreaterThan(String labelTypeId) {
+        setLabelTypeId_GreaterThan(labelTypeId, null);
+    }
+
+    public void setLabelTypeId_GreaterThan(String labelTypeId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("labelTypeId", ConditionKey.CK_GREATER_THAN, labelTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setLabelTypeId_LessThan(String labelTypeId) {
+        setLabelTypeId_LessThan(labelTypeId, null);
+    }
+
+    public void setLabelTypeId_LessThan(String labelTypeId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("labelTypeId", ConditionKey.CK_LESS_THAN, labelTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setLabelTypeId_GreaterEqual(String labelTypeId) {
+        setLabelTypeId_GreaterEqual(labelTypeId, null);
+    }
+
+    public void setLabelTypeId_GreaterEqual(String labelTypeId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("labelTypeId", ConditionKey.CK_GREATER_EQUAL, labelTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setLabelTypeId_LessEqual(String labelTypeId) {
+        setLabelTypeId_LessEqual(labelTypeId, null);
+    }
+
+    public void setLabelTypeId_LessEqual(String labelTypeId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("labelTypeId", ConditionKey.CK_LESS_EQUAL, labelTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+}

src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsFileConfigToRoleCF.java

@@ -0,0 +1,430 @@
+package org.codelibs.fess.es.cbean.cf.bs;
+
+import java.util.Collection;
+
+import org.codelibs.fess.es.cbean.cf.FileConfigToRoleCF;
+import org.codelibs.fess.es.cbean.cq.FileConfigToRoleCQ;
+import org.dbflute.exception.IllegalConditionBeanOperationException;
+import org.dbflute.cbean.ckey.ConditionKey;
+import org.elasticsearch.index.query.AndFilterBuilder;
+import org.elasticsearch.index.query.BoolFilterBuilder;
+import org.elasticsearch.index.query.ExistsFilterBuilder;
+import org.elasticsearch.index.query.MissingFilterBuilder;
+import org.elasticsearch.index.query.NotFilterBuilder;
+import org.elasticsearch.index.query.OrFilterBuilder;
+import org.elasticsearch.index.query.PrefixFilterBuilder;
+import org.elasticsearch.index.query.QueryFilterBuilder;
+import org.elasticsearch.index.query.RangeFilterBuilder;
+import org.elasticsearch.index.query.TermFilterBuilder;
+import org.elasticsearch.index.query.TermsFilterBuilder;
+
+/**
+ * @author FreeGen
+ */
+public abstract class BsFileConfigToRoleCF extends AbstractConditionFilter {
+
+    public void bool(BoolCall<FileConfigToRoleCF> boolLambda) {
+        bool(boolLambda, null);
+    }
+
+    public void bool(BoolCall<FileConfigToRoleCF> boolLambda, ConditionOptionCall<BoolFilterBuilder> opLambda) {
+        FileConfigToRoleCF mustFilter = new FileConfigToRoleCF();
+        FileConfigToRoleCF shouldFilter = new FileConfigToRoleCF();
+        FileConfigToRoleCF mustNotFilter = new FileConfigToRoleCF();
+        boolLambda.callback(mustFilter, shouldFilter, mustNotFilter);
+        if (mustFilter.hasFilters() || shouldFilter.hasFilters() || mustNotFilter.hasFilters()) {
+            BoolFilterBuilder builder =
+                    regBoolF(mustFilter.filterBuilderList, shouldFilter.filterBuilderList, mustNotFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void and(OperatorCall<FileConfigToRoleCF> andLambda) {
+        and(andLambda, null);
+    }
+
+    public void and(OperatorCall<FileConfigToRoleCF> andLambda, ConditionOptionCall<AndFilterBuilder> opLambda) {
+        FileConfigToRoleCF andFilter = new FileConfigToRoleCF();
+        andLambda.callback(andFilter);
+        if (andFilter.hasFilters()) {
+            AndFilterBuilder builder = regAndF(andFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void or(OperatorCall<FileConfigToRoleCF> orLambda) {
+        or(orLambda, null);
+    }
+
+    public void or(OperatorCall<FileConfigToRoleCF> orLambda, ConditionOptionCall<OrFilterBuilder> opLambda) {
+        FileConfigToRoleCF orFilter = new FileConfigToRoleCF();
+        orLambda.callback(orFilter);
+        if (orFilter.hasFilters()) {
+            OrFilterBuilder builder = regOrF(orFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void not(OperatorCall<FileConfigToRoleCF> notLambda) {
+        not(notLambda, null);
+    }
+
+    public void not(OperatorCall<FileConfigToRoleCF> notLambda, ConditionOptionCall<NotFilterBuilder> opLambda) {
+        FileConfigToRoleCF notFilter = new FileConfigToRoleCF();
+        notLambda.callback(notFilter);
+        if (notFilter.hasFilters()) {
+            if (notFilter.filterBuilderList.size() > 1) {
+                final String msg = "not filter must be one filter.";
+                throw new IllegalConditionBeanOperationException(msg);
+            }
+            NotFilterBuilder builder = regNotF(notFilter.filterBuilderList.get(0));
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall<FileConfigToRoleCQ> queryLambda) {
+        query(queryLambda, null);
+    }
+
+    public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall<FileConfigToRoleCQ> queryLambda,
+            ConditionOptionCall<QueryFilterBuilder> opLambda) {
+        FileConfigToRoleCQ query = new FileConfigToRoleCQ();
+        queryLambda.callback(query);
+        if (query.hasQueries()) {
+            QueryFilterBuilder builder = regQueryF(query.getQuery());
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void setFileConfigId_Term(String fileConfigId) {
+        setFileConfigId_Term(fileConfigId, null);
+    }
+
+    public void setFileConfigId_Term(String fileConfigId, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("fileConfigId", fileConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setFileConfigId_Terms(Collection<String> fileConfigIdList) {
+        setFileConfigId_Terms(fileConfigIdList, null);
+    }
+
+    public void setFileConfigId_Terms(Collection<String> fileConfigIdList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("fileConfigId", fileConfigIdList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setFileConfigId_InScope(Collection<String> fileConfigIdList) {
+        setFileConfigId_Terms(fileConfigIdList, null);
+    }
+
+    public void setFileConfigId_InScope(Collection<String> fileConfigIdList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setFileConfigId_Terms(fileConfigIdList, opLambda);
+    }
+
+    public void setFileConfigId_Prefix(String fileConfigId) {
+        setFileConfigId_Prefix(fileConfigId, null);
+    }
+
+    public void setFileConfigId_Prefix(String fileConfigId, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("fileConfigId", fileConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setFileConfigId_Exists() {
+        setFileConfigId_Exists(null);
+    }
+
+    public void setFileConfigId_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("fileConfigId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setFileConfigId_Missing() {
+        setFileConfigId_Missing(null);
+    }
+
+    public void setFileConfigId_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("fileConfigId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setFileConfigId_GreaterThan(String fileConfigId) {
+        setFileConfigId_GreaterThan(fileConfigId, null);
+    }
+
+    public void setFileConfigId_GreaterThan(String fileConfigId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("fileConfigId", ConditionKey.CK_GREATER_THAN, fileConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setFileConfigId_LessThan(String fileConfigId) {
+        setFileConfigId_LessThan(fileConfigId, null);
+    }
+
+    public void setFileConfigId_LessThan(String fileConfigId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("fileConfigId", ConditionKey.CK_LESS_THAN, fileConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setFileConfigId_GreaterEqual(String fileConfigId) {
+        setFileConfigId_GreaterEqual(fileConfigId, null);
+    }
+
+    public void setFileConfigId_GreaterEqual(String fileConfigId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("fileConfigId", ConditionKey.CK_GREATER_EQUAL, fileConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setFileConfigId_LessEqual(String fileConfigId) {
+        setFileConfigId_LessEqual(fileConfigId, null);
+    }
+
+    public void setFileConfigId_LessEqual(String fileConfigId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("fileConfigId", ConditionKey.CK_LESS_EQUAL, fileConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Term(String id) {
+        setId_Term(id, null);
+    }
+
+    public void setId_Term(String id, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("id", id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Terms(Collection<String> idList) {
+        setId_Terms(idList, null);
+    }
+
+    public void setId_Terms(Collection<String> idList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("id", idList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_InScope(Collection<String> idList) {
+        setId_Terms(idList, null);
+    }
+
+    public void setId_InScope(Collection<String> idList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setId_Terms(idList, opLambda);
+    }
+
+    public void setId_Prefix(String id) {
+        setId_Prefix(id, null);
+    }
+
+    public void setId_Prefix(String id, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("id", id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Exists() {
+        setId_Exists(null);
+    }
+
+    public void setId_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("id");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Missing() {
+        setId_Missing(null);
+    }
+
+    public void setId_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("id");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_GreaterThan(String id) {
+        setId_GreaterThan(id, null);
+    }
+
+    public void setId_GreaterThan(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_THAN, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_LessThan(String id) {
+        setId_LessThan(id, null);
+    }
+
+    public void setId_LessThan(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_THAN, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_GreaterEqual(String id) {
+        setId_GreaterEqual(id, null);
+    }
+
+    public void setId_GreaterEqual(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_EQUAL, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_LessEqual(String id) {
+        setId_LessEqual(id, null);
+    }
+
+    public void setId_LessEqual(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_EQUAL, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRoleTypeId_Term(String roleTypeId) {
+        setRoleTypeId_Term(roleTypeId, null);
+    }
+
+    public void setRoleTypeId_Term(String roleTypeId, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("roleTypeId", roleTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRoleTypeId_Terms(Collection<String> roleTypeIdList) {
+        setRoleTypeId_Terms(roleTypeIdList, null);
+    }
+
+    public void setRoleTypeId_Terms(Collection<String> roleTypeIdList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("roleTypeId", roleTypeIdList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRoleTypeId_InScope(Collection<String> roleTypeIdList) {
+        setRoleTypeId_Terms(roleTypeIdList, null);
+    }
+
+    public void setRoleTypeId_InScope(Collection<String> roleTypeIdList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setRoleTypeId_Terms(roleTypeIdList, opLambda);
+    }
+
+    public void setRoleTypeId_Prefix(String roleTypeId) {
+        setRoleTypeId_Prefix(roleTypeId, null);
+    }
+
+    public void setRoleTypeId_Prefix(String roleTypeId, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("roleTypeId", roleTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRoleTypeId_Exists() {
+        setRoleTypeId_Exists(null);
+    }
+
+    public void setRoleTypeId_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("roleTypeId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRoleTypeId_Missing() {
+        setRoleTypeId_Missing(null);
+    }
+
+    public void setRoleTypeId_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("roleTypeId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRoleTypeId_GreaterThan(String roleTypeId) {
+        setRoleTypeId_GreaterThan(roleTypeId, null);
+    }
+
+    public void setRoleTypeId_GreaterThan(String roleTypeId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("roleTypeId", ConditionKey.CK_GREATER_THAN, roleTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRoleTypeId_LessThan(String roleTypeId) {
+        setRoleTypeId_LessThan(roleTypeId, null);
+    }
+
+    public void setRoleTypeId_LessThan(String roleTypeId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("roleTypeId", ConditionKey.CK_LESS_THAN, roleTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRoleTypeId_GreaterEqual(String roleTypeId) {
+        setRoleTypeId_GreaterEqual(roleTypeId, null);
+    }
+
+    public void setRoleTypeId_GreaterEqual(String roleTypeId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("roleTypeId", ConditionKey.CK_GREATER_EQUAL, roleTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRoleTypeId_LessEqual(String roleTypeId) {
+        setRoleTypeId_LessEqual(roleTypeId, null);
+    }
+
+    public void setRoleTypeId_LessEqual(String roleTypeId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("roleTypeId", ConditionKey.CK_LESS_EQUAL, roleTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+}

src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsJobLogCF.java

@@ -0,0 +1,1050 @@
+package org.codelibs.fess.es.cbean.cf.bs;
+
+import java.util.Collection;
+
+import org.codelibs.fess.es.cbean.cf.JobLogCF;
+import org.codelibs.fess.es.cbean.cq.JobLogCQ;
+import org.dbflute.exception.IllegalConditionBeanOperationException;
+import org.dbflute.cbean.ckey.ConditionKey;
+import org.elasticsearch.index.query.AndFilterBuilder;
+import org.elasticsearch.index.query.BoolFilterBuilder;
+import org.elasticsearch.index.query.ExistsFilterBuilder;
+import org.elasticsearch.index.query.MissingFilterBuilder;
+import org.elasticsearch.index.query.NotFilterBuilder;
+import org.elasticsearch.index.query.OrFilterBuilder;
+import org.elasticsearch.index.query.PrefixFilterBuilder;
+import org.elasticsearch.index.query.QueryFilterBuilder;
+import org.elasticsearch.index.query.RangeFilterBuilder;
+import org.elasticsearch.index.query.TermFilterBuilder;
+import org.elasticsearch.index.query.TermsFilterBuilder;
+
+/**
+ * @author FreeGen
+ */
+public abstract class BsJobLogCF extends AbstractConditionFilter {
+
+    public void bool(BoolCall<JobLogCF> boolLambda) {
+        bool(boolLambda, null);
+    }
+
+    public void bool(BoolCall<JobLogCF> boolLambda, ConditionOptionCall<BoolFilterBuilder> opLambda) {
+        JobLogCF mustFilter = new JobLogCF();
+        JobLogCF shouldFilter = new JobLogCF();
+        JobLogCF mustNotFilter = new JobLogCF();
+        boolLambda.callback(mustFilter, shouldFilter, mustNotFilter);
+        if (mustFilter.hasFilters() || shouldFilter.hasFilters() || mustNotFilter.hasFilters()) {
+            BoolFilterBuilder builder =
+                    regBoolF(mustFilter.filterBuilderList, shouldFilter.filterBuilderList, mustNotFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void and(OperatorCall<JobLogCF> andLambda) {
+        and(andLambda, null);
+    }
+
+    public void and(OperatorCall<JobLogCF> andLambda, ConditionOptionCall<AndFilterBuilder> opLambda) {
+        JobLogCF andFilter = new JobLogCF();
+        andLambda.callback(andFilter);
+        if (andFilter.hasFilters()) {
+            AndFilterBuilder builder = regAndF(andFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void or(OperatorCall<JobLogCF> orLambda) {
+        or(orLambda, null);
+    }
+
+    public void or(OperatorCall<JobLogCF> orLambda, ConditionOptionCall<OrFilterBuilder> opLambda) {
+        JobLogCF orFilter = new JobLogCF();
+        orLambda.callback(orFilter);
+        if (orFilter.hasFilters()) {
+            OrFilterBuilder builder = regOrF(orFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void not(OperatorCall<JobLogCF> notLambda) {
+        not(notLambda, null);
+    }
+
+    public void not(OperatorCall<JobLogCF> notLambda, ConditionOptionCall<NotFilterBuilder> opLambda) {
+        JobLogCF notFilter = new JobLogCF();
+        notLambda.callback(notFilter);
+        if (notFilter.hasFilters()) {
+            if (notFilter.filterBuilderList.size() > 1) {
+                final String msg = "not filter must be one filter.";
+                throw new IllegalConditionBeanOperationException(msg);
+            }
+            NotFilterBuilder builder = regNotF(notFilter.filterBuilderList.get(0));
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall<JobLogCQ> queryLambda) {
+        query(queryLambda, null);
+    }
+
+    public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall<JobLogCQ> queryLambda,
+            ConditionOptionCall<QueryFilterBuilder> opLambda) {
+        JobLogCQ query = new JobLogCQ();
+        queryLambda.callback(query);
+        if (query.hasQueries()) {
+            QueryFilterBuilder builder = regQueryF(query.getQuery());
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void setEndTime_Term(Long endTime) {
+        setEndTime_Term(endTime, null);
+    }
+
+    public void setEndTime_Term(Long endTime, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("endTime", endTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setEndTime_Terms(Collection<Long> endTimeList) {
+        setEndTime_Terms(endTimeList, null);
+    }
+
+    public void setEndTime_Terms(Collection<Long> endTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("endTime", endTimeList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setEndTime_InScope(Collection<Long> endTimeList) {
+        setEndTime_Terms(endTimeList, null);
+    }
+
+    public void setEndTime_InScope(Collection<Long> endTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setEndTime_Terms(endTimeList, opLambda);
+    }
+
+    public void setEndTime_Exists() {
+        setEndTime_Exists(null);
+    }
+
+    public void setEndTime_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("endTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setEndTime_Missing() {
+        setEndTime_Missing(null);
+    }
+
+    public void setEndTime_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("endTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setEndTime_GreaterThan(Long endTime) {
+        setEndTime_GreaterThan(endTime, null);
+    }
+
+    public void setEndTime_GreaterThan(Long endTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("endTime", ConditionKey.CK_GREATER_THAN, endTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setEndTime_LessThan(Long endTime) {
+        setEndTime_LessThan(endTime, null);
+    }
+
+    public void setEndTime_LessThan(Long endTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("endTime", ConditionKey.CK_LESS_THAN, endTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setEndTime_GreaterEqual(Long endTime) {
+        setEndTime_GreaterEqual(endTime, null);
+    }
+
+    public void setEndTime_GreaterEqual(Long endTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("endTime", ConditionKey.CK_GREATER_EQUAL, endTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setEndTime_LessEqual(Long endTime) {
+        setEndTime_LessEqual(endTime, null);
+    }
+
+    public void setEndTime_LessEqual(Long endTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("endTime", ConditionKey.CK_LESS_EQUAL, endTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Term(String id) {
+        setId_Term(id, null);
+    }
+
+    public void setId_Term(String id, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("id", id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Terms(Collection<String> idList) {
+        setId_Terms(idList, null);
+    }
+
+    public void setId_Terms(Collection<String> idList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("id", idList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_InScope(Collection<String> idList) {
+        setId_Terms(idList, null);
+    }
+
+    public void setId_InScope(Collection<String> idList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setId_Terms(idList, opLambda);
+    }
+
+    public void setId_Prefix(String id) {
+        setId_Prefix(id, null);
+    }
+
+    public void setId_Prefix(String id, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("id", id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Exists() {
+        setId_Exists(null);
+    }
+
+    public void setId_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("id");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Missing() {
+        setId_Missing(null);
+    }
+
+    public void setId_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("id");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_GreaterThan(String id) {
+        setId_GreaterThan(id, null);
+    }
+
+    public void setId_GreaterThan(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_THAN, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_LessThan(String id) {
+        setId_LessThan(id, null);
+    }
+
+    public void setId_LessThan(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_THAN, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_GreaterEqual(String id) {
+        setId_GreaterEqual(id, null);
+    }
+
+    public void setId_GreaterEqual(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_EQUAL, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_LessEqual(String id) {
+        setId_LessEqual(id, null);
+    }
+
+    public void setId_LessEqual(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_EQUAL, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setJobName_Term(String jobName) {
+        setJobName_Term(jobName, null);
+    }
+
+    public void setJobName_Term(String jobName, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("jobName", jobName);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setJobName_Terms(Collection<String> jobNameList) {
+        setJobName_Terms(jobNameList, null);
+    }
+
+    public void setJobName_Terms(Collection<String> jobNameList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("jobName", jobNameList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setJobName_InScope(Collection<String> jobNameList) {
+        setJobName_Terms(jobNameList, null);
+    }
+
+    public void setJobName_InScope(Collection<String> jobNameList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setJobName_Terms(jobNameList, opLambda);
+    }
+
+    public void setJobName_Prefix(String jobName) {
+        setJobName_Prefix(jobName, null);
+    }
+
+    public void setJobName_Prefix(String jobName, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("jobName", jobName);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setJobName_Exists() {
+        setJobName_Exists(null);
+    }
+
+    public void setJobName_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("jobName");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setJobName_Missing() {
+        setJobName_Missing(null);
+    }
+
+    public void setJobName_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("jobName");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setJobName_GreaterThan(String jobName) {
+        setJobName_GreaterThan(jobName, null);
+    }
+
+    public void setJobName_GreaterThan(String jobName, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("jobName", ConditionKey.CK_GREATER_THAN, jobName);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setJobName_LessThan(String jobName) {
+        setJobName_LessThan(jobName, null);
+    }
+
+    public void setJobName_LessThan(String jobName, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("jobName", ConditionKey.CK_LESS_THAN, jobName);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setJobName_GreaterEqual(String jobName) {
+        setJobName_GreaterEqual(jobName, null);
+    }
+
+    public void setJobName_GreaterEqual(String jobName, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("jobName", ConditionKey.CK_GREATER_EQUAL, jobName);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setJobName_LessEqual(String jobName) {
+        setJobName_LessEqual(jobName, null);
+    }
+
+    public void setJobName_LessEqual(String jobName, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("jobName", ConditionKey.CK_LESS_EQUAL, jobName);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setJobStatus_Term(String jobStatus) {
+        setJobStatus_Term(jobStatus, null);
+    }
+
+    public void setJobStatus_Term(String jobStatus, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("jobStatus", jobStatus);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setJobStatus_Terms(Collection<String> jobStatusList) {
+        setJobStatus_Terms(jobStatusList, null);
+    }
+
+    public void setJobStatus_Terms(Collection<String> jobStatusList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("jobStatus", jobStatusList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setJobStatus_InScope(Collection<String> jobStatusList) {
+        setJobStatus_Terms(jobStatusList, null);
+    }
+
+    public void setJobStatus_InScope(Collection<String> jobStatusList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setJobStatus_Terms(jobStatusList, opLambda);
+    }
+
+    public void setJobStatus_Prefix(String jobStatus) {
+        setJobStatus_Prefix(jobStatus, null);
+    }
+
+    public void setJobStatus_Prefix(String jobStatus, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("jobStatus", jobStatus);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setJobStatus_Exists() {
+        setJobStatus_Exists(null);
+    }
+
+    public void setJobStatus_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("jobStatus");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setJobStatus_Missing() {
+        setJobStatus_Missing(null);
+    }
+
+    public void setJobStatus_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("jobStatus");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setJobStatus_GreaterThan(String jobStatus) {
+        setJobStatus_GreaterThan(jobStatus, null);
+    }
+
+    public void setJobStatus_GreaterThan(String jobStatus, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("jobStatus", ConditionKey.CK_GREATER_THAN, jobStatus);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setJobStatus_LessThan(String jobStatus) {
+        setJobStatus_LessThan(jobStatus, null);
+    }
+
+    public void setJobStatus_LessThan(String jobStatus, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("jobStatus", ConditionKey.CK_LESS_THAN, jobStatus);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setJobStatus_GreaterEqual(String jobStatus) {
+        setJobStatus_GreaterEqual(jobStatus, null);
+    }
+
+    public void setJobStatus_GreaterEqual(String jobStatus, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("jobStatus", ConditionKey.CK_GREATER_EQUAL, jobStatus);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setJobStatus_LessEqual(String jobStatus) {
+        setJobStatus_LessEqual(jobStatus, null);
+    }
+
+    public void setJobStatus_LessEqual(String jobStatus, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("jobStatus", ConditionKey.CK_LESS_EQUAL, jobStatus);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setScriptData_Term(String scriptData) {
+        setScriptData_Term(scriptData, null);
+    }
+
+    public void setScriptData_Term(String scriptData, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("scriptData", scriptData);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setScriptData_Terms(Collection<String> scriptDataList) {
+        setScriptData_Terms(scriptDataList, null);
+    }
+
+    public void setScriptData_Terms(Collection<String> scriptDataList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("scriptData", scriptDataList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setScriptData_InScope(Collection<String> scriptDataList) {
+        setScriptData_Terms(scriptDataList, null);
+    }
+
+    public void setScriptData_InScope(Collection<String> scriptDataList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setScriptData_Terms(scriptDataList, opLambda);
+    }
+
+    public void setScriptData_Prefix(String scriptData) {
+        setScriptData_Prefix(scriptData, null);
+    }
+
+    public void setScriptData_Prefix(String scriptData, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("scriptData", scriptData);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setScriptData_Exists() {
+        setScriptData_Exists(null);
+    }
+
+    public void setScriptData_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("scriptData");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setScriptData_Missing() {
+        setScriptData_Missing(null);
+    }
+
+    public void setScriptData_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("scriptData");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setScriptData_GreaterThan(String scriptData) {
+        setScriptData_GreaterThan(scriptData, null);
+    }
+
+    public void setScriptData_GreaterThan(String scriptData, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("scriptData", ConditionKey.CK_GREATER_THAN, scriptData);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setScriptData_LessThan(String scriptData) {
+        setScriptData_LessThan(scriptData, null);
+    }
+
+    public void setScriptData_LessThan(String scriptData, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("scriptData", ConditionKey.CK_LESS_THAN, scriptData);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setScriptData_GreaterEqual(String scriptData) {
+        setScriptData_GreaterEqual(scriptData, null);
+    }
+
+    public void setScriptData_GreaterEqual(String scriptData, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("scriptData", ConditionKey.CK_GREATER_EQUAL, scriptData);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setScriptData_LessEqual(String scriptData) {
+        setScriptData_LessEqual(scriptData, null);
+    }
+
+    public void setScriptData_LessEqual(String scriptData, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("scriptData", ConditionKey.CK_LESS_EQUAL, scriptData);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setScriptResult_Term(String scriptResult) {
+        setScriptResult_Term(scriptResult, null);
+    }
+
+    public void setScriptResult_Term(String scriptResult, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("scriptResult", scriptResult);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setScriptResult_Terms(Collection<String> scriptResultList) {
+        setScriptResult_Terms(scriptResultList, null);
+    }
+
+    public void setScriptResult_Terms(Collection<String> scriptResultList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("scriptResult", scriptResultList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setScriptResult_InScope(Collection<String> scriptResultList) {
+        setScriptResult_Terms(scriptResultList, null);
+    }
+
+    public void setScriptResult_InScope(Collection<String> scriptResultList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setScriptResult_Terms(scriptResultList, opLambda);
+    }
+
+    public void setScriptResult_Prefix(String scriptResult) {
+        setScriptResult_Prefix(scriptResult, null);
+    }
+
+    public void setScriptResult_Prefix(String scriptResult, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("scriptResult", scriptResult);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setScriptResult_Exists() {
+        setScriptResult_Exists(null);
+    }
+
+    public void setScriptResult_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("scriptResult");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setScriptResult_Missing() {
+        setScriptResult_Missing(null);
+    }
+
+    public void setScriptResult_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("scriptResult");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setScriptResult_GreaterThan(String scriptResult) {
+        setScriptResult_GreaterThan(scriptResult, null);
+    }
+
+    public void setScriptResult_GreaterThan(String scriptResult, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("scriptResult", ConditionKey.CK_GREATER_THAN, scriptResult);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setScriptResult_LessThan(String scriptResult) {
+        setScriptResult_LessThan(scriptResult, null);
+    }
+
+    public void setScriptResult_LessThan(String scriptResult, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("scriptResult", ConditionKey.CK_LESS_THAN, scriptResult);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setScriptResult_GreaterEqual(String scriptResult) {
+        setScriptResult_GreaterEqual(scriptResult, null);
+    }
+
+    public void setScriptResult_GreaterEqual(String scriptResult, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("scriptResult", ConditionKey.CK_GREATER_EQUAL, scriptResult);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setScriptResult_LessEqual(String scriptResult) {
+        setScriptResult_LessEqual(scriptResult, null);
+    }
+
+    public void setScriptResult_LessEqual(String scriptResult, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("scriptResult", ConditionKey.CK_LESS_EQUAL, scriptResult);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setScriptType_Term(String scriptType) {
+        setScriptType_Term(scriptType, null);
+    }
+
+    public void setScriptType_Term(String scriptType, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("scriptType", scriptType);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setScriptType_Terms(Collection<String> scriptTypeList) {
+        setScriptType_Terms(scriptTypeList, null);
+    }
+
+    public void setScriptType_Terms(Collection<String> scriptTypeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("scriptType", scriptTypeList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setScriptType_InScope(Collection<String> scriptTypeList) {
+        setScriptType_Terms(scriptTypeList, null);
+    }
+
+    public void setScriptType_InScope(Collection<String> scriptTypeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setScriptType_Terms(scriptTypeList, opLambda);
+    }
+
+    public void setScriptType_Prefix(String scriptType) {
+        setScriptType_Prefix(scriptType, null);
+    }
+
+    public void setScriptType_Prefix(String scriptType, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("scriptType", scriptType);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setScriptType_Exists() {
+        setScriptType_Exists(null);
+    }
+
+    public void setScriptType_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("scriptType");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setScriptType_Missing() {
+        setScriptType_Missing(null);
+    }
+
+    public void setScriptType_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("scriptType");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setScriptType_GreaterThan(String scriptType) {
+        setScriptType_GreaterThan(scriptType, null);
+    }
+
+    public void setScriptType_GreaterThan(String scriptType, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("scriptType", ConditionKey.CK_GREATER_THAN, scriptType);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setScriptType_LessThan(String scriptType) {
+        setScriptType_LessThan(scriptType, null);
+    }
+
+    public void setScriptType_LessThan(String scriptType, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("scriptType", ConditionKey.CK_LESS_THAN, scriptType);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setScriptType_GreaterEqual(String scriptType) {
+        setScriptType_GreaterEqual(scriptType, null);
+    }
+
+    public void setScriptType_GreaterEqual(String scriptType, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("scriptType", ConditionKey.CK_GREATER_EQUAL, scriptType);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setScriptType_LessEqual(String scriptType) {
+        setScriptType_LessEqual(scriptType, null);
+    }
+
+    public void setScriptType_LessEqual(String scriptType, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("scriptType", ConditionKey.CK_LESS_EQUAL, scriptType);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setStartTime_Term(Long startTime) {
+        setStartTime_Term(startTime, null);
+    }
+
+    public void setStartTime_Term(Long startTime, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("startTime", startTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setStartTime_Terms(Collection<Long> startTimeList) {
+        setStartTime_Terms(startTimeList, null);
+    }
+
+    public void setStartTime_Terms(Collection<Long> startTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("startTime", startTimeList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setStartTime_InScope(Collection<Long> startTimeList) {
+        setStartTime_Terms(startTimeList, null);
+    }
+
+    public void setStartTime_InScope(Collection<Long> startTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setStartTime_Terms(startTimeList, opLambda);
+    }
+
+    public void setStartTime_Exists() {
+        setStartTime_Exists(null);
+    }
+
+    public void setStartTime_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("startTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setStartTime_Missing() {
+        setStartTime_Missing(null);
+    }
+
+    public void setStartTime_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("startTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setStartTime_GreaterThan(Long startTime) {
+        setStartTime_GreaterThan(startTime, null);
+    }
+
+    public void setStartTime_GreaterThan(Long startTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("startTime", ConditionKey.CK_GREATER_THAN, startTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setStartTime_LessThan(Long startTime) {
+        setStartTime_LessThan(startTime, null);
+    }
+
+    public void setStartTime_LessThan(Long startTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("startTime", ConditionKey.CK_LESS_THAN, startTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setStartTime_GreaterEqual(Long startTime) {
+        setStartTime_GreaterEqual(startTime, null);
+    }
+
+    public void setStartTime_GreaterEqual(Long startTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("startTime", ConditionKey.CK_GREATER_EQUAL, startTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setStartTime_LessEqual(Long startTime) {
+        setStartTime_LessEqual(startTime, null);
+    }
+
+    public void setStartTime_LessEqual(Long startTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("startTime", ConditionKey.CK_LESS_EQUAL, startTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTarget_Term(String target) {
+        setTarget_Term(target, null);
+    }
+
+    public void setTarget_Term(String target, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("target", target);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTarget_Terms(Collection<String> targetList) {
+        setTarget_Terms(targetList, null);
+    }
+
+    public void setTarget_Terms(Collection<String> targetList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("target", targetList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTarget_InScope(Collection<String> targetList) {
+        setTarget_Terms(targetList, null);
+    }
+
+    public void setTarget_InScope(Collection<String> targetList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setTarget_Terms(targetList, opLambda);
+    }
+
+    public void setTarget_Prefix(String target) {
+        setTarget_Prefix(target, null);
+    }
+
+    public void setTarget_Prefix(String target, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("target", target);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTarget_Exists() {
+        setTarget_Exists(null);
+    }
+
+    public void setTarget_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("target");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTarget_Missing() {
+        setTarget_Missing(null);
+    }
+
+    public void setTarget_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("target");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTarget_GreaterThan(String target) {
+        setTarget_GreaterThan(target, null);
+    }
+
+    public void setTarget_GreaterThan(String target, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("target", ConditionKey.CK_GREATER_THAN, target);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTarget_LessThan(String target) {
+        setTarget_LessThan(target, null);
+    }
+
+    public void setTarget_LessThan(String target, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("target", ConditionKey.CK_LESS_THAN, target);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTarget_GreaterEqual(String target) {
+        setTarget_GreaterEqual(target, null);
+    }
+
+    public void setTarget_GreaterEqual(String target, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("target", ConditionKey.CK_GREATER_EQUAL, target);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTarget_LessEqual(String target) {
+        setTarget_LessEqual(target, null);
+    }
+
+    public void setTarget_LessEqual(String target, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("target", ConditionKey.CK_LESS_EQUAL, target);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+}

src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsKeyMatchCF.java

@@ -0,0 +1,1028 @@
+package org.codelibs.fess.es.cbean.cf.bs;
+
+import java.util.Collection;
+
+import org.codelibs.fess.es.cbean.cf.KeyMatchCF;
+import org.codelibs.fess.es.cbean.cq.KeyMatchCQ;
+import org.dbflute.exception.IllegalConditionBeanOperationException;
+import org.dbflute.cbean.ckey.ConditionKey;
+import org.elasticsearch.index.query.AndFilterBuilder;
+import org.elasticsearch.index.query.BoolFilterBuilder;
+import org.elasticsearch.index.query.ExistsFilterBuilder;
+import org.elasticsearch.index.query.MissingFilterBuilder;
+import org.elasticsearch.index.query.NotFilterBuilder;
+import org.elasticsearch.index.query.OrFilterBuilder;
+import org.elasticsearch.index.query.PrefixFilterBuilder;
+import org.elasticsearch.index.query.QueryFilterBuilder;
+import org.elasticsearch.index.query.RangeFilterBuilder;
+import org.elasticsearch.index.query.TermFilterBuilder;
+import org.elasticsearch.index.query.TermsFilterBuilder;
+
+/**
+ * @author FreeGen
+ */
+public abstract class BsKeyMatchCF extends AbstractConditionFilter {
+
+    public void bool(BoolCall<KeyMatchCF> boolLambda) {
+        bool(boolLambda, null);
+    }
+
+    public void bool(BoolCall<KeyMatchCF> boolLambda, ConditionOptionCall<BoolFilterBuilder> opLambda) {
+        KeyMatchCF mustFilter = new KeyMatchCF();
+        KeyMatchCF shouldFilter = new KeyMatchCF();
+        KeyMatchCF mustNotFilter = new KeyMatchCF();
+        boolLambda.callback(mustFilter, shouldFilter, mustNotFilter);
+        if (mustFilter.hasFilters() || shouldFilter.hasFilters() || mustNotFilter.hasFilters()) {
+            BoolFilterBuilder builder =
+                    regBoolF(mustFilter.filterBuilderList, shouldFilter.filterBuilderList, mustNotFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void and(OperatorCall<KeyMatchCF> andLambda) {
+        and(andLambda, null);
+    }
+
+    public void and(OperatorCall<KeyMatchCF> andLambda, ConditionOptionCall<AndFilterBuilder> opLambda) {
+        KeyMatchCF andFilter = new KeyMatchCF();
+        andLambda.callback(andFilter);
+        if (andFilter.hasFilters()) {
+            AndFilterBuilder builder = regAndF(andFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void or(OperatorCall<KeyMatchCF> orLambda) {
+        or(orLambda, null);
+    }
+
+    public void or(OperatorCall<KeyMatchCF> orLambda, ConditionOptionCall<OrFilterBuilder> opLambda) {
+        KeyMatchCF orFilter = new KeyMatchCF();
+        orLambda.callback(orFilter);
+        if (orFilter.hasFilters()) {
+            OrFilterBuilder builder = regOrF(orFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void not(OperatorCall<KeyMatchCF> notLambda) {
+        not(notLambda, null);
+    }
+
+    public void not(OperatorCall<KeyMatchCF> notLambda, ConditionOptionCall<NotFilterBuilder> opLambda) {
+        KeyMatchCF notFilter = new KeyMatchCF();
+        notLambda.callback(notFilter);
+        if (notFilter.hasFilters()) {
+            if (notFilter.filterBuilderList.size() > 1) {
+                final String msg = "not filter must be one filter.";
+                throw new IllegalConditionBeanOperationException(msg);
+            }
+            NotFilterBuilder builder = regNotF(notFilter.filterBuilderList.get(0));
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall<KeyMatchCQ> queryLambda) {
+        query(queryLambda, null);
+    }
+
+    public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall<KeyMatchCQ> queryLambda,
+            ConditionOptionCall<QueryFilterBuilder> opLambda) {
+        KeyMatchCQ query = new KeyMatchCQ();
+        queryLambda.callback(query);
+        if (query.hasQueries()) {
+            QueryFilterBuilder builder = regQueryF(query.getQuery());
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void setBoost_Term(Float boost) {
+        setBoost_Term(boost, null);
+    }
+
+    public void setBoost_Term(Float boost, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("boost", boost);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setBoost_Terms(Collection<Float> boostList) {
+        setBoost_Terms(boostList, null);
+    }
+
+    public void setBoost_Terms(Collection<Float> boostList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("boost", boostList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setBoost_InScope(Collection<Float> boostList) {
+        setBoost_Terms(boostList, null);
+    }
+
+    public void setBoost_InScope(Collection<Float> boostList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setBoost_Terms(boostList, opLambda);
+    }
+
+    public void setBoost_Exists() {
+        setBoost_Exists(null);
+    }
+
+    public void setBoost_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("boost");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setBoost_Missing() {
+        setBoost_Missing(null);
+    }
+
+    public void setBoost_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("boost");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setBoost_GreaterThan(Float boost) {
+        setBoost_GreaterThan(boost, null);
+    }
+
+    public void setBoost_GreaterThan(Float boost, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("boost", ConditionKey.CK_GREATER_THAN, boost);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setBoost_LessThan(Float boost) {
+        setBoost_LessThan(boost, null);
+    }
+
+    public void setBoost_LessThan(Float boost, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("boost", ConditionKey.CK_LESS_THAN, boost);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setBoost_GreaterEqual(Float boost) {
+        setBoost_GreaterEqual(boost, null);
+    }
+
+    public void setBoost_GreaterEqual(Float boost, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("boost", ConditionKey.CK_GREATER_EQUAL, boost);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setBoost_LessEqual(Float boost) {
+        setBoost_LessEqual(boost, null);
+    }
+
+    public void setBoost_LessEqual(Float boost, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("boost", ConditionKey.CK_LESS_EQUAL, boost);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_Term(String createdBy) {
+        setCreatedBy_Term(createdBy, null);
+    }
+
+    public void setCreatedBy_Term(String createdBy, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_Terms(Collection<String> createdByList) {
+        setCreatedBy_Terms(createdByList, null);
+    }
+
+    public void setCreatedBy_Terms(Collection<String> createdByList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("createdBy", createdByList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_InScope(Collection<String> createdByList) {
+        setCreatedBy_Terms(createdByList, null);
+    }
+
+    public void setCreatedBy_InScope(Collection<String> createdByList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setCreatedBy_Terms(createdByList, opLambda);
+    }
+
+    public void setCreatedBy_Prefix(String createdBy) {
+        setCreatedBy_Prefix(createdBy, null);
+    }
+
+    public void setCreatedBy_Prefix(String createdBy, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_Exists() {
+        setCreatedBy_Exists(null);
+    }
+
+    public void setCreatedBy_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("createdBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_Missing() {
+        setCreatedBy_Missing(null);
+    }
+
+    public void setCreatedBy_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("createdBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_GreaterThan(String createdBy) {
+        setCreatedBy_GreaterThan(createdBy, null);
+    }
+
+    public void setCreatedBy_GreaterThan(String createdBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_GREATER_THAN, createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_LessThan(String createdBy) {
+        setCreatedBy_LessThan(createdBy, null);
+    }
+
+    public void setCreatedBy_LessThan(String createdBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_LESS_THAN, createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_GreaterEqual(String createdBy) {
+        setCreatedBy_GreaterEqual(createdBy, null);
+    }
+
+    public void setCreatedBy_GreaterEqual(String createdBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_LessEqual(String createdBy) {
+        setCreatedBy_LessEqual(createdBy, null);
+    }
+
+    public void setCreatedBy_LessEqual(String createdBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_Term(Long createdTime) {
+        setCreatedTime_Term(createdTime, null);
+    }
+
+    public void setCreatedTime_Term(Long createdTime, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("createdTime", createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_Terms(Collection<Long> createdTimeList) {
+        setCreatedTime_Terms(createdTimeList, null);
+    }
+
+    public void setCreatedTime_Terms(Collection<Long> createdTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("createdTime", createdTimeList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_InScope(Collection<Long> createdTimeList) {
+        setCreatedTime_Terms(createdTimeList, null);
+    }
+
+    public void setCreatedTime_InScope(Collection<Long> createdTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setCreatedTime_Terms(createdTimeList, opLambda);
+    }
+
+    public void setCreatedTime_Exists() {
+        setCreatedTime_Exists(null);
+    }
+
+    public void setCreatedTime_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("createdTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_Missing() {
+        setCreatedTime_Missing(null);
+    }
+
+    public void setCreatedTime_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("createdTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_GreaterThan(Long createdTime) {
+        setCreatedTime_GreaterThan(createdTime, null);
+    }
+
+    public void setCreatedTime_GreaterThan(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_THAN, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_LessThan(Long createdTime) {
+        setCreatedTime_LessThan(createdTime, null);
+    }
+
+    public void setCreatedTime_LessThan(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_THAN, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_GreaterEqual(Long createdTime) {
+        setCreatedTime_GreaterEqual(createdTime, null);
+    }
+
+    public void setCreatedTime_GreaterEqual(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_LessEqual(Long createdTime) {
+        setCreatedTime_LessEqual(createdTime, null);
+    }
+
+    public void setCreatedTime_LessEqual(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Term(String id) {
+        setId_Term(id, null);
+    }
+
+    public void setId_Term(String id, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("id", id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Terms(Collection<String> idList) {
+        setId_Terms(idList, null);
+    }
+
+    public void setId_Terms(Collection<String> idList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("id", idList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_InScope(Collection<String> idList) {
+        setId_Terms(idList, null);
+    }
+
+    public void setId_InScope(Collection<String> idList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setId_Terms(idList, opLambda);
+    }
+
+    public void setId_Prefix(String id) {
+        setId_Prefix(id, null);
+    }
+
+    public void setId_Prefix(String id, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("id", id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Exists() {
+        setId_Exists(null);
+    }
+
+    public void setId_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("id");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Missing() {
+        setId_Missing(null);
+    }
+
+    public void setId_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("id");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_GreaterThan(String id) {
+        setId_GreaterThan(id, null);
+    }
+
+    public void setId_GreaterThan(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_THAN, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_LessThan(String id) {
+        setId_LessThan(id, null);
+    }
+
+    public void setId_LessThan(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_THAN, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_GreaterEqual(String id) {
+        setId_GreaterEqual(id, null);
+    }
+
+    public void setId_GreaterEqual(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_EQUAL, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_LessEqual(String id) {
+        setId_LessEqual(id, null);
+    }
+
+    public void setId_LessEqual(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_EQUAL, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setMaxSize_Term(Integer maxSize) {
+        setMaxSize_Term(maxSize, null);
+    }
+
+    public void setMaxSize_Term(Integer maxSize, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("maxSize", maxSize);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setMaxSize_Terms(Collection<Integer> maxSizeList) {
+        setMaxSize_Terms(maxSizeList, null);
+    }
+
+    public void setMaxSize_Terms(Collection<Integer> maxSizeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("maxSize", maxSizeList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setMaxSize_InScope(Collection<Integer> maxSizeList) {
+        setMaxSize_Terms(maxSizeList, null);
+    }
+
+    public void setMaxSize_InScope(Collection<Integer> maxSizeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setMaxSize_Terms(maxSizeList, opLambda);
+    }
+
+    public void setMaxSize_Exists() {
+        setMaxSize_Exists(null);
+    }
+
+    public void setMaxSize_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("maxSize");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setMaxSize_Missing() {
+        setMaxSize_Missing(null);
+    }
+
+    public void setMaxSize_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("maxSize");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setMaxSize_GreaterThan(Integer maxSize) {
+        setMaxSize_GreaterThan(maxSize, null);
+    }
+
+    public void setMaxSize_GreaterThan(Integer maxSize, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("maxSize", ConditionKey.CK_GREATER_THAN, maxSize);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setMaxSize_LessThan(Integer maxSize) {
+        setMaxSize_LessThan(maxSize, null);
+    }
+
+    public void setMaxSize_LessThan(Integer maxSize, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("maxSize", ConditionKey.CK_LESS_THAN, maxSize);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setMaxSize_GreaterEqual(Integer maxSize) {
+        setMaxSize_GreaterEqual(maxSize, null);
+    }
+
+    public void setMaxSize_GreaterEqual(Integer maxSize, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("maxSize", ConditionKey.CK_GREATER_EQUAL, maxSize);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setMaxSize_LessEqual(Integer maxSize) {
+        setMaxSize_LessEqual(maxSize, null);
+    }
+
+    public void setMaxSize_LessEqual(Integer maxSize, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("maxSize", ConditionKey.CK_LESS_EQUAL, maxSize);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setQuery_Term(String query) {
+        setQuery_Term(query, null);
+    }
+
+    public void setQuery_Term(String query, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("query", query);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setQuery_Terms(Collection<String> queryList) {
+        setQuery_Terms(queryList, null);
+    }
+
+    public void setQuery_Terms(Collection<String> queryList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("query", queryList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setQuery_InScope(Collection<String> queryList) {
+        setQuery_Terms(queryList, null);
+    }
+
+    public void setQuery_InScope(Collection<String> queryList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setQuery_Terms(queryList, opLambda);
+    }
+
+    public void setQuery_Prefix(String query) {
+        setQuery_Prefix(query, null);
+    }
+
+    public void setQuery_Prefix(String query, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("query", query);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setQuery_Exists() {
+        setQuery_Exists(null);
+    }
+
+    public void setQuery_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("query");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setQuery_Missing() {
+        setQuery_Missing(null);
+    }
+
+    public void setQuery_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("query");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setQuery_GreaterThan(String query) {
+        setQuery_GreaterThan(query, null);
+    }
+
+    public void setQuery_GreaterThan(String query, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("query", ConditionKey.CK_GREATER_THAN, query);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setQuery_LessThan(String query) {
+        setQuery_LessThan(query, null);
+    }
+
+    public void setQuery_LessThan(String query, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("query", ConditionKey.CK_LESS_THAN, query);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setQuery_GreaterEqual(String query) {
+        setQuery_GreaterEqual(query, null);
+    }
+
+    public void setQuery_GreaterEqual(String query, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("query", ConditionKey.CK_GREATER_EQUAL, query);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setQuery_LessEqual(String query) {
+        setQuery_LessEqual(query, null);
+    }
+
+    public void setQuery_LessEqual(String query, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("query", ConditionKey.CK_LESS_EQUAL, query);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTerm_Term(String term) {
+        setTerm_Term(term, null);
+    }
+
+    public void setTerm_Term(String term, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("term", term);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTerm_Terms(Collection<String> termList) {
+        setTerm_Terms(termList, null);
+    }
+
+    public void setTerm_Terms(Collection<String> termList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("term", termList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTerm_InScope(Collection<String> termList) {
+        setTerm_Terms(termList, null);
+    }
+
+    public void setTerm_InScope(Collection<String> termList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setTerm_Terms(termList, opLambda);
+    }
+
+    public void setTerm_Prefix(String term) {
+        setTerm_Prefix(term, null);
+    }
+
+    public void setTerm_Prefix(String term, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("term", term);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTerm_Exists() {
+        setTerm_Exists(null);
+    }
+
+    public void setTerm_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("term");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTerm_Missing() {
+        setTerm_Missing(null);
+    }
+
+    public void setTerm_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("term");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTerm_GreaterThan(String term) {
+        setTerm_GreaterThan(term, null);
+    }
+
+    public void setTerm_GreaterThan(String term, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("term", ConditionKey.CK_GREATER_THAN, term);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTerm_LessThan(String term) {
+        setTerm_LessThan(term, null);
+    }
+
+    public void setTerm_LessThan(String term, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("term", ConditionKey.CK_LESS_THAN, term);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTerm_GreaterEqual(String term) {
+        setTerm_GreaterEqual(term, null);
+    }
+
+    public void setTerm_GreaterEqual(String term, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("term", ConditionKey.CK_GREATER_EQUAL, term);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTerm_LessEqual(String term) {
+        setTerm_LessEqual(term, null);
+    }
+
+    public void setTerm_LessEqual(String term, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("term", ConditionKey.CK_LESS_EQUAL, term);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Term(String updatedBy) {
+        setUpdatedBy_Term(updatedBy, null);
+    }
+
+    public void setUpdatedBy_Term(String updatedBy, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Terms(Collection<String> updatedByList) {
+        setUpdatedBy_Terms(updatedByList, null);
+    }
+
+    public void setUpdatedBy_Terms(Collection<String> updatedByList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("updatedBy", updatedByList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_InScope(Collection<String> updatedByList) {
+        setUpdatedBy_Terms(updatedByList, null);
+    }
+
+    public void setUpdatedBy_InScope(Collection<String> updatedByList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setUpdatedBy_Terms(updatedByList, opLambda);
+    }
+
+    public void setUpdatedBy_Prefix(String updatedBy) {
+        setUpdatedBy_Prefix(updatedBy, null);
+    }
+
+    public void setUpdatedBy_Prefix(String updatedBy, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Exists() {
+        setUpdatedBy_Exists(null);
+    }
+
+    public void setUpdatedBy_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("updatedBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Missing() {
+        setUpdatedBy_Missing(null);
+    }
+
+    public void setUpdatedBy_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("updatedBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_GreaterThan(String updatedBy) {
+        setUpdatedBy_GreaterThan(updatedBy, null);
+    }
+
+    public void setUpdatedBy_GreaterThan(String updatedBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_LessThan(String updatedBy) {
+        setUpdatedBy_LessThan(updatedBy, null);
+    }
+
+    public void setUpdatedBy_LessThan(String updatedBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_GreaterEqual(String updatedBy) {
+        setUpdatedBy_GreaterEqual(updatedBy, null);
+    }
+
+    public void setUpdatedBy_GreaterEqual(String updatedBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_LessEqual(String updatedBy) {
+        setUpdatedBy_LessEqual(updatedBy, null);
+    }
+
+    public void setUpdatedBy_LessEqual(String updatedBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_Term(Long updatedTime) {
+        setUpdatedTime_Term(updatedTime, null);
+    }
+
+    public void setUpdatedTime_Term(Long updatedTime, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("updatedTime", updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_Terms(Collection<Long> updatedTimeList) {
+        setUpdatedTime_Terms(updatedTimeList, null);
+    }
+
+    public void setUpdatedTime_Terms(Collection<Long> updatedTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("updatedTime", updatedTimeList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_InScope(Collection<Long> updatedTimeList) {
+        setUpdatedTime_Terms(updatedTimeList, null);
+    }
+
+    public void setUpdatedTime_InScope(Collection<Long> updatedTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setUpdatedTime_Terms(updatedTimeList, opLambda);
+    }
+
+    public void setUpdatedTime_Exists() {
+        setUpdatedTime_Exists(null);
+    }
+
+    public void setUpdatedTime_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("updatedTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_Missing() {
+        setUpdatedTime_Missing(null);
+    }
+
+    public void setUpdatedTime_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("updatedTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_GreaterThan(Long updatedTime) {
+        setUpdatedTime_GreaterThan(updatedTime, null);
+    }
+
+    public void setUpdatedTime_GreaterThan(Long updatedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_LessThan(Long updatedTime) {
+        setUpdatedTime_LessThan(updatedTime, null);
+    }
+
+    public void setUpdatedTime_LessThan(Long updatedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_GreaterEqual(Long updatedTime) {
+        setUpdatedTime_GreaterEqual(updatedTime, null);
+    }
+
+    public void setUpdatedTime_GreaterEqual(Long updatedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_LessEqual(Long updatedTime) {
+        setUpdatedTime_LessEqual(updatedTime, null);
+    }
+
+    public void setUpdatedTime_LessEqual(Long updatedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+}

src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsLabelToRoleCF.java

@@ -0,0 +1,430 @@
+package org.codelibs.fess.es.cbean.cf.bs;
+
+import java.util.Collection;
+
+import org.codelibs.fess.es.cbean.cf.LabelToRoleCF;
+import org.codelibs.fess.es.cbean.cq.LabelToRoleCQ;
+import org.dbflute.exception.IllegalConditionBeanOperationException;
+import org.dbflute.cbean.ckey.ConditionKey;
+import org.elasticsearch.index.query.AndFilterBuilder;
+import org.elasticsearch.index.query.BoolFilterBuilder;
+import org.elasticsearch.index.query.ExistsFilterBuilder;
+import org.elasticsearch.index.query.MissingFilterBuilder;
+import org.elasticsearch.index.query.NotFilterBuilder;
+import org.elasticsearch.index.query.OrFilterBuilder;
+import org.elasticsearch.index.query.PrefixFilterBuilder;
+import org.elasticsearch.index.query.QueryFilterBuilder;
+import org.elasticsearch.index.query.RangeFilterBuilder;
+import org.elasticsearch.index.query.TermFilterBuilder;
+import org.elasticsearch.index.query.TermsFilterBuilder;
+
+/**
+ * @author FreeGen
+ */
+public abstract class BsLabelToRoleCF extends AbstractConditionFilter {
+
+    public void bool(BoolCall<LabelToRoleCF> boolLambda) {
+        bool(boolLambda, null);
+    }
+
+    public void bool(BoolCall<LabelToRoleCF> boolLambda, ConditionOptionCall<BoolFilterBuilder> opLambda) {
+        LabelToRoleCF mustFilter = new LabelToRoleCF();
+        LabelToRoleCF shouldFilter = new LabelToRoleCF();
+        LabelToRoleCF mustNotFilter = new LabelToRoleCF();
+        boolLambda.callback(mustFilter, shouldFilter, mustNotFilter);
+        if (mustFilter.hasFilters() || shouldFilter.hasFilters() || mustNotFilter.hasFilters()) {
+            BoolFilterBuilder builder =
+                    regBoolF(mustFilter.filterBuilderList, shouldFilter.filterBuilderList, mustNotFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void and(OperatorCall<LabelToRoleCF> andLambda) {
+        and(andLambda, null);
+    }
+
+    public void and(OperatorCall<LabelToRoleCF> andLambda, ConditionOptionCall<AndFilterBuilder> opLambda) {
+        LabelToRoleCF andFilter = new LabelToRoleCF();
+        andLambda.callback(andFilter);
+        if (andFilter.hasFilters()) {
+            AndFilterBuilder builder = regAndF(andFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void or(OperatorCall<LabelToRoleCF> orLambda) {
+        or(orLambda, null);
+    }
+
+    public void or(OperatorCall<LabelToRoleCF> orLambda, ConditionOptionCall<OrFilterBuilder> opLambda) {
+        LabelToRoleCF orFilter = new LabelToRoleCF();
+        orLambda.callback(orFilter);
+        if (orFilter.hasFilters()) {
+            OrFilterBuilder builder = regOrF(orFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void not(OperatorCall<LabelToRoleCF> notLambda) {
+        not(notLambda, null);
+    }
+
+    public void not(OperatorCall<LabelToRoleCF> notLambda, ConditionOptionCall<NotFilterBuilder> opLambda) {
+        LabelToRoleCF notFilter = new LabelToRoleCF();
+        notLambda.callback(notFilter);
+        if (notFilter.hasFilters()) {
+            if (notFilter.filterBuilderList.size() > 1) {
+                final String msg = "not filter must be one filter.";
+                throw new IllegalConditionBeanOperationException(msg);
+            }
+            NotFilterBuilder builder = regNotF(notFilter.filterBuilderList.get(0));
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall<LabelToRoleCQ> queryLambda) {
+        query(queryLambda, null);
+    }
+
+    public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall<LabelToRoleCQ> queryLambda,
+            ConditionOptionCall<QueryFilterBuilder> opLambda) {
+        LabelToRoleCQ query = new LabelToRoleCQ();
+        queryLambda.callback(query);
+        if (query.hasQueries()) {
+            QueryFilterBuilder builder = regQueryF(query.getQuery());
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void setId_Term(String id) {
+        setId_Term(id, null);
+    }
+
+    public void setId_Term(String id, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("id", id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Terms(Collection<String> idList) {
+        setId_Terms(idList, null);
+    }
+
+    public void setId_Terms(Collection<String> idList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("id", idList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_InScope(Collection<String> idList) {
+        setId_Terms(idList, null);
+    }
+
+    public void setId_InScope(Collection<String> idList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setId_Terms(idList, opLambda);
+    }
+
+    public void setId_Prefix(String id) {
+        setId_Prefix(id, null);
+    }
+
+    public void setId_Prefix(String id, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("id", id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Exists() {
+        setId_Exists(null);
+    }
+
+    public void setId_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("id");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Missing() {
+        setId_Missing(null);
+    }
+
+    public void setId_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("id");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_GreaterThan(String id) {
+        setId_GreaterThan(id, null);
+    }
+
+    public void setId_GreaterThan(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_THAN, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_LessThan(String id) {
+        setId_LessThan(id, null);
+    }
+
+    public void setId_LessThan(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_THAN, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_GreaterEqual(String id) {
+        setId_GreaterEqual(id, null);
+    }
+
+    public void setId_GreaterEqual(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_EQUAL, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_LessEqual(String id) {
+        setId_LessEqual(id, null);
+    }
+
+    public void setId_LessEqual(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_EQUAL, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setLabelTypeId_Term(String labelTypeId) {
+        setLabelTypeId_Term(labelTypeId, null);
+    }
+
+    public void setLabelTypeId_Term(String labelTypeId, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("labelTypeId", labelTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setLabelTypeId_Terms(Collection<String> labelTypeIdList) {
+        setLabelTypeId_Terms(labelTypeIdList, null);
+    }
+
+    public void setLabelTypeId_Terms(Collection<String> labelTypeIdList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("labelTypeId", labelTypeIdList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setLabelTypeId_InScope(Collection<String> labelTypeIdList) {
+        setLabelTypeId_Terms(labelTypeIdList, null);
+    }
+
+    public void setLabelTypeId_InScope(Collection<String> labelTypeIdList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setLabelTypeId_Terms(labelTypeIdList, opLambda);
+    }
+
+    public void setLabelTypeId_Prefix(String labelTypeId) {
+        setLabelTypeId_Prefix(labelTypeId, null);
+    }
+
+    public void setLabelTypeId_Prefix(String labelTypeId, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("labelTypeId", labelTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setLabelTypeId_Exists() {
+        setLabelTypeId_Exists(null);
+    }
+
+    public void setLabelTypeId_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("labelTypeId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setLabelTypeId_Missing() {
+        setLabelTypeId_Missing(null);
+    }
+
+    public void setLabelTypeId_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("labelTypeId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setLabelTypeId_GreaterThan(String labelTypeId) {
+        setLabelTypeId_GreaterThan(labelTypeId, null);
+    }
+
+    public void setLabelTypeId_GreaterThan(String labelTypeId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("labelTypeId", ConditionKey.CK_GREATER_THAN, labelTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setLabelTypeId_LessThan(String labelTypeId) {
+        setLabelTypeId_LessThan(labelTypeId, null);
+    }
+
+    public void setLabelTypeId_LessThan(String labelTypeId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("labelTypeId", ConditionKey.CK_LESS_THAN, labelTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setLabelTypeId_GreaterEqual(String labelTypeId) {
+        setLabelTypeId_GreaterEqual(labelTypeId, null);
+    }
+
+    public void setLabelTypeId_GreaterEqual(String labelTypeId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("labelTypeId", ConditionKey.CK_GREATER_EQUAL, labelTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setLabelTypeId_LessEqual(String labelTypeId) {
+        setLabelTypeId_LessEqual(labelTypeId, null);
+    }
+
+    public void setLabelTypeId_LessEqual(String labelTypeId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("labelTypeId", ConditionKey.CK_LESS_EQUAL, labelTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRoleTypeId_Term(String roleTypeId) {
+        setRoleTypeId_Term(roleTypeId, null);
+    }
+
+    public void setRoleTypeId_Term(String roleTypeId, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("roleTypeId", roleTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRoleTypeId_Terms(Collection<String> roleTypeIdList) {
+        setRoleTypeId_Terms(roleTypeIdList, null);
+    }
+
+    public void setRoleTypeId_Terms(Collection<String> roleTypeIdList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("roleTypeId", roleTypeIdList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRoleTypeId_InScope(Collection<String> roleTypeIdList) {
+        setRoleTypeId_Terms(roleTypeIdList, null);
+    }
+
+    public void setRoleTypeId_InScope(Collection<String> roleTypeIdList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setRoleTypeId_Terms(roleTypeIdList, opLambda);
+    }
+
+    public void setRoleTypeId_Prefix(String roleTypeId) {
+        setRoleTypeId_Prefix(roleTypeId, null);
+    }
+
+    public void setRoleTypeId_Prefix(String roleTypeId, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("roleTypeId", roleTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRoleTypeId_Exists() {
+        setRoleTypeId_Exists(null);
+    }
+
+    public void setRoleTypeId_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("roleTypeId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRoleTypeId_Missing() {
+        setRoleTypeId_Missing(null);
+    }
+
+    public void setRoleTypeId_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("roleTypeId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRoleTypeId_GreaterThan(String roleTypeId) {
+        setRoleTypeId_GreaterThan(roleTypeId, null);
+    }
+
+    public void setRoleTypeId_GreaterThan(String roleTypeId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("roleTypeId", ConditionKey.CK_GREATER_THAN, roleTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRoleTypeId_LessThan(String roleTypeId) {
+        setRoleTypeId_LessThan(roleTypeId, null);
+    }
+
+    public void setRoleTypeId_LessThan(String roleTypeId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("roleTypeId", ConditionKey.CK_LESS_THAN, roleTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRoleTypeId_GreaterEqual(String roleTypeId) {
+        setRoleTypeId_GreaterEqual(roleTypeId, null);
+    }
+
+    public void setRoleTypeId_GreaterEqual(String roleTypeId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("roleTypeId", ConditionKey.CK_GREATER_EQUAL, roleTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRoleTypeId_LessEqual(String roleTypeId) {
+        setRoleTypeId_LessEqual(roleTypeId, null);
+    }
+
+    public void setRoleTypeId_LessEqual(String roleTypeId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("roleTypeId", ConditionKey.CK_LESS_EQUAL, roleTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+}

src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsLabelTypeCF.java

@@ -0,0 +1,1146 @@
+package org.codelibs.fess.es.cbean.cf.bs;
+
+import java.util.Collection;
+
+import org.codelibs.fess.es.cbean.cf.LabelTypeCF;
+import org.codelibs.fess.es.cbean.cq.LabelTypeCQ;
+import org.dbflute.exception.IllegalConditionBeanOperationException;
+import org.dbflute.cbean.ckey.ConditionKey;
+import org.elasticsearch.index.query.AndFilterBuilder;
+import org.elasticsearch.index.query.BoolFilterBuilder;
+import org.elasticsearch.index.query.ExistsFilterBuilder;
+import org.elasticsearch.index.query.MissingFilterBuilder;
+import org.elasticsearch.index.query.NotFilterBuilder;
+import org.elasticsearch.index.query.OrFilterBuilder;
+import org.elasticsearch.index.query.PrefixFilterBuilder;
+import org.elasticsearch.index.query.QueryFilterBuilder;
+import org.elasticsearch.index.query.RangeFilterBuilder;
+import org.elasticsearch.index.query.TermFilterBuilder;
+import org.elasticsearch.index.query.TermsFilterBuilder;
+
+/**
+ * @author FreeGen
+ */
+public abstract class BsLabelTypeCF extends AbstractConditionFilter {
+
+    public void bool(BoolCall<LabelTypeCF> boolLambda) {
+        bool(boolLambda, null);
+    }
+
+    public void bool(BoolCall<LabelTypeCF> boolLambda, ConditionOptionCall<BoolFilterBuilder> opLambda) {
+        LabelTypeCF mustFilter = new LabelTypeCF();
+        LabelTypeCF shouldFilter = new LabelTypeCF();
+        LabelTypeCF mustNotFilter = new LabelTypeCF();
+        boolLambda.callback(mustFilter, shouldFilter, mustNotFilter);
+        if (mustFilter.hasFilters() || shouldFilter.hasFilters() || mustNotFilter.hasFilters()) {
+            BoolFilterBuilder builder =
+                    regBoolF(mustFilter.filterBuilderList, shouldFilter.filterBuilderList, mustNotFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void and(OperatorCall<LabelTypeCF> andLambda) {
+        and(andLambda, null);
+    }
+
+    public void and(OperatorCall<LabelTypeCF> andLambda, ConditionOptionCall<AndFilterBuilder> opLambda) {
+        LabelTypeCF andFilter = new LabelTypeCF();
+        andLambda.callback(andFilter);
+        if (andFilter.hasFilters()) {
+            AndFilterBuilder builder = regAndF(andFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void or(OperatorCall<LabelTypeCF> orLambda) {
+        or(orLambda, null);
+    }
+
+    public void or(OperatorCall<LabelTypeCF> orLambda, ConditionOptionCall<OrFilterBuilder> opLambda) {
+        LabelTypeCF orFilter = new LabelTypeCF();
+        orLambda.callback(orFilter);
+        if (orFilter.hasFilters()) {
+            OrFilterBuilder builder = regOrF(orFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void not(OperatorCall<LabelTypeCF> notLambda) {
+        not(notLambda, null);
+    }
+
+    public void not(OperatorCall<LabelTypeCF> notLambda, ConditionOptionCall<NotFilterBuilder> opLambda) {
+        LabelTypeCF notFilter = new LabelTypeCF();
+        notLambda.callback(notFilter);
+        if (notFilter.hasFilters()) {
+            if (notFilter.filterBuilderList.size() > 1) {
+                final String msg = "not filter must be one filter.";
+                throw new IllegalConditionBeanOperationException(msg);
+            }
+            NotFilterBuilder builder = regNotF(notFilter.filterBuilderList.get(0));
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall<LabelTypeCQ> queryLambda) {
+        query(queryLambda, null);
+    }
+
+    public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall<LabelTypeCQ> queryLambda,
+            ConditionOptionCall<QueryFilterBuilder> opLambda) {
+        LabelTypeCQ query = new LabelTypeCQ();
+        queryLambda.callback(query);
+        if (query.hasQueries()) {
+            QueryFilterBuilder builder = regQueryF(query.getQuery());
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void setCreatedBy_Term(String createdBy) {
+        setCreatedBy_Term(createdBy, null);
+    }
+
+    public void setCreatedBy_Term(String createdBy, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_Terms(Collection<String> createdByList) {
+        setCreatedBy_Terms(createdByList, null);
+    }
+
+    public void setCreatedBy_Terms(Collection<String> createdByList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("createdBy", createdByList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_InScope(Collection<String> createdByList) {
+        setCreatedBy_Terms(createdByList, null);
+    }
+
+    public void setCreatedBy_InScope(Collection<String> createdByList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setCreatedBy_Terms(createdByList, opLambda);
+    }
+
+    public void setCreatedBy_Prefix(String createdBy) {
+        setCreatedBy_Prefix(createdBy, null);
+    }
+
+    public void setCreatedBy_Prefix(String createdBy, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_Exists() {
+        setCreatedBy_Exists(null);
+    }
+
+    public void setCreatedBy_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("createdBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_Missing() {
+        setCreatedBy_Missing(null);
+    }
+
+    public void setCreatedBy_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("createdBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_GreaterThan(String createdBy) {
+        setCreatedBy_GreaterThan(createdBy, null);
+    }
+
+    public void setCreatedBy_GreaterThan(String createdBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_GREATER_THAN, createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_LessThan(String createdBy) {
+        setCreatedBy_LessThan(createdBy, null);
+    }
+
+    public void setCreatedBy_LessThan(String createdBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_LESS_THAN, createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_GreaterEqual(String createdBy) {
+        setCreatedBy_GreaterEqual(createdBy, null);
+    }
+
+    public void setCreatedBy_GreaterEqual(String createdBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_LessEqual(String createdBy) {
+        setCreatedBy_LessEqual(createdBy, null);
+    }
+
+    public void setCreatedBy_LessEqual(String createdBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_Term(Long createdTime) {
+        setCreatedTime_Term(createdTime, null);
+    }
+
+    public void setCreatedTime_Term(Long createdTime, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("createdTime", createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_Terms(Collection<Long> createdTimeList) {
+        setCreatedTime_Terms(createdTimeList, null);
+    }
+
+    public void setCreatedTime_Terms(Collection<Long> createdTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("createdTime", createdTimeList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_InScope(Collection<Long> createdTimeList) {
+        setCreatedTime_Terms(createdTimeList, null);
+    }
+
+    public void setCreatedTime_InScope(Collection<Long> createdTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setCreatedTime_Terms(createdTimeList, opLambda);
+    }
+
+    public void setCreatedTime_Exists() {
+        setCreatedTime_Exists(null);
+    }
+
+    public void setCreatedTime_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("createdTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_Missing() {
+        setCreatedTime_Missing(null);
+    }
+
+    public void setCreatedTime_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("createdTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_GreaterThan(Long createdTime) {
+        setCreatedTime_GreaterThan(createdTime, null);
+    }
+
+    public void setCreatedTime_GreaterThan(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_THAN, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_LessThan(Long createdTime) {
+        setCreatedTime_LessThan(createdTime, null);
+    }
+
+    public void setCreatedTime_LessThan(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_THAN, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_GreaterEqual(Long createdTime) {
+        setCreatedTime_GreaterEqual(createdTime, null);
+    }
+
+    public void setCreatedTime_GreaterEqual(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_LessEqual(Long createdTime) {
+        setCreatedTime_LessEqual(createdTime, null);
+    }
+
+    public void setCreatedTime_LessEqual(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setExcludedPaths_Term(String excludedPaths) {
+        setExcludedPaths_Term(excludedPaths, null);
+    }
+
+    public void setExcludedPaths_Term(String excludedPaths, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("excludedPaths", excludedPaths);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setExcludedPaths_Terms(Collection<String> excludedPathsList) {
+        setExcludedPaths_Terms(excludedPathsList, null);
+    }
+
+    public void setExcludedPaths_Terms(Collection<String> excludedPathsList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("excludedPaths", excludedPathsList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setExcludedPaths_InScope(Collection<String> excludedPathsList) {
+        setExcludedPaths_Terms(excludedPathsList, null);
+    }
+
+    public void setExcludedPaths_InScope(Collection<String> excludedPathsList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setExcludedPaths_Terms(excludedPathsList, opLambda);
+    }
+
+    public void setExcludedPaths_Prefix(String excludedPaths) {
+        setExcludedPaths_Prefix(excludedPaths, null);
+    }
+
+    public void setExcludedPaths_Prefix(String excludedPaths, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("excludedPaths", excludedPaths);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setExcludedPaths_Exists() {
+        setExcludedPaths_Exists(null);
+    }
+
+    public void setExcludedPaths_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("excludedPaths");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setExcludedPaths_Missing() {
+        setExcludedPaths_Missing(null);
+    }
+
+    public void setExcludedPaths_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("excludedPaths");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setExcludedPaths_GreaterThan(String excludedPaths) {
+        setExcludedPaths_GreaterThan(excludedPaths, null);
+    }
+
+    public void setExcludedPaths_GreaterThan(String excludedPaths, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("excludedPaths", ConditionKey.CK_GREATER_THAN, excludedPaths);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setExcludedPaths_LessThan(String excludedPaths) {
+        setExcludedPaths_LessThan(excludedPaths, null);
+    }
+
+    public void setExcludedPaths_LessThan(String excludedPaths, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("excludedPaths", ConditionKey.CK_LESS_THAN, excludedPaths);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setExcludedPaths_GreaterEqual(String excludedPaths) {
+        setExcludedPaths_GreaterEqual(excludedPaths, null);
+    }
+
+    public void setExcludedPaths_GreaterEqual(String excludedPaths, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("excludedPaths", ConditionKey.CK_GREATER_EQUAL, excludedPaths);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setExcludedPaths_LessEqual(String excludedPaths) {
+        setExcludedPaths_LessEqual(excludedPaths, null);
+    }
+
+    public void setExcludedPaths_LessEqual(String excludedPaths, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("excludedPaths", ConditionKey.CK_LESS_EQUAL, excludedPaths);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Term(String id) {
+        setId_Term(id, null);
+    }
+
+    public void setId_Term(String id, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("id", id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Terms(Collection<String> idList) {
+        setId_Terms(idList, null);
+    }
+
+    public void setId_Terms(Collection<String> idList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("id", idList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_InScope(Collection<String> idList) {
+        setId_Terms(idList, null);
+    }
+
+    public void setId_InScope(Collection<String> idList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setId_Terms(idList, opLambda);
+    }
+
+    public void setId_Prefix(String id) {
+        setId_Prefix(id, null);
+    }
+
+    public void setId_Prefix(String id, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("id", id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Exists() {
+        setId_Exists(null);
+    }
+
+    public void setId_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("id");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Missing() {
+        setId_Missing(null);
+    }
+
+    public void setId_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("id");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_GreaterThan(String id) {
+        setId_GreaterThan(id, null);
+    }
+
+    public void setId_GreaterThan(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_THAN, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_LessThan(String id) {
+        setId_LessThan(id, null);
+    }
+
+    public void setId_LessThan(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_THAN, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_GreaterEqual(String id) {
+        setId_GreaterEqual(id, null);
+    }
+
+    public void setId_GreaterEqual(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_EQUAL, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_LessEqual(String id) {
+        setId_LessEqual(id, null);
+    }
+
+    public void setId_LessEqual(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_EQUAL, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIncludedPaths_Term(String includedPaths) {
+        setIncludedPaths_Term(includedPaths, null);
+    }
+
+    public void setIncludedPaths_Term(String includedPaths, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("includedPaths", includedPaths);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIncludedPaths_Terms(Collection<String> includedPathsList) {
+        setIncludedPaths_Terms(includedPathsList, null);
+    }
+
+    public void setIncludedPaths_Terms(Collection<String> includedPathsList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("includedPaths", includedPathsList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIncludedPaths_InScope(Collection<String> includedPathsList) {
+        setIncludedPaths_Terms(includedPathsList, null);
+    }
+
+    public void setIncludedPaths_InScope(Collection<String> includedPathsList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setIncludedPaths_Terms(includedPathsList, opLambda);
+    }
+
+    public void setIncludedPaths_Prefix(String includedPaths) {
+        setIncludedPaths_Prefix(includedPaths, null);
+    }
+
+    public void setIncludedPaths_Prefix(String includedPaths, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("includedPaths", includedPaths);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIncludedPaths_Exists() {
+        setIncludedPaths_Exists(null);
+    }
+
+    public void setIncludedPaths_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("includedPaths");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIncludedPaths_Missing() {
+        setIncludedPaths_Missing(null);
+    }
+
+    public void setIncludedPaths_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("includedPaths");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIncludedPaths_GreaterThan(String includedPaths) {
+        setIncludedPaths_GreaterThan(includedPaths, null);
+    }
+
+    public void setIncludedPaths_GreaterThan(String includedPaths, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("includedPaths", ConditionKey.CK_GREATER_THAN, includedPaths);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIncludedPaths_LessThan(String includedPaths) {
+        setIncludedPaths_LessThan(includedPaths, null);
+    }
+
+    public void setIncludedPaths_LessThan(String includedPaths, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("includedPaths", ConditionKey.CK_LESS_THAN, includedPaths);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIncludedPaths_GreaterEqual(String includedPaths) {
+        setIncludedPaths_GreaterEqual(includedPaths, null);
+    }
+
+    public void setIncludedPaths_GreaterEqual(String includedPaths, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("includedPaths", ConditionKey.CK_GREATER_EQUAL, includedPaths);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIncludedPaths_LessEqual(String includedPaths) {
+        setIncludedPaths_LessEqual(includedPaths, null);
+    }
+
+    public void setIncludedPaths_LessEqual(String includedPaths, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("includedPaths", ConditionKey.CK_LESS_EQUAL, includedPaths);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_Term(String name) {
+        setName_Term(name, null);
+    }
+
+    public void setName_Term(String name, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("name", name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_Terms(Collection<String> nameList) {
+        setName_Terms(nameList, null);
+    }
+
+    public void setName_Terms(Collection<String> nameList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("name", nameList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_InScope(Collection<String> nameList) {
+        setName_Terms(nameList, null);
+    }
+
+    public void setName_InScope(Collection<String> nameList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setName_Terms(nameList, opLambda);
+    }
+
+    public void setName_Prefix(String name) {
+        setName_Prefix(name, null);
+    }
+
+    public void setName_Prefix(String name, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("name", name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_Exists() {
+        setName_Exists(null);
+    }
+
+    public void setName_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("name");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_Missing() {
+        setName_Missing(null);
+    }
+
+    public void setName_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("name");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_GreaterThan(String name) {
+        setName_GreaterThan(name, null);
+    }
+
+    public void setName_GreaterThan(String name, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_GREATER_THAN, name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_LessThan(String name) {
+        setName_LessThan(name, null);
+    }
+
+    public void setName_LessThan(String name, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_LESS_THAN, name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_GreaterEqual(String name) {
+        setName_GreaterEqual(name, null);
+    }
+
+    public void setName_GreaterEqual(String name, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_GREATER_EQUAL, name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_LessEqual(String name) {
+        setName_LessEqual(name, null);
+    }
+
+    public void setName_LessEqual(String name, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_LESS_EQUAL, name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_Term(Integer sortOrder) {
+        setSortOrder_Term(sortOrder, null);
+    }
+
+    public void setSortOrder_Term(Integer sortOrder, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("sortOrder", sortOrder);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_Terms(Collection<Integer> sortOrderList) {
+        setSortOrder_Terms(sortOrderList, null);
+    }
+
+    public void setSortOrder_Terms(Collection<Integer> sortOrderList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("sortOrder", sortOrderList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_InScope(Collection<Integer> sortOrderList) {
+        setSortOrder_Terms(sortOrderList, null);
+    }
+
+    public void setSortOrder_InScope(Collection<Integer> sortOrderList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setSortOrder_Terms(sortOrderList, opLambda);
+    }
+
+    public void setSortOrder_Exists() {
+        setSortOrder_Exists(null);
+    }
+
+    public void setSortOrder_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("sortOrder");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_Missing() {
+        setSortOrder_Missing(null);
+    }
+
+    public void setSortOrder_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("sortOrder");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_GreaterThan(Integer sortOrder) {
+        setSortOrder_GreaterThan(sortOrder, null);
+    }
+
+    public void setSortOrder_GreaterThan(Integer sortOrder, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_GREATER_THAN, sortOrder);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_LessThan(Integer sortOrder) {
+        setSortOrder_LessThan(sortOrder, null);
+    }
+
+    public void setSortOrder_LessThan(Integer sortOrder, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_LESS_THAN, sortOrder);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_GreaterEqual(Integer sortOrder) {
+        setSortOrder_GreaterEqual(sortOrder, null);
+    }
+
+    public void setSortOrder_GreaterEqual(Integer sortOrder, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_GREATER_EQUAL, sortOrder);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_LessEqual(Integer sortOrder) {
+        setSortOrder_LessEqual(sortOrder, null);
+    }
+
+    public void setSortOrder_LessEqual(Integer sortOrder, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_LESS_EQUAL, sortOrder);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Term(String updatedBy) {
+        setUpdatedBy_Term(updatedBy, null);
+    }
+
+    public void setUpdatedBy_Term(String updatedBy, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Terms(Collection<String> updatedByList) {
+        setUpdatedBy_Terms(updatedByList, null);
+    }
+
+    public void setUpdatedBy_Terms(Collection<String> updatedByList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("updatedBy", updatedByList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_InScope(Collection<String> updatedByList) {
+        setUpdatedBy_Terms(updatedByList, null);
+    }
+
+    public void setUpdatedBy_InScope(Collection<String> updatedByList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setUpdatedBy_Terms(updatedByList, opLambda);
+    }
+
+    public void setUpdatedBy_Prefix(String updatedBy) {
+        setUpdatedBy_Prefix(updatedBy, null);
+    }
+
+    public void setUpdatedBy_Prefix(String updatedBy, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Exists() {
+        setUpdatedBy_Exists(null);
+    }
+
+    public void setUpdatedBy_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("updatedBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Missing() {
+        setUpdatedBy_Missing(null);
+    }
+
+    public void setUpdatedBy_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("updatedBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_GreaterThan(String updatedBy) {
+        setUpdatedBy_GreaterThan(updatedBy, null);
+    }
+
+    public void setUpdatedBy_GreaterThan(String updatedBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_LessThan(String updatedBy) {
+        setUpdatedBy_LessThan(updatedBy, null);
+    }
+
+    public void setUpdatedBy_LessThan(String updatedBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_GreaterEqual(String updatedBy) {
+        setUpdatedBy_GreaterEqual(updatedBy, null);
+    }
+
+    public void setUpdatedBy_GreaterEqual(String updatedBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_LessEqual(String updatedBy) {
+        setUpdatedBy_LessEqual(updatedBy, null);
+    }
+
+    public void setUpdatedBy_LessEqual(String updatedBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_Term(Long updatedTime) {
+        setUpdatedTime_Term(updatedTime, null);
+    }
+
+    public void setUpdatedTime_Term(Long updatedTime, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("updatedTime", updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_Terms(Collection<Long> updatedTimeList) {
+        setUpdatedTime_Terms(updatedTimeList, null);
+    }
+
+    public void setUpdatedTime_Terms(Collection<Long> updatedTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("updatedTime", updatedTimeList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_InScope(Collection<Long> updatedTimeList) {
+        setUpdatedTime_Terms(updatedTimeList, null);
+    }
+
+    public void setUpdatedTime_InScope(Collection<Long> updatedTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setUpdatedTime_Terms(updatedTimeList, opLambda);
+    }
+
+    public void setUpdatedTime_Exists() {
+        setUpdatedTime_Exists(null);
+    }
+
+    public void setUpdatedTime_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("updatedTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_Missing() {
+        setUpdatedTime_Missing(null);
+    }
+
+    public void setUpdatedTime_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("updatedTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_GreaterThan(Long updatedTime) {
+        setUpdatedTime_GreaterThan(updatedTime, null);
+    }
+
+    public void setUpdatedTime_GreaterThan(Long updatedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_LessThan(Long updatedTime) {
+        setUpdatedTime_LessThan(updatedTime, null);
+    }
+
+    public void setUpdatedTime_LessThan(Long updatedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_GreaterEqual(Long updatedTime) {
+        setUpdatedTime_GreaterEqual(updatedTime, null);
+    }
+
+    public void setUpdatedTime_GreaterEqual(Long updatedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_LessEqual(Long updatedTime) {
+        setUpdatedTime_LessEqual(updatedTime, null);
+    }
+
+    public void setUpdatedTime_LessEqual(Long updatedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setValue_Term(String value) {
+        setValue_Term(value, null);
+    }
+
+    public void setValue_Term(String value, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("value", value);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setValue_Terms(Collection<String> valueList) {
+        setValue_Terms(valueList, null);
+    }
+
+    public void setValue_Terms(Collection<String> valueList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("value", valueList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setValue_InScope(Collection<String> valueList) {
+        setValue_Terms(valueList, null);
+    }
+
+    public void setValue_InScope(Collection<String> valueList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setValue_Terms(valueList, opLambda);
+    }
+
+    public void setValue_Prefix(String value) {
+        setValue_Prefix(value, null);
+    }
+
+    public void setValue_Prefix(String value, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("value", value);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setValue_Exists() {
+        setValue_Exists(null);
+    }
+
+    public void setValue_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("value");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setValue_Missing() {
+        setValue_Missing(null);
+    }
+
+    public void setValue_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("value");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setValue_GreaterThan(String value) {
+        setValue_GreaterThan(value, null);
+    }
+
+    public void setValue_GreaterThan(String value, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("value", ConditionKey.CK_GREATER_THAN, value);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setValue_LessThan(String value) {
+        setValue_LessThan(value, null);
+    }
+
+    public void setValue_LessThan(String value, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("value", ConditionKey.CK_LESS_THAN, value);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setValue_GreaterEqual(String value) {
+        setValue_GreaterEqual(value, null);
+    }
+
+    public void setValue_GreaterEqual(String value, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("value", ConditionKey.CK_GREATER_EQUAL, value);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setValue_LessEqual(String value) {
+        setValue_LessEqual(value, null);
+    }
+
+    public void setValue_LessEqual(String value, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("value", ConditionKey.CK_LESS_EQUAL, value);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+}

src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsOverlappingHostCF.java

@@ -0,0 +1,932 @@
+package org.codelibs.fess.es.cbean.cf.bs;
+
+import java.util.Collection;
+
+import org.codelibs.fess.es.cbean.cf.OverlappingHostCF;
+import org.codelibs.fess.es.cbean.cq.OverlappingHostCQ;
+import org.dbflute.exception.IllegalConditionBeanOperationException;
+import org.dbflute.cbean.ckey.ConditionKey;
+import org.elasticsearch.index.query.AndFilterBuilder;
+import org.elasticsearch.index.query.BoolFilterBuilder;
+import org.elasticsearch.index.query.ExistsFilterBuilder;
+import org.elasticsearch.index.query.MissingFilterBuilder;
+import org.elasticsearch.index.query.NotFilterBuilder;
+import org.elasticsearch.index.query.OrFilterBuilder;
+import org.elasticsearch.index.query.PrefixFilterBuilder;
+import org.elasticsearch.index.query.QueryFilterBuilder;
+import org.elasticsearch.index.query.RangeFilterBuilder;
+import org.elasticsearch.index.query.TermFilterBuilder;
+import org.elasticsearch.index.query.TermsFilterBuilder;
+
+/**
+ * @author FreeGen
+ */
+public abstract class BsOverlappingHostCF extends AbstractConditionFilter {
+
+    public void bool(BoolCall<OverlappingHostCF> boolLambda) {
+        bool(boolLambda, null);
+    }
+
+    public void bool(BoolCall<OverlappingHostCF> boolLambda, ConditionOptionCall<BoolFilterBuilder> opLambda) {
+        OverlappingHostCF mustFilter = new OverlappingHostCF();
+        OverlappingHostCF shouldFilter = new OverlappingHostCF();
+        OverlappingHostCF mustNotFilter = new OverlappingHostCF();
+        boolLambda.callback(mustFilter, shouldFilter, mustNotFilter);
+        if (mustFilter.hasFilters() || shouldFilter.hasFilters() || mustNotFilter.hasFilters()) {
+            BoolFilterBuilder builder =
+                    regBoolF(mustFilter.filterBuilderList, shouldFilter.filterBuilderList, mustNotFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void and(OperatorCall<OverlappingHostCF> andLambda) {
+        and(andLambda, null);
+    }
+
+    public void and(OperatorCall<OverlappingHostCF> andLambda, ConditionOptionCall<AndFilterBuilder> opLambda) {
+        OverlappingHostCF andFilter = new OverlappingHostCF();
+        andLambda.callback(andFilter);
+        if (andFilter.hasFilters()) {
+            AndFilterBuilder builder = regAndF(andFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void or(OperatorCall<OverlappingHostCF> orLambda) {
+        or(orLambda, null);
+    }
+
+    public void or(OperatorCall<OverlappingHostCF> orLambda, ConditionOptionCall<OrFilterBuilder> opLambda) {
+        OverlappingHostCF orFilter = new OverlappingHostCF();
+        orLambda.callback(orFilter);
+        if (orFilter.hasFilters()) {
+            OrFilterBuilder builder = regOrF(orFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void not(OperatorCall<OverlappingHostCF> notLambda) {
+        not(notLambda, null);
+    }
+
+    public void not(OperatorCall<OverlappingHostCF> notLambda, ConditionOptionCall<NotFilterBuilder> opLambda) {
+        OverlappingHostCF notFilter = new OverlappingHostCF();
+        notLambda.callback(notFilter);
+        if (notFilter.hasFilters()) {
+            if (notFilter.filterBuilderList.size() > 1) {
+                final String msg = "not filter must be one filter.";
+                throw new IllegalConditionBeanOperationException(msg);
+            }
+            NotFilterBuilder builder = regNotF(notFilter.filterBuilderList.get(0));
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall<OverlappingHostCQ> queryLambda) {
+        query(queryLambda, null);
+    }
+
+    public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall<OverlappingHostCQ> queryLambda,
+            ConditionOptionCall<QueryFilterBuilder> opLambda) {
+        OverlappingHostCQ query = new OverlappingHostCQ();
+        queryLambda.callback(query);
+        if (query.hasQueries()) {
+            QueryFilterBuilder builder = regQueryF(query.getQuery());
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void setCreatedBy_Term(String createdBy) {
+        setCreatedBy_Term(createdBy, null);
+    }
+
+    public void setCreatedBy_Term(String createdBy, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_Terms(Collection<String> createdByList) {
+        setCreatedBy_Terms(createdByList, null);
+    }
+
+    public void setCreatedBy_Terms(Collection<String> createdByList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("createdBy", createdByList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_InScope(Collection<String> createdByList) {
+        setCreatedBy_Terms(createdByList, null);
+    }
+
+    public void setCreatedBy_InScope(Collection<String> createdByList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setCreatedBy_Terms(createdByList, opLambda);
+    }
+
+    public void setCreatedBy_Prefix(String createdBy) {
+        setCreatedBy_Prefix(createdBy, null);
+    }
+
+    public void setCreatedBy_Prefix(String createdBy, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_Exists() {
+        setCreatedBy_Exists(null);
+    }
+
+    public void setCreatedBy_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("createdBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_Missing() {
+        setCreatedBy_Missing(null);
+    }
+
+    public void setCreatedBy_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("createdBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_GreaterThan(String createdBy) {
+        setCreatedBy_GreaterThan(createdBy, null);
+    }
+
+    public void setCreatedBy_GreaterThan(String createdBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_GREATER_THAN, createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_LessThan(String createdBy) {
+        setCreatedBy_LessThan(createdBy, null);
+    }
+
+    public void setCreatedBy_LessThan(String createdBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_LESS_THAN, createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_GreaterEqual(String createdBy) {
+        setCreatedBy_GreaterEqual(createdBy, null);
+    }
+
+    public void setCreatedBy_GreaterEqual(String createdBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_LessEqual(String createdBy) {
+        setCreatedBy_LessEqual(createdBy, null);
+    }
+
+    public void setCreatedBy_LessEqual(String createdBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_Term(Long createdTime) {
+        setCreatedTime_Term(createdTime, null);
+    }
+
+    public void setCreatedTime_Term(Long createdTime, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("createdTime", createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_Terms(Collection<Long> createdTimeList) {
+        setCreatedTime_Terms(createdTimeList, null);
+    }
+
+    public void setCreatedTime_Terms(Collection<Long> createdTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("createdTime", createdTimeList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_InScope(Collection<Long> createdTimeList) {
+        setCreatedTime_Terms(createdTimeList, null);
+    }
+
+    public void setCreatedTime_InScope(Collection<Long> createdTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setCreatedTime_Terms(createdTimeList, opLambda);
+    }
+
+    public void setCreatedTime_Exists() {
+        setCreatedTime_Exists(null);
+    }
+
+    public void setCreatedTime_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("createdTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_Missing() {
+        setCreatedTime_Missing(null);
+    }
+
+    public void setCreatedTime_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("createdTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_GreaterThan(Long createdTime) {
+        setCreatedTime_GreaterThan(createdTime, null);
+    }
+
+    public void setCreatedTime_GreaterThan(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_THAN, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_LessThan(Long createdTime) {
+        setCreatedTime_LessThan(createdTime, null);
+    }
+
+    public void setCreatedTime_LessThan(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_THAN, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_GreaterEqual(Long createdTime) {
+        setCreatedTime_GreaterEqual(createdTime, null);
+    }
+
+    public void setCreatedTime_GreaterEqual(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_LessEqual(Long createdTime) {
+        setCreatedTime_LessEqual(createdTime, null);
+    }
+
+    public void setCreatedTime_LessEqual(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Term(String id) {
+        setId_Term(id, null);
+    }
+
+    public void setId_Term(String id, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("id", id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Terms(Collection<String> idList) {
+        setId_Terms(idList, null);
+    }
+
+    public void setId_Terms(Collection<String> idList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("id", idList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_InScope(Collection<String> idList) {
+        setId_Terms(idList, null);
+    }
+
+    public void setId_InScope(Collection<String> idList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setId_Terms(idList, opLambda);
+    }
+
+    public void setId_Prefix(String id) {
+        setId_Prefix(id, null);
+    }
+
+    public void setId_Prefix(String id, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("id", id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Exists() {
+        setId_Exists(null);
+    }
+
+    public void setId_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("id");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Missing() {
+        setId_Missing(null);
+    }
+
+    public void setId_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("id");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_GreaterThan(String id) {
+        setId_GreaterThan(id, null);
+    }
+
+    public void setId_GreaterThan(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_THAN, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_LessThan(String id) {
+        setId_LessThan(id, null);
+    }
+
+    public void setId_LessThan(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_THAN, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_GreaterEqual(String id) {
+        setId_GreaterEqual(id, null);
+    }
+
+    public void setId_GreaterEqual(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_EQUAL, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_LessEqual(String id) {
+        setId_LessEqual(id, null);
+    }
+
+    public void setId_LessEqual(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_EQUAL, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setOverlappingName_Term(String overlappingName) {
+        setOverlappingName_Term(overlappingName, null);
+    }
+
+    public void setOverlappingName_Term(String overlappingName, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("overlappingName", overlappingName);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setOverlappingName_Terms(Collection<String> overlappingNameList) {
+        setOverlappingName_Terms(overlappingNameList, null);
+    }
+
+    public void setOverlappingName_Terms(Collection<String> overlappingNameList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("overlappingName", overlappingNameList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setOverlappingName_InScope(Collection<String> overlappingNameList) {
+        setOverlappingName_Terms(overlappingNameList, null);
+    }
+
+    public void setOverlappingName_InScope(Collection<String> overlappingNameList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setOverlappingName_Terms(overlappingNameList, opLambda);
+    }
+
+    public void setOverlappingName_Prefix(String overlappingName) {
+        setOverlappingName_Prefix(overlappingName, null);
+    }
+
+    public void setOverlappingName_Prefix(String overlappingName, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("overlappingName", overlappingName);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setOverlappingName_Exists() {
+        setOverlappingName_Exists(null);
+    }
+
+    public void setOverlappingName_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("overlappingName");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setOverlappingName_Missing() {
+        setOverlappingName_Missing(null);
+    }
+
+    public void setOverlappingName_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("overlappingName");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setOverlappingName_GreaterThan(String overlappingName) {
+        setOverlappingName_GreaterThan(overlappingName, null);
+    }
+
+    public void setOverlappingName_GreaterThan(String overlappingName, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("overlappingName", ConditionKey.CK_GREATER_THAN, overlappingName);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setOverlappingName_LessThan(String overlappingName) {
+        setOverlappingName_LessThan(overlappingName, null);
+    }
+
+    public void setOverlappingName_LessThan(String overlappingName, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("overlappingName", ConditionKey.CK_LESS_THAN, overlappingName);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setOverlappingName_GreaterEqual(String overlappingName) {
+        setOverlappingName_GreaterEqual(overlappingName, null);
+    }
+
+    public void setOverlappingName_GreaterEqual(String overlappingName, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("overlappingName", ConditionKey.CK_GREATER_EQUAL, overlappingName);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setOverlappingName_LessEqual(String overlappingName) {
+        setOverlappingName_LessEqual(overlappingName, null);
+    }
+
+    public void setOverlappingName_LessEqual(String overlappingName, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("overlappingName", ConditionKey.CK_LESS_EQUAL, overlappingName);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRegularName_Term(String regularName) {
+        setRegularName_Term(regularName, null);
+    }
+
+    public void setRegularName_Term(String regularName, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("regularName", regularName);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRegularName_Terms(Collection<String> regularNameList) {
+        setRegularName_Terms(regularNameList, null);
+    }
+
+    public void setRegularName_Terms(Collection<String> regularNameList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("regularName", regularNameList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRegularName_InScope(Collection<String> regularNameList) {
+        setRegularName_Terms(regularNameList, null);
+    }
+
+    public void setRegularName_InScope(Collection<String> regularNameList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setRegularName_Terms(regularNameList, opLambda);
+    }
+
+    public void setRegularName_Prefix(String regularName) {
+        setRegularName_Prefix(regularName, null);
+    }
+
+    public void setRegularName_Prefix(String regularName, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("regularName", regularName);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRegularName_Exists() {
+        setRegularName_Exists(null);
+    }
+
+    public void setRegularName_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("regularName");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRegularName_Missing() {
+        setRegularName_Missing(null);
+    }
+
+    public void setRegularName_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("regularName");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRegularName_GreaterThan(String regularName) {
+        setRegularName_GreaterThan(regularName, null);
+    }
+
+    public void setRegularName_GreaterThan(String regularName, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("regularName", ConditionKey.CK_GREATER_THAN, regularName);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRegularName_LessThan(String regularName) {
+        setRegularName_LessThan(regularName, null);
+    }
+
+    public void setRegularName_LessThan(String regularName, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("regularName", ConditionKey.CK_LESS_THAN, regularName);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRegularName_GreaterEqual(String regularName) {
+        setRegularName_GreaterEqual(regularName, null);
+    }
+
+    public void setRegularName_GreaterEqual(String regularName, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("regularName", ConditionKey.CK_GREATER_EQUAL, regularName);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRegularName_LessEqual(String regularName) {
+        setRegularName_LessEqual(regularName, null);
+    }
+
+    public void setRegularName_LessEqual(String regularName, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("regularName", ConditionKey.CK_LESS_EQUAL, regularName);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_Term(Integer sortOrder) {
+        setSortOrder_Term(sortOrder, null);
+    }
+
+    public void setSortOrder_Term(Integer sortOrder, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("sortOrder", sortOrder);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_Terms(Collection<Integer> sortOrderList) {
+        setSortOrder_Terms(sortOrderList, null);
+    }
+
+    public void setSortOrder_Terms(Collection<Integer> sortOrderList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("sortOrder", sortOrderList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_InScope(Collection<Integer> sortOrderList) {
+        setSortOrder_Terms(sortOrderList, null);
+    }
+
+    public void setSortOrder_InScope(Collection<Integer> sortOrderList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setSortOrder_Terms(sortOrderList, opLambda);
+    }
+
+    public void setSortOrder_Exists() {
+        setSortOrder_Exists(null);
+    }
+
+    public void setSortOrder_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("sortOrder");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_Missing() {
+        setSortOrder_Missing(null);
+    }
+
+    public void setSortOrder_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("sortOrder");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_GreaterThan(Integer sortOrder) {
+        setSortOrder_GreaterThan(sortOrder, null);
+    }
+
+    public void setSortOrder_GreaterThan(Integer sortOrder, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_GREATER_THAN, sortOrder);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_LessThan(Integer sortOrder) {
+        setSortOrder_LessThan(sortOrder, null);
+    }
+
+    public void setSortOrder_LessThan(Integer sortOrder, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_LESS_THAN, sortOrder);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_GreaterEqual(Integer sortOrder) {
+        setSortOrder_GreaterEqual(sortOrder, null);
+    }
+
+    public void setSortOrder_GreaterEqual(Integer sortOrder, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_GREATER_EQUAL, sortOrder);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_LessEqual(Integer sortOrder) {
+        setSortOrder_LessEqual(sortOrder, null);
+    }
+
+    public void setSortOrder_LessEqual(Integer sortOrder, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_LESS_EQUAL, sortOrder);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Term(String updatedBy) {
+        setUpdatedBy_Term(updatedBy, null);
+    }
+
+    public void setUpdatedBy_Term(String updatedBy, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Terms(Collection<String> updatedByList) {
+        setUpdatedBy_Terms(updatedByList, null);
+    }
+
+    public void setUpdatedBy_Terms(Collection<String> updatedByList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("updatedBy", updatedByList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_InScope(Collection<String> updatedByList) {
+        setUpdatedBy_Terms(updatedByList, null);
+    }
+
+    public void setUpdatedBy_InScope(Collection<String> updatedByList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setUpdatedBy_Terms(updatedByList, opLambda);
+    }
+
+    public void setUpdatedBy_Prefix(String updatedBy) {
+        setUpdatedBy_Prefix(updatedBy, null);
+    }
+
+    public void setUpdatedBy_Prefix(String updatedBy, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Exists() {
+        setUpdatedBy_Exists(null);
+    }
+
+    public void setUpdatedBy_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("updatedBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Missing() {
+        setUpdatedBy_Missing(null);
+    }
+
+    public void setUpdatedBy_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("updatedBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_GreaterThan(String updatedBy) {
+        setUpdatedBy_GreaterThan(updatedBy, null);
+    }
+
+    public void setUpdatedBy_GreaterThan(String updatedBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_LessThan(String updatedBy) {
+        setUpdatedBy_LessThan(updatedBy, null);
+    }
+
+    public void setUpdatedBy_LessThan(String updatedBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_GreaterEqual(String updatedBy) {
+        setUpdatedBy_GreaterEqual(updatedBy, null);
+    }
+
+    public void setUpdatedBy_GreaterEqual(String updatedBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_LessEqual(String updatedBy) {
+        setUpdatedBy_LessEqual(updatedBy, null);
+    }
+
+    public void setUpdatedBy_LessEqual(String updatedBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_Term(Long updatedTime) {
+        setUpdatedTime_Term(updatedTime, null);
+    }
+
+    public void setUpdatedTime_Term(Long updatedTime, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("updatedTime", updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_Terms(Collection<Long> updatedTimeList) {
+        setUpdatedTime_Terms(updatedTimeList, null);
+    }
+
+    public void setUpdatedTime_Terms(Collection<Long> updatedTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("updatedTime", updatedTimeList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_InScope(Collection<Long> updatedTimeList) {
+        setUpdatedTime_Terms(updatedTimeList, null);
+    }
+
+    public void setUpdatedTime_InScope(Collection<Long> updatedTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setUpdatedTime_Terms(updatedTimeList, opLambda);
+    }
+
+    public void setUpdatedTime_Exists() {
+        setUpdatedTime_Exists(null);
+    }
+
+    public void setUpdatedTime_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("updatedTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_Missing() {
+        setUpdatedTime_Missing(null);
+    }
+
+    public void setUpdatedTime_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("updatedTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_GreaterThan(Long updatedTime) {
+        setUpdatedTime_GreaterThan(updatedTime, null);
+    }
+
+    public void setUpdatedTime_GreaterThan(Long updatedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_LessThan(Long updatedTime) {
+        setUpdatedTime_LessThan(updatedTime, null);
+    }
+
+    public void setUpdatedTime_LessThan(Long updatedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_GreaterEqual(Long updatedTime) {
+        setUpdatedTime_GreaterEqual(updatedTime, null);
+    }
+
+    public void setUpdatedTime_GreaterEqual(Long updatedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_LessEqual(Long updatedTime) {
+        setUpdatedTime_LessEqual(updatedTime, null);
+    }
+
+    public void setUpdatedTime_LessEqual(Long updatedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+}

src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsPathMappingCF.java

@@ -0,0 +1,1039 @@
+package org.codelibs.fess.es.cbean.cf.bs;
+
+import java.util.Collection;
+
+import org.codelibs.fess.es.cbean.cf.PathMappingCF;
+import org.codelibs.fess.es.cbean.cq.PathMappingCQ;
+import org.dbflute.exception.IllegalConditionBeanOperationException;
+import org.dbflute.cbean.ckey.ConditionKey;
+import org.elasticsearch.index.query.AndFilterBuilder;
+import org.elasticsearch.index.query.BoolFilterBuilder;
+import org.elasticsearch.index.query.ExistsFilterBuilder;
+import org.elasticsearch.index.query.MissingFilterBuilder;
+import org.elasticsearch.index.query.NotFilterBuilder;
+import org.elasticsearch.index.query.OrFilterBuilder;
+import org.elasticsearch.index.query.PrefixFilterBuilder;
+import org.elasticsearch.index.query.QueryFilterBuilder;
+import org.elasticsearch.index.query.RangeFilterBuilder;
+import org.elasticsearch.index.query.TermFilterBuilder;
+import org.elasticsearch.index.query.TermsFilterBuilder;
+
+/**
+ * @author FreeGen
+ */
+public abstract class BsPathMappingCF extends AbstractConditionFilter {
+
+    public void bool(BoolCall<PathMappingCF> boolLambda) {
+        bool(boolLambda, null);
+    }
+
+    public void bool(BoolCall<PathMappingCF> boolLambda, ConditionOptionCall<BoolFilterBuilder> opLambda) {
+        PathMappingCF mustFilter = new PathMappingCF();
+        PathMappingCF shouldFilter = new PathMappingCF();
+        PathMappingCF mustNotFilter = new PathMappingCF();
+        boolLambda.callback(mustFilter, shouldFilter, mustNotFilter);
+        if (mustFilter.hasFilters() || shouldFilter.hasFilters() || mustNotFilter.hasFilters()) {
+            BoolFilterBuilder builder =
+                    regBoolF(mustFilter.filterBuilderList, shouldFilter.filterBuilderList, mustNotFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void and(OperatorCall<PathMappingCF> andLambda) {
+        and(andLambda, null);
+    }
+
+    public void and(OperatorCall<PathMappingCF> andLambda, ConditionOptionCall<AndFilterBuilder> opLambda) {
+        PathMappingCF andFilter = new PathMappingCF();
+        andLambda.callback(andFilter);
+        if (andFilter.hasFilters()) {
+            AndFilterBuilder builder = regAndF(andFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void or(OperatorCall<PathMappingCF> orLambda) {
+        or(orLambda, null);
+    }
+
+    public void or(OperatorCall<PathMappingCF> orLambda, ConditionOptionCall<OrFilterBuilder> opLambda) {
+        PathMappingCF orFilter = new PathMappingCF();
+        orLambda.callback(orFilter);
+        if (orFilter.hasFilters()) {
+            OrFilterBuilder builder = regOrF(orFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void not(OperatorCall<PathMappingCF> notLambda) {
+        not(notLambda, null);
+    }
+
+    public void not(OperatorCall<PathMappingCF> notLambda, ConditionOptionCall<NotFilterBuilder> opLambda) {
+        PathMappingCF notFilter = new PathMappingCF();
+        notLambda.callback(notFilter);
+        if (notFilter.hasFilters()) {
+            if (notFilter.filterBuilderList.size() > 1) {
+                final String msg = "not filter must be one filter.";
+                throw new IllegalConditionBeanOperationException(msg);
+            }
+            NotFilterBuilder builder = regNotF(notFilter.filterBuilderList.get(0));
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall<PathMappingCQ> queryLambda) {
+        query(queryLambda, null);
+    }
+
+    public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall<PathMappingCQ> queryLambda,
+            ConditionOptionCall<QueryFilterBuilder> opLambda) {
+        PathMappingCQ query = new PathMappingCQ();
+        queryLambda.callback(query);
+        if (query.hasQueries()) {
+            QueryFilterBuilder builder = regQueryF(query.getQuery());
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void setCreatedBy_Term(String createdBy) {
+        setCreatedBy_Term(createdBy, null);
+    }
+
+    public void setCreatedBy_Term(String createdBy, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_Terms(Collection<String> createdByList) {
+        setCreatedBy_Terms(createdByList, null);
+    }
+
+    public void setCreatedBy_Terms(Collection<String> createdByList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("createdBy", createdByList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_InScope(Collection<String> createdByList) {
+        setCreatedBy_Terms(createdByList, null);
+    }
+
+    public void setCreatedBy_InScope(Collection<String> createdByList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setCreatedBy_Terms(createdByList, opLambda);
+    }
+
+    public void setCreatedBy_Prefix(String createdBy) {
+        setCreatedBy_Prefix(createdBy, null);
+    }
+
+    public void setCreatedBy_Prefix(String createdBy, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_Exists() {
+        setCreatedBy_Exists(null);
+    }
+
+    public void setCreatedBy_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("createdBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_Missing() {
+        setCreatedBy_Missing(null);
+    }
+
+    public void setCreatedBy_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("createdBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_GreaterThan(String createdBy) {
+        setCreatedBy_GreaterThan(createdBy, null);
+    }
+
+    public void setCreatedBy_GreaterThan(String createdBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_GREATER_THAN, createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_LessThan(String createdBy) {
+        setCreatedBy_LessThan(createdBy, null);
+    }
+
+    public void setCreatedBy_LessThan(String createdBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_LESS_THAN, createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_GreaterEqual(String createdBy) {
+        setCreatedBy_GreaterEqual(createdBy, null);
+    }
+
+    public void setCreatedBy_GreaterEqual(String createdBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_LessEqual(String createdBy) {
+        setCreatedBy_LessEqual(createdBy, null);
+    }
+
+    public void setCreatedBy_LessEqual(String createdBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_Term(Long createdTime) {
+        setCreatedTime_Term(createdTime, null);
+    }
+
+    public void setCreatedTime_Term(Long createdTime, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("createdTime", createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_Terms(Collection<Long> createdTimeList) {
+        setCreatedTime_Terms(createdTimeList, null);
+    }
+
+    public void setCreatedTime_Terms(Collection<Long> createdTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("createdTime", createdTimeList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_InScope(Collection<Long> createdTimeList) {
+        setCreatedTime_Terms(createdTimeList, null);
+    }
+
+    public void setCreatedTime_InScope(Collection<Long> createdTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setCreatedTime_Terms(createdTimeList, opLambda);
+    }
+
+    public void setCreatedTime_Exists() {
+        setCreatedTime_Exists(null);
+    }
+
+    public void setCreatedTime_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("createdTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_Missing() {
+        setCreatedTime_Missing(null);
+    }
+
+    public void setCreatedTime_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("createdTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_GreaterThan(Long createdTime) {
+        setCreatedTime_GreaterThan(createdTime, null);
+    }
+
+    public void setCreatedTime_GreaterThan(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_THAN, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_LessThan(Long createdTime) {
+        setCreatedTime_LessThan(createdTime, null);
+    }
+
+    public void setCreatedTime_LessThan(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_THAN, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_GreaterEqual(Long createdTime) {
+        setCreatedTime_GreaterEqual(createdTime, null);
+    }
+
+    public void setCreatedTime_GreaterEqual(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_LessEqual(Long createdTime) {
+        setCreatedTime_LessEqual(createdTime, null);
+    }
+
+    public void setCreatedTime_LessEqual(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Term(String id) {
+        setId_Term(id, null);
+    }
+
+    public void setId_Term(String id, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("id", id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Terms(Collection<String> idList) {
+        setId_Terms(idList, null);
+    }
+
+    public void setId_Terms(Collection<String> idList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("id", idList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_InScope(Collection<String> idList) {
+        setId_Terms(idList, null);
+    }
+
+    public void setId_InScope(Collection<String> idList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setId_Terms(idList, opLambda);
+    }
+
+    public void setId_Prefix(String id) {
+        setId_Prefix(id, null);
+    }
+
+    public void setId_Prefix(String id, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("id", id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Exists() {
+        setId_Exists(null);
+    }
+
+    public void setId_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("id");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Missing() {
+        setId_Missing(null);
+    }
+
+    public void setId_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("id");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_GreaterThan(String id) {
+        setId_GreaterThan(id, null);
+    }
+
+    public void setId_GreaterThan(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_THAN, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_LessThan(String id) {
+        setId_LessThan(id, null);
+    }
+
+    public void setId_LessThan(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_THAN, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_GreaterEqual(String id) {
+        setId_GreaterEqual(id, null);
+    }
+
+    public void setId_GreaterEqual(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_EQUAL, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_LessEqual(String id) {
+        setId_LessEqual(id, null);
+    }
+
+    public void setId_LessEqual(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_EQUAL, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setProcessType_Term(String processType) {
+        setProcessType_Term(processType, null);
+    }
+
+    public void setProcessType_Term(String processType, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("processType", processType);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setProcessType_Terms(Collection<String> processTypeList) {
+        setProcessType_Terms(processTypeList, null);
+    }
+
+    public void setProcessType_Terms(Collection<String> processTypeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("processType", processTypeList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setProcessType_InScope(Collection<String> processTypeList) {
+        setProcessType_Terms(processTypeList, null);
+    }
+
+    public void setProcessType_InScope(Collection<String> processTypeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setProcessType_Terms(processTypeList, opLambda);
+    }
+
+    public void setProcessType_Prefix(String processType) {
+        setProcessType_Prefix(processType, null);
+    }
+
+    public void setProcessType_Prefix(String processType, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("processType", processType);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setProcessType_Exists() {
+        setProcessType_Exists(null);
+    }
+
+    public void setProcessType_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("processType");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setProcessType_Missing() {
+        setProcessType_Missing(null);
+    }
+
+    public void setProcessType_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("processType");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setProcessType_GreaterThan(String processType) {
+        setProcessType_GreaterThan(processType, null);
+    }
+
+    public void setProcessType_GreaterThan(String processType, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("processType", ConditionKey.CK_GREATER_THAN, processType);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setProcessType_LessThan(String processType) {
+        setProcessType_LessThan(processType, null);
+    }
+
+    public void setProcessType_LessThan(String processType, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("processType", ConditionKey.CK_LESS_THAN, processType);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setProcessType_GreaterEqual(String processType) {
+        setProcessType_GreaterEqual(processType, null);
+    }
+
+    public void setProcessType_GreaterEqual(String processType, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("processType", ConditionKey.CK_GREATER_EQUAL, processType);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setProcessType_LessEqual(String processType) {
+        setProcessType_LessEqual(processType, null);
+    }
+
+    public void setProcessType_LessEqual(String processType, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("processType", ConditionKey.CK_LESS_EQUAL, processType);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRegex_Term(String regex) {
+        setRegex_Term(regex, null);
+    }
+
+    public void setRegex_Term(String regex, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("regex", regex);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRegex_Terms(Collection<String> regexList) {
+        setRegex_Terms(regexList, null);
+    }
+
+    public void setRegex_Terms(Collection<String> regexList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("regex", regexList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRegex_InScope(Collection<String> regexList) {
+        setRegex_Terms(regexList, null);
+    }
+
+    public void setRegex_InScope(Collection<String> regexList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setRegex_Terms(regexList, opLambda);
+    }
+
+    public void setRegex_Prefix(String regex) {
+        setRegex_Prefix(regex, null);
+    }
+
+    public void setRegex_Prefix(String regex, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("regex", regex);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRegex_Exists() {
+        setRegex_Exists(null);
+    }
+
+    public void setRegex_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("regex");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRegex_Missing() {
+        setRegex_Missing(null);
+    }
+
+    public void setRegex_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("regex");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRegex_GreaterThan(String regex) {
+        setRegex_GreaterThan(regex, null);
+    }
+
+    public void setRegex_GreaterThan(String regex, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("regex", ConditionKey.CK_GREATER_THAN, regex);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRegex_LessThan(String regex) {
+        setRegex_LessThan(regex, null);
+    }
+
+    public void setRegex_LessThan(String regex, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("regex", ConditionKey.CK_LESS_THAN, regex);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRegex_GreaterEqual(String regex) {
+        setRegex_GreaterEqual(regex, null);
+    }
+
+    public void setRegex_GreaterEqual(String regex, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("regex", ConditionKey.CK_GREATER_EQUAL, regex);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRegex_LessEqual(String regex) {
+        setRegex_LessEqual(regex, null);
+    }
+
+    public void setRegex_LessEqual(String regex, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("regex", ConditionKey.CK_LESS_EQUAL, regex);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setReplacement_Term(String replacement) {
+        setReplacement_Term(replacement, null);
+    }
+
+    public void setReplacement_Term(String replacement, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("replacement", replacement);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setReplacement_Terms(Collection<String> replacementList) {
+        setReplacement_Terms(replacementList, null);
+    }
+
+    public void setReplacement_Terms(Collection<String> replacementList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("replacement", replacementList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setReplacement_InScope(Collection<String> replacementList) {
+        setReplacement_Terms(replacementList, null);
+    }
+
+    public void setReplacement_InScope(Collection<String> replacementList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setReplacement_Terms(replacementList, opLambda);
+    }
+
+    public void setReplacement_Prefix(String replacement) {
+        setReplacement_Prefix(replacement, null);
+    }
+
+    public void setReplacement_Prefix(String replacement, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("replacement", replacement);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setReplacement_Exists() {
+        setReplacement_Exists(null);
+    }
+
+    public void setReplacement_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("replacement");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setReplacement_Missing() {
+        setReplacement_Missing(null);
+    }
+
+    public void setReplacement_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("replacement");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setReplacement_GreaterThan(String replacement) {
+        setReplacement_GreaterThan(replacement, null);
+    }
+
+    public void setReplacement_GreaterThan(String replacement, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("replacement", ConditionKey.CK_GREATER_THAN, replacement);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setReplacement_LessThan(String replacement) {
+        setReplacement_LessThan(replacement, null);
+    }
+
+    public void setReplacement_LessThan(String replacement, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("replacement", ConditionKey.CK_LESS_THAN, replacement);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setReplacement_GreaterEqual(String replacement) {
+        setReplacement_GreaterEqual(replacement, null);
+    }
+
+    public void setReplacement_GreaterEqual(String replacement, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("replacement", ConditionKey.CK_GREATER_EQUAL, replacement);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setReplacement_LessEqual(String replacement) {
+        setReplacement_LessEqual(replacement, null);
+    }
+
+    public void setReplacement_LessEqual(String replacement, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("replacement", ConditionKey.CK_LESS_EQUAL, replacement);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_Term(Integer sortOrder) {
+        setSortOrder_Term(sortOrder, null);
+    }
+
+    public void setSortOrder_Term(Integer sortOrder, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("sortOrder", sortOrder);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_Terms(Collection<Integer> sortOrderList) {
+        setSortOrder_Terms(sortOrderList, null);
+    }
+
+    public void setSortOrder_Terms(Collection<Integer> sortOrderList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("sortOrder", sortOrderList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_InScope(Collection<Integer> sortOrderList) {
+        setSortOrder_Terms(sortOrderList, null);
+    }
+
+    public void setSortOrder_InScope(Collection<Integer> sortOrderList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setSortOrder_Terms(sortOrderList, opLambda);
+    }
+
+    public void setSortOrder_Exists() {
+        setSortOrder_Exists(null);
+    }
+
+    public void setSortOrder_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("sortOrder");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_Missing() {
+        setSortOrder_Missing(null);
+    }
+
+    public void setSortOrder_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("sortOrder");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_GreaterThan(Integer sortOrder) {
+        setSortOrder_GreaterThan(sortOrder, null);
+    }
+
+    public void setSortOrder_GreaterThan(Integer sortOrder, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_GREATER_THAN, sortOrder);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_LessThan(Integer sortOrder) {
+        setSortOrder_LessThan(sortOrder, null);
+    }
+
+    public void setSortOrder_LessThan(Integer sortOrder, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_LESS_THAN, sortOrder);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_GreaterEqual(Integer sortOrder) {
+        setSortOrder_GreaterEqual(sortOrder, null);
+    }
+
+    public void setSortOrder_GreaterEqual(Integer sortOrder, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_GREATER_EQUAL, sortOrder);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_LessEqual(Integer sortOrder) {
+        setSortOrder_LessEqual(sortOrder, null);
+    }
+
+    public void setSortOrder_LessEqual(Integer sortOrder, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_LESS_EQUAL, sortOrder);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Term(String updatedBy) {
+        setUpdatedBy_Term(updatedBy, null);
+    }
+
+    public void setUpdatedBy_Term(String updatedBy, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Terms(Collection<String> updatedByList) {
+        setUpdatedBy_Terms(updatedByList, null);
+    }
+
+    public void setUpdatedBy_Terms(Collection<String> updatedByList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("updatedBy", updatedByList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_InScope(Collection<String> updatedByList) {
+        setUpdatedBy_Terms(updatedByList, null);
+    }
+
+    public void setUpdatedBy_InScope(Collection<String> updatedByList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setUpdatedBy_Terms(updatedByList, opLambda);
+    }
+
+    public void setUpdatedBy_Prefix(String updatedBy) {
+        setUpdatedBy_Prefix(updatedBy, null);
+    }
+
+    public void setUpdatedBy_Prefix(String updatedBy, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Exists() {
+        setUpdatedBy_Exists(null);
+    }
+
+    public void setUpdatedBy_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("updatedBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Missing() {
+        setUpdatedBy_Missing(null);
+    }
+
+    public void setUpdatedBy_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("updatedBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_GreaterThan(String updatedBy) {
+        setUpdatedBy_GreaterThan(updatedBy, null);
+    }
+
+    public void setUpdatedBy_GreaterThan(String updatedBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_LessThan(String updatedBy) {
+        setUpdatedBy_LessThan(updatedBy, null);
+    }
+
+    public void setUpdatedBy_LessThan(String updatedBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_GreaterEqual(String updatedBy) {
+        setUpdatedBy_GreaterEqual(updatedBy, null);
+    }
+
+    public void setUpdatedBy_GreaterEqual(String updatedBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_LessEqual(String updatedBy) {
+        setUpdatedBy_LessEqual(updatedBy, null);
+    }
+
+    public void setUpdatedBy_LessEqual(String updatedBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_Term(Long updatedTime) {
+        setUpdatedTime_Term(updatedTime, null);
+    }
+
+    public void setUpdatedTime_Term(Long updatedTime, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("updatedTime", updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_Terms(Collection<Long> updatedTimeList) {
+        setUpdatedTime_Terms(updatedTimeList, null);
+    }
+
+    public void setUpdatedTime_Terms(Collection<Long> updatedTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("updatedTime", updatedTimeList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_InScope(Collection<Long> updatedTimeList) {
+        setUpdatedTime_Terms(updatedTimeList, null);
+    }
+
+    public void setUpdatedTime_InScope(Collection<Long> updatedTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setUpdatedTime_Terms(updatedTimeList, opLambda);
+    }
+
+    public void setUpdatedTime_Exists() {
+        setUpdatedTime_Exists(null);
+    }
+
+    public void setUpdatedTime_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("updatedTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_Missing() {
+        setUpdatedTime_Missing(null);
+    }
+
+    public void setUpdatedTime_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("updatedTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_GreaterThan(Long updatedTime) {
+        setUpdatedTime_GreaterThan(updatedTime, null);
+    }
+
+    public void setUpdatedTime_GreaterThan(Long updatedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_LessThan(Long updatedTime) {
+        setUpdatedTime_LessThan(updatedTime, null);
+    }
+
+    public void setUpdatedTime_LessThan(Long updatedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_GreaterEqual(Long updatedTime) {
+        setUpdatedTime_GreaterEqual(updatedTime, null);
+    }
+
+    public void setUpdatedTime_GreaterEqual(Long updatedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_LessEqual(Long updatedTime) {
+        setUpdatedTime_LessEqual(updatedTime, null);
+    }
+
+    public void setUpdatedTime_LessEqual(Long updatedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+}

src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsRequestHeaderCF.java

@@ -0,0 +1,943 @@
+package org.codelibs.fess.es.cbean.cf.bs;
+
+import java.util.Collection;
+
+import org.codelibs.fess.es.cbean.cf.RequestHeaderCF;
+import org.codelibs.fess.es.cbean.cq.RequestHeaderCQ;
+import org.dbflute.exception.IllegalConditionBeanOperationException;
+import org.dbflute.cbean.ckey.ConditionKey;
+import org.elasticsearch.index.query.AndFilterBuilder;
+import org.elasticsearch.index.query.BoolFilterBuilder;
+import org.elasticsearch.index.query.ExistsFilterBuilder;
+import org.elasticsearch.index.query.MissingFilterBuilder;
+import org.elasticsearch.index.query.NotFilterBuilder;
+import org.elasticsearch.index.query.OrFilterBuilder;
+import org.elasticsearch.index.query.PrefixFilterBuilder;
+import org.elasticsearch.index.query.QueryFilterBuilder;
+import org.elasticsearch.index.query.RangeFilterBuilder;
+import org.elasticsearch.index.query.TermFilterBuilder;
+import org.elasticsearch.index.query.TermsFilterBuilder;
+
+/**
+ * @author FreeGen
+ */
+public abstract class BsRequestHeaderCF extends AbstractConditionFilter {
+
+    public void bool(BoolCall<RequestHeaderCF> boolLambda) {
+        bool(boolLambda, null);
+    }
+
+    public void bool(BoolCall<RequestHeaderCF> boolLambda, ConditionOptionCall<BoolFilterBuilder> opLambda) {
+        RequestHeaderCF mustFilter = new RequestHeaderCF();
+        RequestHeaderCF shouldFilter = new RequestHeaderCF();
+        RequestHeaderCF mustNotFilter = new RequestHeaderCF();
+        boolLambda.callback(mustFilter, shouldFilter, mustNotFilter);
+        if (mustFilter.hasFilters() || shouldFilter.hasFilters() || mustNotFilter.hasFilters()) {
+            BoolFilterBuilder builder =
+                    regBoolF(mustFilter.filterBuilderList, shouldFilter.filterBuilderList, mustNotFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void and(OperatorCall<RequestHeaderCF> andLambda) {
+        and(andLambda, null);
+    }
+
+    public void and(OperatorCall<RequestHeaderCF> andLambda, ConditionOptionCall<AndFilterBuilder> opLambda) {
+        RequestHeaderCF andFilter = new RequestHeaderCF();
+        andLambda.callback(andFilter);
+        if (andFilter.hasFilters()) {
+            AndFilterBuilder builder = regAndF(andFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void or(OperatorCall<RequestHeaderCF> orLambda) {
+        or(orLambda, null);
+    }
+
+    public void or(OperatorCall<RequestHeaderCF> orLambda, ConditionOptionCall<OrFilterBuilder> opLambda) {
+        RequestHeaderCF orFilter = new RequestHeaderCF();
+        orLambda.callback(orFilter);
+        if (orFilter.hasFilters()) {
+            OrFilterBuilder builder = regOrF(orFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void not(OperatorCall<RequestHeaderCF> notLambda) {
+        not(notLambda, null);
+    }
+
+    public void not(OperatorCall<RequestHeaderCF> notLambda, ConditionOptionCall<NotFilterBuilder> opLambda) {
+        RequestHeaderCF notFilter = new RequestHeaderCF();
+        notLambda.callback(notFilter);
+        if (notFilter.hasFilters()) {
+            if (notFilter.filterBuilderList.size() > 1) {
+                final String msg = "not filter must be one filter.";
+                throw new IllegalConditionBeanOperationException(msg);
+            }
+            NotFilterBuilder builder = regNotF(notFilter.filterBuilderList.get(0));
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall<RequestHeaderCQ> queryLambda) {
+        query(queryLambda, null);
+    }
+
+    public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall<RequestHeaderCQ> queryLambda,
+            ConditionOptionCall<QueryFilterBuilder> opLambda) {
+        RequestHeaderCQ query = new RequestHeaderCQ();
+        queryLambda.callback(query);
+        if (query.hasQueries()) {
+            QueryFilterBuilder builder = regQueryF(query.getQuery());
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void setCreatedBy_Term(String createdBy) {
+        setCreatedBy_Term(createdBy, null);
+    }
+
+    public void setCreatedBy_Term(String createdBy, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_Terms(Collection<String> createdByList) {
+        setCreatedBy_Terms(createdByList, null);
+    }
+
+    public void setCreatedBy_Terms(Collection<String> createdByList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("createdBy", createdByList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_InScope(Collection<String> createdByList) {
+        setCreatedBy_Terms(createdByList, null);
+    }
+
+    public void setCreatedBy_InScope(Collection<String> createdByList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setCreatedBy_Terms(createdByList, opLambda);
+    }
+
+    public void setCreatedBy_Prefix(String createdBy) {
+        setCreatedBy_Prefix(createdBy, null);
+    }
+
+    public void setCreatedBy_Prefix(String createdBy, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_Exists() {
+        setCreatedBy_Exists(null);
+    }
+
+    public void setCreatedBy_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("createdBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_Missing() {
+        setCreatedBy_Missing(null);
+    }
+
+    public void setCreatedBy_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("createdBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_GreaterThan(String createdBy) {
+        setCreatedBy_GreaterThan(createdBy, null);
+    }
+
+    public void setCreatedBy_GreaterThan(String createdBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_GREATER_THAN, createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_LessThan(String createdBy) {
+        setCreatedBy_LessThan(createdBy, null);
+    }
+
+    public void setCreatedBy_LessThan(String createdBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_LESS_THAN, createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_GreaterEqual(String createdBy) {
+        setCreatedBy_GreaterEqual(createdBy, null);
+    }
+
+    public void setCreatedBy_GreaterEqual(String createdBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_LessEqual(String createdBy) {
+        setCreatedBy_LessEqual(createdBy, null);
+    }
+
+    public void setCreatedBy_LessEqual(String createdBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_Term(Long createdTime) {
+        setCreatedTime_Term(createdTime, null);
+    }
+
+    public void setCreatedTime_Term(Long createdTime, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("createdTime", createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_Terms(Collection<Long> createdTimeList) {
+        setCreatedTime_Terms(createdTimeList, null);
+    }
+
+    public void setCreatedTime_Terms(Collection<Long> createdTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("createdTime", createdTimeList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_InScope(Collection<Long> createdTimeList) {
+        setCreatedTime_Terms(createdTimeList, null);
+    }
+
+    public void setCreatedTime_InScope(Collection<Long> createdTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setCreatedTime_Terms(createdTimeList, opLambda);
+    }
+
+    public void setCreatedTime_Exists() {
+        setCreatedTime_Exists(null);
+    }
+
+    public void setCreatedTime_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("createdTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_Missing() {
+        setCreatedTime_Missing(null);
+    }
+
+    public void setCreatedTime_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("createdTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_GreaterThan(Long createdTime) {
+        setCreatedTime_GreaterThan(createdTime, null);
+    }
+
+    public void setCreatedTime_GreaterThan(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_THAN, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_LessThan(Long createdTime) {
+        setCreatedTime_LessThan(createdTime, null);
+    }
+
+    public void setCreatedTime_LessThan(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_THAN, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_GreaterEqual(Long createdTime) {
+        setCreatedTime_GreaterEqual(createdTime, null);
+    }
+
+    public void setCreatedTime_GreaterEqual(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_LessEqual(Long createdTime) {
+        setCreatedTime_LessEqual(createdTime, null);
+    }
+
+    public void setCreatedTime_LessEqual(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Term(String id) {
+        setId_Term(id, null);
+    }
+
+    public void setId_Term(String id, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("id", id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Terms(Collection<String> idList) {
+        setId_Terms(idList, null);
+    }
+
+    public void setId_Terms(Collection<String> idList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("id", idList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_InScope(Collection<String> idList) {
+        setId_Terms(idList, null);
+    }
+
+    public void setId_InScope(Collection<String> idList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setId_Terms(idList, opLambda);
+    }
+
+    public void setId_Prefix(String id) {
+        setId_Prefix(id, null);
+    }
+
+    public void setId_Prefix(String id, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("id", id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Exists() {
+        setId_Exists(null);
+    }
+
+    public void setId_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("id");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Missing() {
+        setId_Missing(null);
+    }
+
+    public void setId_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("id");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_GreaterThan(String id) {
+        setId_GreaterThan(id, null);
+    }
+
+    public void setId_GreaterThan(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_THAN, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_LessThan(String id) {
+        setId_LessThan(id, null);
+    }
+
+    public void setId_LessThan(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_THAN, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_GreaterEqual(String id) {
+        setId_GreaterEqual(id, null);
+    }
+
+    public void setId_GreaterEqual(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_EQUAL, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_LessEqual(String id) {
+        setId_LessEqual(id, null);
+    }
+
+    public void setId_LessEqual(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_EQUAL, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_Term(String name) {
+        setName_Term(name, null);
+    }
+
+    public void setName_Term(String name, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("name", name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_Terms(Collection<String> nameList) {
+        setName_Terms(nameList, null);
+    }
+
+    public void setName_Terms(Collection<String> nameList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("name", nameList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_InScope(Collection<String> nameList) {
+        setName_Terms(nameList, null);
+    }
+
+    public void setName_InScope(Collection<String> nameList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setName_Terms(nameList, opLambda);
+    }
+
+    public void setName_Prefix(String name) {
+        setName_Prefix(name, null);
+    }
+
+    public void setName_Prefix(String name, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("name", name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_Exists() {
+        setName_Exists(null);
+    }
+
+    public void setName_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("name");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_Missing() {
+        setName_Missing(null);
+    }
+
+    public void setName_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("name");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_GreaterThan(String name) {
+        setName_GreaterThan(name, null);
+    }
+
+    public void setName_GreaterThan(String name, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_GREATER_THAN, name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_LessThan(String name) {
+        setName_LessThan(name, null);
+    }
+
+    public void setName_LessThan(String name, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_LESS_THAN, name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_GreaterEqual(String name) {
+        setName_GreaterEqual(name, null);
+    }
+
+    public void setName_GreaterEqual(String name, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_GREATER_EQUAL, name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_LessEqual(String name) {
+        setName_LessEqual(name, null);
+    }
+
+    public void setName_LessEqual(String name, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_LESS_EQUAL, name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Term(String updatedBy) {
+        setUpdatedBy_Term(updatedBy, null);
+    }
+
+    public void setUpdatedBy_Term(String updatedBy, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Terms(Collection<String> updatedByList) {
+        setUpdatedBy_Terms(updatedByList, null);
+    }
+
+    public void setUpdatedBy_Terms(Collection<String> updatedByList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("updatedBy", updatedByList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_InScope(Collection<String> updatedByList) {
+        setUpdatedBy_Terms(updatedByList, null);
+    }
+
+    public void setUpdatedBy_InScope(Collection<String> updatedByList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setUpdatedBy_Terms(updatedByList, opLambda);
+    }
+
+    public void setUpdatedBy_Prefix(String updatedBy) {
+        setUpdatedBy_Prefix(updatedBy, null);
+    }
+
+    public void setUpdatedBy_Prefix(String updatedBy, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Exists() {
+        setUpdatedBy_Exists(null);
+    }
+
+    public void setUpdatedBy_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("updatedBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Missing() {
+        setUpdatedBy_Missing(null);
+    }
+
+    public void setUpdatedBy_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("updatedBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_GreaterThan(String updatedBy) {
+        setUpdatedBy_GreaterThan(updatedBy, null);
+    }
+
+    public void setUpdatedBy_GreaterThan(String updatedBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_LessThan(String updatedBy) {
+        setUpdatedBy_LessThan(updatedBy, null);
+    }
+
+    public void setUpdatedBy_LessThan(String updatedBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_GreaterEqual(String updatedBy) {
+        setUpdatedBy_GreaterEqual(updatedBy, null);
+    }
+
+    public void setUpdatedBy_GreaterEqual(String updatedBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_LessEqual(String updatedBy) {
+        setUpdatedBy_LessEqual(updatedBy, null);
+    }
+
+    public void setUpdatedBy_LessEqual(String updatedBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_Term(Long updatedTime) {
+        setUpdatedTime_Term(updatedTime, null);
+    }
+
+    public void setUpdatedTime_Term(Long updatedTime, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("updatedTime", updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_Terms(Collection<Long> updatedTimeList) {
+        setUpdatedTime_Terms(updatedTimeList, null);
+    }
+
+    public void setUpdatedTime_Terms(Collection<Long> updatedTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("updatedTime", updatedTimeList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_InScope(Collection<Long> updatedTimeList) {
+        setUpdatedTime_Terms(updatedTimeList, null);
+    }
+
+    public void setUpdatedTime_InScope(Collection<Long> updatedTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setUpdatedTime_Terms(updatedTimeList, opLambda);
+    }
+
+    public void setUpdatedTime_Exists() {
+        setUpdatedTime_Exists(null);
+    }
+
+    public void setUpdatedTime_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("updatedTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_Missing() {
+        setUpdatedTime_Missing(null);
+    }
+
+    public void setUpdatedTime_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("updatedTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_GreaterThan(Long updatedTime) {
+        setUpdatedTime_GreaterThan(updatedTime, null);
+    }
+
+    public void setUpdatedTime_GreaterThan(Long updatedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_LessThan(Long updatedTime) {
+        setUpdatedTime_LessThan(updatedTime, null);
+    }
+
+    public void setUpdatedTime_LessThan(Long updatedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_GreaterEqual(Long updatedTime) {
+        setUpdatedTime_GreaterEqual(updatedTime, null);
+    }
+
+    public void setUpdatedTime_GreaterEqual(Long updatedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_LessEqual(Long updatedTime) {
+        setUpdatedTime_LessEqual(updatedTime, null);
+    }
+
+    public void setUpdatedTime_LessEqual(Long updatedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setValue_Term(String value) {
+        setValue_Term(value, null);
+    }
+
+    public void setValue_Term(String value, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("value", value);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setValue_Terms(Collection<String> valueList) {
+        setValue_Terms(valueList, null);
+    }
+
+    public void setValue_Terms(Collection<String> valueList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("value", valueList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setValue_InScope(Collection<String> valueList) {
+        setValue_Terms(valueList, null);
+    }
+
+    public void setValue_InScope(Collection<String> valueList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setValue_Terms(valueList, opLambda);
+    }
+
+    public void setValue_Prefix(String value) {
+        setValue_Prefix(value, null);
+    }
+
+    public void setValue_Prefix(String value, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("value", value);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setValue_Exists() {
+        setValue_Exists(null);
+    }
+
+    public void setValue_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("value");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setValue_Missing() {
+        setValue_Missing(null);
+    }
+
+    public void setValue_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("value");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setValue_GreaterThan(String value) {
+        setValue_GreaterThan(value, null);
+    }
+
+    public void setValue_GreaterThan(String value, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("value", ConditionKey.CK_GREATER_THAN, value);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setValue_LessThan(String value) {
+        setValue_LessThan(value, null);
+    }
+
+    public void setValue_LessThan(String value, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("value", ConditionKey.CK_LESS_THAN, value);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setValue_GreaterEqual(String value) {
+        setValue_GreaterEqual(value, null);
+    }
+
+    public void setValue_GreaterEqual(String value, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("value", ConditionKey.CK_GREATER_EQUAL, value);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setValue_LessEqual(String value) {
+        setValue_LessEqual(value, null);
+    }
+
+    public void setValue_LessEqual(String value, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("value", ConditionKey.CK_LESS_EQUAL, value);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setWebConfigId_Term(String webConfigId) {
+        setWebConfigId_Term(webConfigId, null);
+    }
+
+    public void setWebConfigId_Term(String webConfigId, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("webConfigId", webConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setWebConfigId_Terms(Collection<String> webConfigIdList) {
+        setWebConfigId_Terms(webConfigIdList, null);
+    }
+
+    public void setWebConfigId_Terms(Collection<String> webConfigIdList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("webConfigId", webConfigIdList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setWebConfigId_InScope(Collection<String> webConfigIdList) {
+        setWebConfigId_Terms(webConfigIdList, null);
+    }
+
+    public void setWebConfigId_InScope(Collection<String> webConfigIdList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setWebConfigId_Terms(webConfigIdList, opLambda);
+    }
+
+    public void setWebConfigId_Prefix(String webConfigId) {
+        setWebConfigId_Prefix(webConfigId, null);
+    }
+
+    public void setWebConfigId_Prefix(String webConfigId, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("webConfigId", webConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setWebConfigId_Exists() {
+        setWebConfigId_Exists(null);
+    }
+
+    public void setWebConfigId_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("webConfigId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setWebConfigId_Missing() {
+        setWebConfigId_Missing(null);
+    }
+
+    public void setWebConfigId_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("webConfigId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setWebConfigId_GreaterThan(String webConfigId) {
+        setWebConfigId_GreaterThan(webConfigId, null);
+    }
+
+    public void setWebConfigId_GreaterThan(String webConfigId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("webConfigId", ConditionKey.CK_GREATER_THAN, webConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setWebConfigId_LessThan(String webConfigId) {
+        setWebConfigId_LessThan(webConfigId, null);
+    }
+
+    public void setWebConfigId_LessThan(String webConfigId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("webConfigId", ConditionKey.CK_LESS_THAN, webConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setWebConfigId_GreaterEqual(String webConfigId) {
+        setWebConfigId_GreaterEqual(webConfigId, null);
+    }
+
+    public void setWebConfigId_GreaterEqual(String webConfigId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("webConfigId", ConditionKey.CK_GREATER_EQUAL, webConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setWebConfigId_LessEqual(String webConfigId) {
+        setWebConfigId_LessEqual(webConfigId, null);
+    }
+
+    public void setWebConfigId_LessEqual(String webConfigId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("webConfigId", ConditionKey.CK_LESS_EQUAL, webConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+}

src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsRoleTypeCF.java

@@ -0,0 +1,932 @@
+package org.codelibs.fess.es.cbean.cf.bs;
+
+import java.util.Collection;
+
+import org.codelibs.fess.es.cbean.cf.RoleTypeCF;
+import org.codelibs.fess.es.cbean.cq.RoleTypeCQ;
+import org.dbflute.exception.IllegalConditionBeanOperationException;
+import org.dbflute.cbean.ckey.ConditionKey;
+import org.elasticsearch.index.query.AndFilterBuilder;
+import org.elasticsearch.index.query.BoolFilterBuilder;
+import org.elasticsearch.index.query.ExistsFilterBuilder;
+import org.elasticsearch.index.query.MissingFilterBuilder;
+import org.elasticsearch.index.query.NotFilterBuilder;
+import org.elasticsearch.index.query.OrFilterBuilder;
+import org.elasticsearch.index.query.PrefixFilterBuilder;
+import org.elasticsearch.index.query.QueryFilterBuilder;
+import org.elasticsearch.index.query.RangeFilterBuilder;
+import org.elasticsearch.index.query.TermFilterBuilder;
+import org.elasticsearch.index.query.TermsFilterBuilder;
+
+/**
+ * @author FreeGen
+ */
+public abstract class BsRoleTypeCF extends AbstractConditionFilter {
+
+    public void bool(BoolCall<RoleTypeCF> boolLambda) {
+        bool(boolLambda, null);
+    }
+
+    public void bool(BoolCall<RoleTypeCF> boolLambda, ConditionOptionCall<BoolFilterBuilder> opLambda) {
+        RoleTypeCF mustFilter = new RoleTypeCF();
+        RoleTypeCF shouldFilter = new RoleTypeCF();
+        RoleTypeCF mustNotFilter = new RoleTypeCF();
+        boolLambda.callback(mustFilter, shouldFilter, mustNotFilter);
+        if (mustFilter.hasFilters() || shouldFilter.hasFilters() || mustNotFilter.hasFilters()) {
+            BoolFilterBuilder builder =
+                    regBoolF(mustFilter.filterBuilderList, shouldFilter.filterBuilderList, mustNotFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void and(OperatorCall<RoleTypeCF> andLambda) {
+        and(andLambda, null);
+    }
+
+    public void and(OperatorCall<RoleTypeCF> andLambda, ConditionOptionCall<AndFilterBuilder> opLambda) {
+        RoleTypeCF andFilter = new RoleTypeCF();
+        andLambda.callback(andFilter);
+        if (andFilter.hasFilters()) {
+            AndFilterBuilder builder = regAndF(andFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void or(OperatorCall<RoleTypeCF> orLambda) {
+        or(orLambda, null);
+    }
+
+    public void or(OperatorCall<RoleTypeCF> orLambda, ConditionOptionCall<OrFilterBuilder> opLambda) {
+        RoleTypeCF orFilter = new RoleTypeCF();
+        orLambda.callback(orFilter);
+        if (orFilter.hasFilters()) {
+            OrFilterBuilder builder = regOrF(orFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void not(OperatorCall<RoleTypeCF> notLambda) {
+        not(notLambda, null);
+    }
+
+    public void not(OperatorCall<RoleTypeCF> notLambda, ConditionOptionCall<NotFilterBuilder> opLambda) {
+        RoleTypeCF notFilter = new RoleTypeCF();
+        notLambda.callback(notFilter);
+        if (notFilter.hasFilters()) {
+            if (notFilter.filterBuilderList.size() > 1) {
+                final String msg = "not filter must be one filter.";
+                throw new IllegalConditionBeanOperationException(msg);
+            }
+            NotFilterBuilder builder = regNotF(notFilter.filterBuilderList.get(0));
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall<RoleTypeCQ> queryLambda) {
+        query(queryLambda, null);
+    }
+
+    public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall<RoleTypeCQ> queryLambda,
+            ConditionOptionCall<QueryFilterBuilder> opLambda) {
+        RoleTypeCQ query = new RoleTypeCQ();
+        queryLambda.callback(query);
+        if (query.hasQueries()) {
+            QueryFilterBuilder builder = regQueryF(query.getQuery());
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void setCreatedBy_Term(String createdBy) {
+        setCreatedBy_Term(createdBy, null);
+    }
+
+    public void setCreatedBy_Term(String createdBy, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_Terms(Collection<String> createdByList) {
+        setCreatedBy_Terms(createdByList, null);
+    }
+
+    public void setCreatedBy_Terms(Collection<String> createdByList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("createdBy", createdByList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_InScope(Collection<String> createdByList) {
+        setCreatedBy_Terms(createdByList, null);
+    }
+
+    public void setCreatedBy_InScope(Collection<String> createdByList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setCreatedBy_Terms(createdByList, opLambda);
+    }
+
+    public void setCreatedBy_Prefix(String createdBy) {
+        setCreatedBy_Prefix(createdBy, null);
+    }
+
+    public void setCreatedBy_Prefix(String createdBy, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_Exists() {
+        setCreatedBy_Exists(null);
+    }
+
+    public void setCreatedBy_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("createdBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_Missing() {
+        setCreatedBy_Missing(null);
+    }
+
+    public void setCreatedBy_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("createdBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_GreaterThan(String createdBy) {
+        setCreatedBy_GreaterThan(createdBy, null);
+    }
+
+    public void setCreatedBy_GreaterThan(String createdBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_GREATER_THAN, createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_LessThan(String createdBy) {
+        setCreatedBy_LessThan(createdBy, null);
+    }
+
+    public void setCreatedBy_LessThan(String createdBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_LESS_THAN, createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_GreaterEqual(String createdBy) {
+        setCreatedBy_GreaterEqual(createdBy, null);
+    }
+
+    public void setCreatedBy_GreaterEqual(String createdBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_LessEqual(String createdBy) {
+        setCreatedBy_LessEqual(createdBy, null);
+    }
+
+    public void setCreatedBy_LessEqual(String createdBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_Term(Long createdTime) {
+        setCreatedTime_Term(createdTime, null);
+    }
+
+    public void setCreatedTime_Term(Long createdTime, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("createdTime", createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_Terms(Collection<Long> createdTimeList) {
+        setCreatedTime_Terms(createdTimeList, null);
+    }
+
+    public void setCreatedTime_Terms(Collection<Long> createdTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("createdTime", createdTimeList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_InScope(Collection<Long> createdTimeList) {
+        setCreatedTime_Terms(createdTimeList, null);
+    }
+
+    public void setCreatedTime_InScope(Collection<Long> createdTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setCreatedTime_Terms(createdTimeList, opLambda);
+    }
+
+    public void setCreatedTime_Exists() {
+        setCreatedTime_Exists(null);
+    }
+
+    public void setCreatedTime_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("createdTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_Missing() {
+        setCreatedTime_Missing(null);
+    }
+
+    public void setCreatedTime_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("createdTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_GreaterThan(Long createdTime) {
+        setCreatedTime_GreaterThan(createdTime, null);
+    }
+
+    public void setCreatedTime_GreaterThan(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_THAN, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_LessThan(Long createdTime) {
+        setCreatedTime_LessThan(createdTime, null);
+    }
+
+    public void setCreatedTime_LessThan(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_THAN, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_GreaterEqual(Long createdTime) {
+        setCreatedTime_GreaterEqual(createdTime, null);
+    }
+
+    public void setCreatedTime_GreaterEqual(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_LessEqual(Long createdTime) {
+        setCreatedTime_LessEqual(createdTime, null);
+    }
+
+    public void setCreatedTime_LessEqual(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Term(String id) {
+        setId_Term(id, null);
+    }
+
+    public void setId_Term(String id, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("id", id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Terms(Collection<String> idList) {
+        setId_Terms(idList, null);
+    }
+
+    public void setId_Terms(Collection<String> idList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("id", idList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_InScope(Collection<String> idList) {
+        setId_Terms(idList, null);
+    }
+
+    public void setId_InScope(Collection<String> idList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setId_Terms(idList, opLambda);
+    }
+
+    public void setId_Prefix(String id) {
+        setId_Prefix(id, null);
+    }
+
+    public void setId_Prefix(String id, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("id", id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Exists() {
+        setId_Exists(null);
+    }
+
+    public void setId_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("id");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Missing() {
+        setId_Missing(null);
+    }
+
+    public void setId_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("id");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_GreaterThan(String id) {
+        setId_GreaterThan(id, null);
+    }
+
+    public void setId_GreaterThan(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_THAN, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_LessThan(String id) {
+        setId_LessThan(id, null);
+    }
+
+    public void setId_LessThan(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_THAN, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_GreaterEqual(String id) {
+        setId_GreaterEqual(id, null);
+    }
+
+    public void setId_GreaterEqual(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_EQUAL, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_LessEqual(String id) {
+        setId_LessEqual(id, null);
+    }
+
+    public void setId_LessEqual(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_EQUAL, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_Term(String name) {
+        setName_Term(name, null);
+    }
+
+    public void setName_Term(String name, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("name", name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_Terms(Collection<String> nameList) {
+        setName_Terms(nameList, null);
+    }
+
+    public void setName_Terms(Collection<String> nameList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("name", nameList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_InScope(Collection<String> nameList) {
+        setName_Terms(nameList, null);
+    }
+
+    public void setName_InScope(Collection<String> nameList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setName_Terms(nameList, opLambda);
+    }
+
+    public void setName_Prefix(String name) {
+        setName_Prefix(name, null);
+    }
+
+    public void setName_Prefix(String name, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("name", name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_Exists() {
+        setName_Exists(null);
+    }
+
+    public void setName_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("name");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_Missing() {
+        setName_Missing(null);
+    }
+
+    public void setName_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("name");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_GreaterThan(String name) {
+        setName_GreaterThan(name, null);
+    }
+
+    public void setName_GreaterThan(String name, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_GREATER_THAN, name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_LessThan(String name) {
+        setName_LessThan(name, null);
+    }
+
+    public void setName_LessThan(String name, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_LESS_THAN, name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_GreaterEqual(String name) {
+        setName_GreaterEqual(name, null);
+    }
+
+    public void setName_GreaterEqual(String name, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_GREATER_EQUAL, name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_LessEqual(String name) {
+        setName_LessEqual(name, null);
+    }
+
+    public void setName_LessEqual(String name, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_LESS_EQUAL, name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_Term(Integer sortOrder) {
+        setSortOrder_Term(sortOrder, null);
+    }
+
+    public void setSortOrder_Term(Integer sortOrder, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("sortOrder", sortOrder);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_Terms(Collection<Integer> sortOrderList) {
+        setSortOrder_Terms(sortOrderList, null);
+    }
+
+    public void setSortOrder_Terms(Collection<Integer> sortOrderList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("sortOrder", sortOrderList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_InScope(Collection<Integer> sortOrderList) {
+        setSortOrder_Terms(sortOrderList, null);
+    }
+
+    public void setSortOrder_InScope(Collection<Integer> sortOrderList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setSortOrder_Terms(sortOrderList, opLambda);
+    }
+
+    public void setSortOrder_Exists() {
+        setSortOrder_Exists(null);
+    }
+
+    public void setSortOrder_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("sortOrder");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_Missing() {
+        setSortOrder_Missing(null);
+    }
+
+    public void setSortOrder_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("sortOrder");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_GreaterThan(Integer sortOrder) {
+        setSortOrder_GreaterThan(sortOrder, null);
+    }
+
+    public void setSortOrder_GreaterThan(Integer sortOrder, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_GREATER_THAN, sortOrder);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_LessThan(Integer sortOrder) {
+        setSortOrder_LessThan(sortOrder, null);
+    }
+
+    public void setSortOrder_LessThan(Integer sortOrder, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_LESS_THAN, sortOrder);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_GreaterEqual(Integer sortOrder) {
+        setSortOrder_GreaterEqual(sortOrder, null);
+    }
+
+    public void setSortOrder_GreaterEqual(Integer sortOrder, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_GREATER_EQUAL, sortOrder);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_LessEqual(Integer sortOrder) {
+        setSortOrder_LessEqual(sortOrder, null);
+    }
+
+    public void setSortOrder_LessEqual(Integer sortOrder, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_LESS_EQUAL, sortOrder);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Term(String updatedBy) {
+        setUpdatedBy_Term(updatedBy, null);
+    }
+
+    public void setUpdatedBy_Term(String updatedBy, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Terms(Collection<String> updatedByList) {
+        setUpdatedBy_Terms(updatedByList, null);
+    }
+
+    public void setUpdatedBy_Terms(Collection<String> updatedByList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("updatedBy", updatedByList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_InScope(Collection<String> updatedByList) {
+        setUpdatedBy_Terms(updatedByList, null);
+    }
+
+    public void setUpdatedBy_InScope(Collection<String> updatedByList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setUpdatedBy_Terms(updatedByList, opLambda);
+    }
+
+    public void setUpdatedBy_Prefix(String updatedBy) {
+        setUpdatedBy_Prefix(updatedBy, null);
+    }
+
+    public void setUpdatedBy_Prefix(String updatedBy, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Exists() {
+        setUpdatedBy_Exists(null);
+    }
+
+    public void setUpdatedBy_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("updatedBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Missing() {
+        setUpdatedBy_Missing(null);
+    }
+
+    public void setUpdatedBy_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("updatedBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_GreaterThan(String updatedBy) {
+        setUpdatedBy_GreaterThan(updatedBy, null);
+    }
+
+    public void setUpdatedBy_GreaterThan(String updatedBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_LessThan(String updatedBy) {
+        setUpdatedBy_LessThan(updatedBy, null);
+    }
+
+    public void setUpdatedBy_LessThan(String updatedBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_GreaterEqual(String updatedBy) {
+        setUpdatedBy_GreaterEqual(updatedBy, null);
+    }
+
+    public void setUpdatedBy_GreaterEqual(String updatedBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_LessEqual(String updatedBy) {
+        setUpdatedBy_LessEqual(updatedBy, null);
+    }
+
+    public void setUpdatedBy_LessEqual(String updatedBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_Term(Long updatedTime) {
+        setUpdatedTime_Term(updatedTime, null);
+    }
+
+    public void setUpdatedTime_Term(Long updatedTime, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("updatedTime", updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_Terms(Collection<Long> updatedTimeList) {
+        setUpdatedTime_Terms(updatedTimeList, null);
+    }
+
+    public void setUpdatedTime_Terms(Collection<Long> updatedTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("updatedTime", updatedTimeList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_InScope(Collection<Long> updatedTimeList) {
+        setUpdatedTime_Terms(updatedTimeList, null);
+    }
+
+    public void setUpdatedTime_InScope(Collection<Long> updatedTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setUpdatedTime_Terms(updatedTimeList, opLambda);
+    }
+
+    public void setUpdatedTime_Exists() {
+        setUpdatedTime_Exists(null);
+    }
+
+    public void setUpdatedTime_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("updatedTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_Missing() {
+        setUpdatedTime_Missing(null);
+    }
+
+    public void setUpdatedTime_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("updatedTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_GreaterThan(Long updatedTime) {
+        setUpdatedTime_GreaterThan(updatedTime, null);
+    }
+
+    public void setUpdatedTime_GreaterThan(Long updatedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_LessThan(Long updatedTime) {
+        setUpdatedTime_LessThan(updatedTime, null);
+    }
+
+    public void setUpdatedTime_LessThan(Long updatedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_GreaterEqual(Long updatedTime) {
+        setUpdatedTime_GreaterEqual(updatedTime, null);
+    }
+
+    public void setUpdatedTime_GreaterEqual(Long updatedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_LessEqual(Long updatedTime) {
+        setUpdatedTime_LessEqual(updatedTime, null);
+    }
+
+    public void setUpdatedTime_LessEqual(Long updatedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setValue_Term(String value) {
+        setValue_Term(value, null);
+    }
+
+    public void setValue_Term(String value, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("value", value);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setValue_Terms(Collection<String> valueList) {
+        setValue_Terms(valueList, null);
+    }
+
+    public void setValue_Terms(Collection<String> valueList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("value", valueList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setValue_InScope(Collection<String> valueList) {
+        setValue_Terms(valueList, null);
+    }
+
+    public void setValue_InScope(Collection<String> valueList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setValue_Terms(valueList, opLambda);
+    }
+
+    public void setValue_Prefix(String value) {
+        setValue_Prefix(value, null);
+    }
+
+    public void setValue_Prefix(String value, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("value", value);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setValue_Exists() {
+        setValue_Exists(null);
+    }
+
+    public void setValue_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("value");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setValue_Missing() {
+        setValue_Missing(null);
+    }
+
+    public void setValue_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("value");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setValue_GreaterThan(String value) {
+        setValue_GreaterThan(value, null);
+    }
+
+    public void setValue_GreaterThan(String value, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("value", ConditionKey.CK_GREATER_THAN, value);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setValue_LessThan(String value) {
+        setValue_LessThan(value, null);
+    }
+
+    public void setValue_LessThan(String value, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("value", ConditionKey.CK_LESS_THAN, value);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setValue_GreaterEqual(String value) {
+        setValue_GreaterEqual(value, null);
+    }
+
+    public void setValue_GreaterEqual(String value, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("value", ConditionKey.CK_GREATER_EQUAL, value);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setValue_LessEqual(String value) {
+        setValue_LessEqual(value, null);
+    }
+
+    public void setValue_LessEqual(String value, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("value", ConditionKey.CK_LESS_EQUAL, value);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+}

src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsScheduledJobCF.java

@@ -0,0 +1,1552 @@
+package org.codelibs.fess.es.cbean.cf.bs;
+
+import java.util.Collection;
+
+import org.codelibs.fess.es.cbean.cf.ScheduledJobCF;
+import org.codelibs.fess.es.cbean.cq.ScheduledJobCQ;
+import org.dbflute.exception.IllegalConditionBeanOperationException;
+import org.dbflute.cbean.ckey.ConditionKey;
+import org.elasticsearch.index.query.AndFilterBuilder;
+import org.elasticsearch.index.query.BoolFilterBuilder;
+import org.elasticsearch.index.query.ExistsFilterBuilder;
+import org.elasticsearch.index.query.MissingFilterBuilder;
+import org.elasticsearch.index.query.NotFilterBuilder;
+import org.elasticsearch.index.query.OrFilterBuilder;
+import org.elasticsearch.index.query.PrefixFilterBuilder;
+import org.elasticsearch.index.query.QueryFilterBuilder;
+import org.elasticsearch.index.query.RangeFilterBuilder;
+import org.elasticsearch.index.query.TermFilterBuilder;
+import org.elasticsearch.index.query.TermsFilterBuilder;
+
+/**
+ * @author FreeGen
+ */
+public abstract class BsScheduledJobCF extends AbstractConditionFilter {
+
+    public void bool(BoolCall<ScheduledJobCF> boolLambda) {
+        bool(boolLambda, null);
+    }
+
+    public void bool(BoolCall<ScheduledJobCF> boolLambda, ConditionOptionCall<BoolFilterBuilder> opLambda) {
+        ScheduledJobCF mustFilter = new ScheduledJobCF();
+        ScheduledJobCF shouldFilter = new ScheduledJobCF();
+        ScheduledJobCF mustNotFilter = new ScheduledJobCF();
+        boolLambda.callback(mustFilter, shouldFilter, mustNotFilter);
+        if (mustFilter.hasFilters() || shouldFilter.hasFilters() || mustNotFilter.hasFilters()) {
+            BoolFilterBuilder builder =
+                    regBoolF(mustFilter.filterBuilderList, shouldFilter.filterBuilderList, mustNotFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void and(OperatorCall<ScheduledJobCF> andLambda) {
+        and(andLambda, null);
+    }
+
+    public void and(OperatorCall<ScheduledJobCF> andLambda, ConditionOptionCall<AndFilterBuilder> opLambda) {
+        ScheduledJobCF andFilter = new ScheduledJobCF();
+        andLambda.callback(andFilter);
+        if (andFilter.hasFilters()) {
+            AndFilterBuilder builder = regAndF(andFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void or(OperatorCall<ScheduledJobCF> orLambda) {
+        or(orLambda, null);
+    }
+
+    public void or(OperatorCall<ScheduledJobCF> orLambda, ConditionOptionCall<OrFilterBuilder> opLambda) {
+        ScheduledJobCF orFilter = new ScheduledJobCF();
+        orLambda.callback(orFilter);
+        if (orFilter.hasFilters()) {
+            OrFilterBuilder builder = regOrF(orFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void not(OperatorCall<ScheduledJobCF> notLambda) {
+        not(notLambda, null);
+    }
+
+    public void not(OperatorCall<ScheduledJobCF> notLambda, ConditionOptionCall<NotFilterBuilder> opLambda) {
+        ScheduledJobCF notFilter = new ScheduledJobCF();
+        notLambda.callback(notFilter);
+        if (notFilter.hasFilters()) {
+            if (notFilter.filterBuilderList.size() > 1) {
+                final String msg = "not filter must be one filter.";
+                throw new IllegalConditionBeanOperationException(msg);
+            }
+            NotFilterBuilder builder = regNotF(notFilter.filterBuilderList.get(0));
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall<ScheduledJobCQ> queryLambda) {
+        query(queryLambda, null);
+    }
+
+    public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall<ScheduledJobCQ> queryLambda,
+            ConditionOptionCall<QueryFilterBuilder> opLambda) {
+        ScheduledJobCQ query = new ScheduledJobCQ();
+        queryLambda.callback(query);
+        if (query.hasQueries()) {
+            QueryFilterBuilder builder = regQueryF(query.getQuery());
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void setAvailable_Term(Boolean available) {
+        setAvailable_Term(available, null);
+    }
+
+    public void setAvailable_Term(Boolean available, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("available", available);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setAvailable_Terms(Collection<Boolean> availableList) {
+        setAvailable_Terms(availableList, null);
+    }
+
+    public void setAvailable_Terms(Collection<Boolean> availableList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("available", availableList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setAvailable_InScope(Collection<Boolean> availableList) {
+        setAvailable_Terms(availableList, null);
+    }
+
+    public void setAvailable_InScope(Collection<Boolean> availableList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setAvailable_Terms(availableList, opLambda);
+    }
+
+    public void setAvailable_Exists() {
+        setAvailable_Exists(null);
+    }
+
+    public void setAvailable_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("available");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setAvailable_Missing() {
+        setAvailable_Missing(null);
+    }
+
+    public void setAvailable_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("available");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setAvailable_GreaterThan(Boolean available) {
+        setAvailable_GreaterThan(available, null);
+    }
+
+    public void setAvailable_GreaterThan(Boolean available, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("available", ConditionKey.CK_GREATER_THAN, available);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setAvailable_LessThan(Boolean available) {
+        setAvailable_LessThan(available, null);
+    }
+
+    public void setAvailable_LessThan(Boolean available, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("available", ConditionKey.CK_LESS_THAN, available);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setAvailable_GreaterEqual(Boolean available) {
+        setAvailable_GreaterEqual(available, null);
+    }
+
+    public void setAvailable_GreaterEqual(Boolean available, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("available", ConditionKey.CK_GREATER_EQUAL, available);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setAvailable_LessEqual(Boolean available) {
+        setAvailable_LessEqual(available, null);
+    }
+
+    public void setAvailable_LessEqual(Boolean available, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("available", ConditionKey.CK_LESS_EQUAL, available);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCrawler_Term(String crawler) {
+        setCrawler_Term(crawler, null);
+    }
+
+    public void setCrawler_Term(String crawler, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("crawler", crawler);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCrawler_Terms(Collection<String> crawlerList) {
+        setCrawler_Terms(crawlerList, null);
+    }
+
+    public void setCrawler_Terms(Collection<String> crawlerList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("crawler", crawlerList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCrawler_InScope(Collection<String> crawlerList) {
+        setCrawler_Terms(crawlerList, null);
+    }
+
+    public void setCrawler_InScope(Collection<String> crawlerList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setCrawler_Terms(crawlerList, opLambda);
+    }
+
+    public void setCrawler_Prefix(String crawler) {
+        setCrawler_Prefix(crawler, null);
+    }
+
+    public void setCrawler_Prefix(String crawler, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("crawler", crawler);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCrawler_Exists() {
+        setCrawler_Exists(null);
+    }
+
+    public void setCrawler_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("crawler");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCrawler_Missing() {
+        setCrawler_Missing(null);
+    }
+
+    public void setCrawler_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("crawler");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCrawler_GreaterThan(String crawler) {
+        setCrawler_GreaterThan(crawler, null);
+    }
+
+    public void setCrawler_GreaterThan(String crawler, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("crawler", ConditionKey.CK_GREATER_THAN, crawler);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCrawler_LessThan(String crawler) {
+        setCrawler_LessThan(crawler, null);
+    }
+
+    public void setCrawler_LessThan(String crawler, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("crawler", ConditionKey.CK_LESS_THAN, crawler);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCrawler_GreaterEqual(String crawler) {
+        setCrawler_GreaterEqual(crawler, null);
+    }
+
+    public void setCrawler_GreaterEqual(String crawler, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("crawler", ConditionKey.CK_GREATER_EQUAL, crawler);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCrawler_LessEqual(String crawler) {
+        setCrawler_LessEqual(crawler, null);
+    }
+
+    public void setCrawler_LessEqual(String crawler, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("crawler", ConditionKey.CK_LESS_EQUAL, crawler);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_Term(String createdBy) {
+        setCreatedBy_Term(createdBy, null);
+    }
+
+    public void setCreatedBy_Term(String createdBy, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_Terms(Collection<String> createdByList) {
+        setCreatedBy_Terms(createdByList, null);
+    }
+
+    public void setCreatedBy_Terms(Collection<String> createdByList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("createdBy", createdByList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_InScope(Collection<String> createdByList) {
+        setCreatedBy_Terms(createdByList, null);
+    }
+
+    public void setCreatedBy_InScope(Collection<String> createdByList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setCreatedBy_Terms(createdByList, opLambda);
+    }
+
+    public void setCreatedBy_Prefix(String createdBy) {
+        setCreatedBy_Prefix(createdBy, null);
+    }
+
+    public void setCreatedBy_Prefix(String createdBy, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_Exists() {
+        setCreatedBy_Exists(null);
+    }
+
+    public void setCreatedBy_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("createdBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_Missing() {
+        setCreatedBy_Missing(null);
+    }
+
+    public void setCreatedBy_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("createdBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_GreaterThan(String createdBy) {
+        setCreatedBy_GreaterThan(createdBy, null);
+    }
+
+    public void setCreatedBy_GreaterThan(String createdBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_GREATER_THAN, createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_LessThan(String createdBy) {
+        setCreatedBy_LessThan(createdBy, null);
+    }
+
+    public void setCreatedBy_LessThan(String createdBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_LESS_THAN, createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_GreaterEqual(String createdBy) {
+        setCreatedBy_GreaterEqual(createdBy, null);
+    }
+
+    public void setCreatedBy_GreaterEqual(String createdBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_LessEqual(String createdBy) {
+        setCreatedBy_LessEqual(createdBy, null);
+    }
+
+    public void setCreatedBy_LessEqual(String createdBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_Term(Long createdTime) {
+        setCreatedTime_Term(createdTime, null);
+    }
+
+    public void setCreatedTime_Term(Long createdTime, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("createdTime", createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_Terms(Collection<Long> createdTimeList) {
+        setCreatedTime_Terms(createdTimeList, null);
+    }
+
+    public void setCreatedTime_Terms(Collection<Long> createdTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("createdTime", createdTimeList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_InScope(Collection<Long> createdTimeList) {
+        setCreatedTime_Terms(createdTimeList, null);
+    }
+
+    public void setCreatedTime_InScope(Collection<Long> createdTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setCreatedTime_Terms(createdTimeList, opLambda);
+    }
+
+    public void setCreatedTime_Exists() {
+        setCreatedTime_Exists(null);
+    }
+
+    public void setCreatedTime_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("createdTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_Missing() {
+        setCreatedTime_Missing(null);
+    }
+
+    public void setCreatedTime_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("createdTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_GreaterThan(Long createdTime) {
+        setCreatedTime_GreaterThan(createdTime, null);
+    }
+
+    public void setCreatedTime_GreaterThan(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_THAN, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_LessThan(Long createdTime) {
+        setCreatedTime_LessThan(createdTime, null);
+    }
+
+    public void setCreatedTime_LessThan(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_THAN, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_GreaterEqual(Long createdTime) {
+        setCreatedTime_GreaterEqual(createdTime, null);
+    }
+
+    public void setCreatedTime_GreaterEqual(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_LessEqual(Long createdTime) {
+        setCreatedTime_LessEqual(createdTime, null);
+    }
+
+    public void setCreatedTime_LessEqual(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCronExpression_Term(String cronExpression) {
+        setCronExpression_Term(cronExpression, null);
+    }
+
+    public void setCronExpression_Term(String cronExpression, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("cronExpression", cronExpression);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCronExpression_Terms(Collection<String> cronExpressionList) {
+        setCronExpression_Terms(cronExpressionList, null);
+    }
+
+    public void setCronExpression_Terms(Collection<String> cronExpressionList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("cronExpression", cronExpressionList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCronExpression_InScope(Collection<String> cronExpressionList) {
+        setCronExpression_Terms(cronExpressionList, null);
+    }
+
+    public void setCronExpression_InScope(Collection<String> cronExpressionList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setCronExpression_Terms(cronExpressionList, opLambda);
+    }
+
+    public void setCronExpression_Prefix(String cronExpression) {
+        setCronExpression_Prefix(cronExpression, null);
+    }
+
+    public void setCronExpression_Prefix(String cronExpression, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("cronExpression", cronExpression);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCronExpression_Exists() {
+        setCronExpression_Exists(null);
+    }
+
+    public void setCronExpression_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("cronExpression");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCronExpression_Missing() {
+        setCronExpression_Missing(null);
+    }
+
+    public void setCronExpression_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("cronExpression");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCronExpression_GreaterThan(String cronExpression) {
+        setCronExpression_GreaterThan(cronExpression, null);
+    }
+
+    public void setCronExpression_GreaterThan(String cronExpression, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("cronExpression", ConditionKey.CK_GREATER_THAN, cronExpression);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCronExpression_LessThan(String cronExpression) {
+        setCronExpression_LessThan(cronExpression, null);
+    }
+
+    public void setCronExpression_LessThan(String cronExpression, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("cronExpression", ConditionKey.CK_LESS_THAN, cronExpression);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCronExpression_GreaterEqual(String cronExpression) {
+        setCronExpression_GreaterEqual(cronExpression, null);
+    }
+
+    public void setCronExpression_GreaterEqual(String cronExpression, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("cronExpression", ConditionKey.CK_GREATER_EQUAL, cronExpression);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCronExpression_LessEqual(String cronExpression) {
+        setCronExpression_LessEqual(cronExpression, null);
+    }
+
+    public void setCronExpression_LessEqual(String cronExpression, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("cronExpression", ConditionKey.CK_LESS_EQUAL, cronExpression);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Term(String id) {
+        setId_Term(id, null);
+    }
+
+    public void setId_Term(String id, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("id", id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Terms(Collection<String> idList) {
+        setId_Terms(idList, null);
+    }
+
+    public void setId_Terms(Collection<String> idList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("id", idList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_InScope(Collection<String> idList) {
+        setId_Terms(idList, null);
+    }
+
+    public void setId_InScope(Collection<String> idList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setId_Terms(idList, opLambda);
+    }
+
+    public void setId_Prefix(String id) {
+        setId_Prefix(id, null);
+    }
+
+    public void setId_Prefix(String id, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("id", id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Exists() {
+        setId_Exists(null);
+    }
+
+    public void setId_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("id");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Missing() {
+        setId_Missing(null);
+    }
+
+    public void setId_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("id");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_GreaterThan(String id) {
+        setId_GreaterThan(id, null);
+    }
+
+    public void setId_GreaterThan(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_THAN, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_LessThan(String id) {
+        setId_LessThan(id, null);
+    }
+
+    public void setId_LessThan(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_THAN, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_GreaterEqual(String id) {
+        setId_GreaterEqual(id, null);
+    }
+
+    public void setId_GreaterEqual(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_EQUAL, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_LessEqual(String id) {
+        setId_LessEqual(id, null);
+    }
+
+    public void setId_LessEqual(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_EQUAL, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setJobLogging_Term(Boolean jobLogging) {
+        setJobLogging_Term(jobLogging, null);
+    }
+
+    public void setJobLogging_Term(Boolean jobLogging, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("jobLogging", jobLogging);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setJobLogging_Terms(Collection<Boolean> jobLoggingList) {
+        setJobLogging_Terms(jobLoggingList, null);
+    }
+
+    public void setJobLogging_Terms(Collection<Boolean> jobLoggingList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("jobLogging", jobLoggingList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setJobLogging_InScope(Collection<Boolean> jobLoggingList) {
+        setJobLogging_Terms(jobLoggingList, null);
+    }
+
+    public void setJobLogging_InScope(Collection<Boolean> jobLoggingList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setJobLogging_Terms(jobLoggingList, opLambda);
+    }
+
+    public void setJobLogging_Exists() {
+        setJobLogging_Exists(null);
+    }
+
+    public void setJobLogging_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("jobLogging");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setJobLogging_Missing() {
+        setJobLogging_Missing(null);
+    }
+
+    public void setJobLogging_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("jobLogging");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setJobLogging_GreaterThan(Boolean jobLogging) {
+        setJobLogging_GreaterThan(jobLogging, null);
+    }
+
+    public void setJobLogging_GreaterThan(Boolean jobLogging, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("jobLogging", ConditionKey.CK_GREATER_THAN, jobLogging);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setJobLogging_LessThan(Boolean jobLogging) {
+        setJobLogging_LessThan(jobLogging, null);
+    }
+
+    public void setJobLogging_LessThan(Boolean jobLogging, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("jobLogging", ConditionKey.CK_LESS_THAN, jobLogging);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setJobLogging_GreaterEqual(Boolean jobLogging) {
+        setJobLogging_GreaterEqual(jobLogging, null);
+    }
+
+    public void setJobLogging_GreaterEqual(Boolean jobLogging, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("jobLogging", ConditionKey.CK_GREATER_EQUAL, jobLogging);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setJobLogging_LessEqual(Boolean jobLogging) {
+        setJobLogging_LessEqual(jobLogging, null);
+    }
+
+    public void setJobLogging_LessEqual(Boolean jobLogging, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("jobLogging", ConditionKey.CK_LESS_EQUAL, jobLogging);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_Term(String name) {
+        setName_Term(name, null);
+    }
+
+    public void setName_Term(String name, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("name", name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_Terms(Collection<String> nameList) {
+        setName_Terms(nameList, null);
+    }
+
+    public void setName_Terms(Collection<String> nameList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("name", nameList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_InScope(Collection<String> nameList) {
+        setName_Terms(nameList, null);
+    }
+
+    public void setName_InScope(Collection<String> nameList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setName_Terms(nameList, opLambda);
+    }
+
+    public void setName_Prefix(String name) {
+        setName_Prefix(name, null);
+    }
+
+    public void setName_Prefix(String name, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("name", name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_Exists() {
+        setName_Exists(null);
+    }
+
+    public void setName_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("name");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_Missing() {
+        setName_Missing(null);
+    }
+
+    public void setName_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("name");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_GreaterThan(String name) {
+        setName_GreaterThan(name, null);
+    }
+
+    public void setName_GreaterThan(String name, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_GREATER_THAN, name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_LessThan(String name) {
+        setName_LessThan(name, null);
+    }
+
+    public void setName_LessThan(String name, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_LESS_THAN, name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_GreaterEqual(String name) {
+        setName_GreaterEqual(name, null);
+    }
+
+    public void setName_GreaterEqual(String name, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_GREATER_EQUAL, name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_LessEqual(String name) {
+        setName_LessEqual(name, null);
+    }
+
+    public void setName_LessEqual(String name, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_LESS_EQUAL, name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setScriptData_Term(String scriptData) {
+        setScriptData_Term(scriptData, null);
+    }
+
+    public void setScriptData_Term(String scriptData, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("scriptData", scriptData);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setScriptData_Terms(Collection<String> scriptDataList) {
+        setScriptData_Terms(scriptDataList, null);
+    }
+
+    public void setScriptData_Terms(Collection<String> scriptDataList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("scriptData", scriptDataList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setScriptData_InScope(Collection<String> scriptDataList) {
+        setScriptData_Terms(scriptDataList, null);
+    }
+
+    public void setScriptData_InScope(Collection<String> scriptDataList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setScriptData_Terms(scriptDataList, opLambda);
+    }
+
+    public void setScriptData_Prefix(String scriptData) {
+        setScriptData_Prefix(scriptData, null);
+    }
+
+    public void setScriptData_Prefix(String scriptData, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("scriptData", scriptData);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setScriptData_Exists() {
+        setScriptData_Exists(null);
+    }
+
+    public void setScriptData_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("scriptData");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setScriptData_Missing() {
+        setScriptData_Missing(null);
+    }
+
+    public void setScriptData_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("scriptData");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setScriptData_GreaterThan(String scriptData) {
+        setScriptData_GreaterThan(scriptData, null);
+    }
+
+    public void setScriptData_GreaterThan(String scriptData, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("scriptData", ConditionKey.CK_GREATER_THAN, scriptData);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setScriptData_LessThan(String scriptData) {
+        setScriptData_LessThan(scriptData, null);
+    }
+
+    public void setScriptData_LessThan(String scriptData, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("scriptData", ConditionKey.CK_LESS_THAN, scriptData);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setScriptData_GreaterEqual(String scriptData) {
+        setScriptData_GreaterEqual(scriptData, null);
+    }
+
+    public void setScriptData_GreaterEqual(String scriptData, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("scriptData", ConditionKey.CK_GREATER_EQUAL, scriptData);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setScriptData_LessEqual(String scriptData) {
+        setScriptData_LessEqual(scriptData, null);
+    }
+
+    public void setScriptData_LessEqual(String scriptData, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("scriptData", ConditionKey.CK_LESS_EQUAL, scriptData);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setScriptType_Term(String scriptType) {
+        setScriptType_Term(scriptType, null);
+    }
+
+    public void setScriptType_Term(String scriptType, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("scriptType", scriptType);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setScriptType_Terms(Collection<String> scriptTypeList) {
+        setScriptType_Terms(scriptTypeList, null);
+    }
+
+    public void setScriptType_Terms(Collection<String> scriptTypeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("scriptType", scriptTypeList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setScriptType_InScope(Collection<String> scriptTypeList) {
+        setScriptType_Terms(scriptTypeList, null);
+    }
+
+    public void setScriptType_InScope(Collection<String> scriptTypeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setScriptType_Terms(scriptTypeList, opLambda);
+    }
+
+    public void setScriptType_Prefix(String scriptType) {
+        setScriptType_Prefix(scriptType, null);
+    }
+
+    public void setScriptType_Prefix(String scriptType, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("scriptType", scriptType);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setScriptType_Exists() {
+        setScriptType_Exists(null);
+    }
+
+    public void setScriptType_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("scriptType");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setScriptType_Missing() {
+        setScriptType_Missing(null);
+    }
+
+    public void setScriptType_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("scriptType");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setScriptType_GreaterThan(String scriptType) {
+        setScriptType_GreaterThan(scriptType, null);
+    }
+
+    public void setScriptType_GreaterThan(String scriptType, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("scriptType", ConditionKey.CK_GREATER_THAN, scriptType);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setScriptType_LessThan(String scriptType) {
+        setScriptType_LessThan(scriptType, null);
+    }
+
+    public void setScriptType_LessThan(String scriptType, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("scriptType", ConditionKey.CK_LESS_THAN, scriptType);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setScriptType_GreaterEqual(String scriptType) {
+        setScriptType_GreaterEqual(scriptType, null);
+    }
+
+    public void setScriptType_GreaterEqual(String scriptType, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("scriptType", ConditionKey.CK_GREATER_EQUAL, scriptType);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setScriptType_LessEqual(String scriptType) {
+        setScriptType_LessEqual(scriptType, null);
+    }
+
+    public void setScriptType_LessEqual(String scriptType, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("scriptType", ConditionKey.CK_LESS_EQUAL, scriptType);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_Term(Integer sortOrder) {
+        setSortOrder_Term(sortOrder, null);
+    }
+
+    public void setSortOrder_Term(Integer sortOrder, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("sortOrder", sortOrder);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_Terms(Collection<Integer> sortOrderList) {
+        setSortOrder_Terms(sortOrderList, null);
+    }
+
+    public void setSortOrder_Terms(Collection<Integer> sortOrderList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("sortOrder", sortOrderList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_InScope(Collection<Integer> sortOrderList) {
+        setSortOrder_Terms(sortOrderList, null);
+    }
+
+    public void setSortOrder_InScope(Collection<Integer> sortOrderList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setSortOrder_Terms(sortOrderList, opLambda);
+    }
+
+    public void setSortOrder_Exists() {
+        setSortOrder_Exists(null);
+    }
+
+    public void setSortOrder_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("sortOrder");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_Missing() {
+        setSortOrder_Missing(null);
+    }
+
+    public void setSortOrder_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("sortOrder");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_GreaterThan(Integer sortOrder) {
+        setSortOrder_GreaterThan(sortOrder, null);
+    }
+
+    public void setSortOrder_GreaterThan(Integer sortOrder, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_GREATER_THAN, sortOrder);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_LessThan(Integer sortOrder) {
+        setSortOrder_LessThan(sortOrder, null);
+    }
+
+    public void setSortOrder_LessThan(Integer sortOrder, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_LESS_THAN, sortOrder);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_GreaterEqual(Integer sortOrder) {
+        setSortOrder_GreaterEqual(sortOrder, null);
+    }
+
+    public void setSortOrder_GreaterEqual(Integer sortOrder, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_GREATER_EQUAL, sortOrder);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_LessEqual(Integer sortOrder) {
+        setSortOrder_LessEqual(sortOrder, null);
+    }
+
+    public void setSortOrder_LessEqual(Integer sortOrder, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_LESS_EQUAL, sortOrder);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTarget_Term(String target) {
+        setTarget_Term(target, null);
+    }
+
+    public void setTarget_Term(String target, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("target", target);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTarget_Terms(Collection<String> targetList) {
+        setTarget_Terms(targetList, null);
+    }
+
+    public void setTarget_Terms(Collection<String> targetList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("target", targetList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTarget_InScope(Collection<String> targetList) {
+        setTarget_Terms(targetList, null);
+    }
+
+    public void setTarget_InScope(Collection<String> targetList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setTarget_Terms(targetList, opLambda);
+    }
+
+    public void setTarget_Prefix(String target) {
+        setTarget_Prefix(target, null);
+    }
+
+    public void setTarget_Prefix(String target, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("target", target);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTarget_Exists() {
+        setTarget_Exists(null);
+    }
+
+    public void setTarget_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("target");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTarget_Missing() {
+        setTarget_Missing(null);
+    }
+
+    public void setTarget_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("target");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTarget_GreaterThan(String target) {
+        setTarget_GreaterThan(target, null);
+    }
+
+    public void setTarget_GreaterThan(String target, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("target", ConditionKey.CK_GREATER_THAN, target);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTarget_LessThan(String target) {
+        setTarget_LessThan(target, null);
+    }
+
+    public void setTarget_LessThan(String target, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("target", ConditionKey.CK_LESS_THAN, target);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTarget_GreaterEqual(String target) {
+        setTarget_GreaterEqual(target, null);
+    }
+
+    public void setTarget_GreaterEqual(String target, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("target", ConditionKey.CK_GREATER_EQUAL, target);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTarget_LessEqual(String target) {
+        setTarget_LessEqual(target, null);
+    }
+
+    public void setTarget_LessEqual(String target, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("target", ConditionKey.CK_LESS_EQUAL, target);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Term(String updatedBy) {
+        setUpdatedBy_Term(updatedBy, null);
+    }
+
+    public void setUpdatedBy_Term(String updatedBy, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Terms(Collection<String> updatedByList) {
+        setUpdatedBy_Terms(updatedByList, null);
+    }
+
+    public void setUpdatedBy_Terms(Collection<String> updatedByList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("updatedBy", updatedByList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_InScope(Collection<String> updatedByList) {
+        setUpdatedBy_Terms(updatedByList, null);
+    }
+
+    public void setUpdatedBy_InScope(Collection<String> updatedByList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setUpdatedBy_Terms(updatedByList, opLambda);
+    }
+
+    public void setUpdatedBy_Prefix(String updatedBy) {
+        setUpdatedBy_Prefix(updatedBy, null);
+    }
+
+    public void setUpdatedBy_Prefix(String updatedBy, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Exists() {
+        setUpdatedBy_Exists(null);
+    }
+
+    public void setUpdatedBy_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("updatedBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Missing() {
+        setUpdatedBy_Missing(null);
+    }
+
+    public void setUpdatedBy_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("updatedBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_GreaterThan(String updatedBy) {
+        setUpdatedBy_GreaterThan(updatedBy, null);
+    }
+
+    public void setUpdatedBy_GreaterThan(String updatedBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_LessThan(String updatedBy) {
+        setUpdatedBy_LessThan(updatedBy, null);
+    }
+
+    public void setUpdatedBy_LessThan(String updatedBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_GreaterEqual(String updatedBy) {
+        setUpdatedBy_GreaterEqual(updatedBy, null);
+    }
+
+    public void setUpdatedBy_GreaterEqual(String updatedBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_LessEqual(String updatedBy) {
+        setUpdatedBy_LessEqual(updatedBy, null);
+    }
+
+    public void setUpdatedBy_LessEqual(String updatedBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_Term(Long updatedTime) {
+        setUpdatedTime_Term(updatedTime, null);
+    }
+
+    public void setUpdatedTime_Term(Long updatedTime, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("updatedTime", updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_Terms(Collection<Long> updatedTimeList) {
+        setUpdatedTime_Terms(updatedTimeList, null);
+    }
+
+    public void setUpdatedTime_Terms(Collection<Long> updatedTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("updatedTime", updatedTimeList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_InScope(Collection<Long> updatedTimeList) {
+        setUpdatedTime_Terms(updatedTimeList, null);
+    }
+
+    public void setUpdatedTime_InScope(Collection<Long> updatedTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setUpdatedTime_Terms(updatedTimeList, opLambda);
+    }
+
+    public void setUpdatedTime_Exists() {
+        setUpdatedTime_Exists(null);
+    }
+
+    public void setUpdatedTime_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("updatedTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_Missing() {
+        setUpdatedTime_Missing(null);
+    }
+
+    public void setUpdatedTime_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("updatedTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_GreaterThan(Long updatedTime) {
+        setUpdatedTime_GreaterThan(updatedTime, null);
+    }
+
+    public void setUpdatedTime_GreaterThan(Long updatedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_LessThan(Long updatedTime) {
+        setUpdatedTime_LessThan(updatedTime, null);
+    }
+
+    public void setUpdatedTime_LessThan(Long updatedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_GreaterEqual(Long updatedTime) {
+        setUpdatedTime_GreaterEqual(updatedTime, null);
+    }
+
+    public void setUpdatedTime_GreaterEqual(Long updatedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_LessEqual(Long updatedTime) {
+        setUpdatedTime_LessEqual(updatedTime, null);
+    }
+
+    public void setUpdatedTime_LessEqual(Long updatedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+}

src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsSearchFieldLogCF.java

@@ -0,0 +1,537 @@
+package org.codelibs.fess.es.cbean.cf.bs;
+
+import java.util.Collection;
+
+import org.codelibs.fess.es.cbean.cf.SearchFieldLogCF;
+import org.codelibs.fess.es.cbean.cq.SearchFieldLogCQ;
+import org.dbflute.exception.IllegalConditionBeanOperationException;
+import org.dbflute.cbean.ckey.ConditionKey;
+import org.elasticsearch.index.query.AndFilterBuilder;
+import org.elasticsearch.index.query.BoolFilterBuilder;
+import org.elasticsearch.index.query.ExistsFilterBuilder;
+import org.elasticsearch.index.query.MissingFilterBuilder;
+import org.elasticsearch.index.query.NotFilterBuilder;
+import org.elasticsearch.index.query.OrFilterBuilder;
+import org.elasticsearch.index.query.PrefixFilterBuilder;
+import org.elasticsearch.index.query.QueryFilterBuilder;
+import org.elasticsearch.index.query.RangeFilterBuilder;
+import org.elasticsearch.index.query.TermFilterBuilder;
+import org.elasticsearch.index.query.TermsFilterBuilder;
+
+/**
+ * @author FreeGen
+ */
+public abstract class BsSearchFieldLogCF extends AbstractConditionFilter {
+
+    public void bool(BoolCall<SearchFieldLogCF> boolLambda) {
+        bool(boolLambda, null);
+    }
+
+    public void bool(BoolCall<SearchFieldLogCF> boolLambda, ConditionOptionCall<BoolFilterBuilder> opLambda) {
+        SearchFieldLogCF mustFilter = new SearchFieldLogCF();
+        SearchFieldLogCF shouldFilter = new SearchFieldLogCF();
+        SearchFieldLogCF mustNotFilter = new SearchFieldLogCF();
+        boolLambda.callback(mustFilter, shouldFilter, mustNotFilter);
+        if (mustFilter.hasFilters() || shouldFilter.hasFilters() || mustNotFilter.hasFilters()) {
+            BoolFilterBuilder builder =
+                    regBoolF(mustFilter.filterBuilderList, shouldFilter.filterBuilderList, mustNotFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void and(OperatorCall<SearchFieldLogCF> andLambda) {
+        and(andLambda, null);
+    }
+
+    public void and(OperatorCall<SearchFieldLogCF> andLambda, ConditionOptionCall<AndFilterBuilder> opLambda) {
+        SearchFieldLogCF andFilter = new SearchFieldLogCF();
+        andLambda.callback(andFilter);
+        if (andFilter.hasFilters()) {
+            AndFilterBuilder builder = regAndF(andFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void or(OperatorCall<SearchFieldLogCF> orLambda) {
+        or(orLambda, null);
+    }
+
+    public void or(OperatorCall<SearchFieldLogCF> orLambda, ConditionOptionCall<OrFilterBuilder> opLambda) {
+        SearchFieldLogCF orFilter = new SearchFieldLogCF();
+        orLambda.callback(orFilter);
+        if (orFilter.hasFilters()) {
+            OrFilterBuilder builder = regOrF(orFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void not(OperatorCall<SearchFieldLogCF> notLambda) {
+        not(notLambda, null);
+    }
+
+    public void not(OperatorCall<SearchFieldLogCF> notLambda, ConditionOptionCall<NotFilterBuilder> opLambda) {
+        SearchFieldLogCF notFilter = new SearchFieldLogCF();
+        notLambda.callback(notFilter);
+        if (notFilter.hasFilters()) {
+            if (notFilter.filterBuilderList.size() > 1) {
+                final String msg = "not filter must be one filter.";
+                throw new IllegalConditionBeanOperationException(msg);
+            }
+            NotFilterBuilder builder = regNotF(notFilter.filterBuilderList.get(0));
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall<SearchFieldLogCQ> queryLambda) {
+        query(queryLambda, null);
+    }
+
+    public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall<SearchFieldLogCQ> queryLambda,
+            ConditionOptionCall<QueryFilterBuilder> opLambda) {
+        SearchFieldLogCQ query = new SearchFieldLogCQ();
+        queryLambda.callback(query);
+        if (query.hasQueries()) {
+            QueryFilterBuilder builder = regQueryF(query.getQuery());
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void setId_Term(String id) {
+        setId_Term(id, null);
+    }
+
+    public void setId_Term(String id, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("id", id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Terms(Collection<String> idList) {
+        setId_Terms(idList, null);
+    }
+
+    public void setId_Terms(Collection<String> idList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("id", idList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_InScope(Collection<String> idList) {
+        setId_Terms(idList, null);
+    }
+
+    public void setId_InScope(Collection<String> idList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setId_Terms(idList, opLambda);
+    }
+
+    public void setId_Prefix(String id) {
+        setId_Prefix(id, null);
+    }
+
+    public void setId_Prefix(String id, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("id", id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Exists() {
+        setId_Exists(null);
+    }
+
+    public void setId_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("id");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Missing() {
+        setId_Missing(null);
+    }
+
+    public void setId_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("id");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_GreaterThan(String id) {
+        setId_GreaterThan(id, null);
+    }
+
+    public void setId_GreaterThan(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_THAN, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_LessThan(String id) {
+        setId_LessThan(id, null);
+    }
+
+    public void setId_LessThan(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_THAN, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_GreaterEqual(String id) {
+        setId_GreaterEqual(id, null);
+    }
+
+    public void setId_GreaterEqual(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_EQUAL, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_LessEqual(String id) {
+        setId_LessEqual(id, null);
+    }
+
+    public void setId_LessEqual(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_EQUAL, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_Term(String name) {
+        setName_Term(name, null);
+    }
+
+    public void setName_Term(String name, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("name", name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_Terms(Collection<String> nameList) {
+        setName_Terms(nameList, null);
+    }
+
+    public void setName_Terms(Collection<String> nameList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("name", nameList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_InScope(Collection<String> nameList) {
+        setName_Terms(nameList, null);
+    }
+
+    public void setName_InScope(Collection<String> nameList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setName_Terms(nameList, opLambda);
+    }
+
+    public void setName_Prefix(String name) {
+        setName_Prefix(name, null);
+    }
+
+    public void setName_Prefix(String name, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("name", name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_Exists() {
+        setName_Exists(null);
+    }
+
+    public void setName_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("name");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_Missing() {
+        setName_Missing(null);
+    }
+
+    public void setName_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("name");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_GreaterThan(String name) {
+        setName_GreaterThan(name, null);
+    }
+
+    public void setName_GreaterThan(String name, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_GREATER_THAN, name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_LessThan(String name) {
+        setName_LessThan(name, null);
+    }
+
+    public void setName_LessThan(String name, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_LESS_THAN, name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_GreaterEqual(String name) {
+        setName_GreaterEqual(name, null);
+    }
+
+    public void setName_GreaterEqual(String name, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_GREATER_EQUAL, name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_LessEqual(String name) {
+        setName_LessEqual(name, null);
+    }
+
+    public void setName_LessEqual(String name, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_LESS_EQUAL, name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSearchLogId_Term(String searchLogId) {
+        setSearchLogId_Term(searchLogId, null);
+    }
+
+    public void setSearchLogId_Term(String searchLogId, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("searchLogId", searchLogId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSearchLogId_Terms(Collection<String> searchLogIdList) {
+        setSearchLogId_Terms(searchLogIdList, null);
+    }
+
+    public void setSearchLogId_Terms(Collection<String> searchLogIdList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("searchLogId", searchLogIdList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSearchLogId_InScope(Collection<String> searchLogIdList) {
+        setSearchLogId_Terms(searchLogIdList, null);
+    }
+
+    public void setSearchLogId_InScope(Collection<String> searchLogIdList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setSearchLogId_Terms(searchLogIdList, opLambda);
+    }
+
+    public void setSearchLogId_Prefix(String searchLogId) {
+        setSearchLogId_Prefix(searchLogId, null);
+    }
+
+    public void setSearchLogId_Prefix(String searchLogId, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("searchLogId", searchLogId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSearchLogId_Exists() {
+        setSearchLogId_Exists(null);
+    }
+
+    public void setSearchLogId_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("searchLogId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSearchLogId_Missing() {
+        setSearchLogId_Missing(null);
+    }
+
+    public void setSearchLogId_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("searchLogId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSearchLogId_GreaterThan(String searchLogId) {
+        setSearchLogId_GreaterThan(searchLogId, null);
+    }
+
+    public void setSearchLogId_GreaterThan(String searchLogId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("searchLogId", ConditionKey.CK_GREATER_THAN, searchLogId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSearchLogId_LessThan(String searchLogId) {
+        setSearchLogId_LessThan(searchLogId, null);
+    }
+
+    public void setSearchLogId_LessThan(String searchLogId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("searchLogId", ConditionKey.CK_LESS_THAN, searchLogId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSearchLogId_GreaterEqual(String searchLogId) {
+        setSearchLogId_GreaterEqual(searchLogId, null);
+    }
+
+    public void setSearchLogId_GreaterEqual(String searchLogId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("searchLogId", ConditionKey.CK_GREATER_EQUAL, searchLogId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSearchLogId_LessEqual(String searchLogId) {
+        setSearchLogId_LessEqual(searchLogId, null);
+    }
+
+    public void setSearchLogId_LessEqual(String searchLogId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("searchLogId", ConditionKey.CK_LESS_EQUAL, searchLogId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setValue_Term(String value) {
+        setValue_Term(value, null);
+    }
+
+    public void setValue_Term(String value, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("value", value);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setValue_Terms(Collection<String> valueList) {
+        setValue_Terms(valueList, null);
+    }
+
+    public void setValue_Terms(Collection<String> valueList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("value", valueList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setValue_InScope(Collection<String> valueList) {
+        setValue_Terms(valueList, null);
+    }
+
+    public void setValue_InScope(Collection<String> valueList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setValue_Terms(valueList, opLambda);
+    }
+
+    public void setValue_Prefix(String value) {
+        setValue_Prefix(value, null);
+    }
+
+    public void setValue_Prefix(String value, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("value", value);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setValue_Exists() {
+        setValue_Exists(null);
+    }
+
+    public void setValue_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("value");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setValue_Missing() {
+        setValue_Missing(null);
+    }
+
+    public void setValue_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("value");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setValue_GreaterThan(String value) {
+        setValue_GreaterThan(value, null);
+    }
+
+    public void setValue_GreaterThan(String value, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("value", ConditionKey.CK_GREATER_THAN, value);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setValue_LessThan(String value) {
+        setValue_LessThan(value, null);
+    }
+
+    public void setValue_LessThan(String value, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("value", ConditionKey.CK_LESS_THAN, value);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setValue_GreaterEqual(String value) {
+        setValue_GreaterEqual(value, null);
+    }
+
+    public void setValue_GreaterEqual(String value, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("value", ConditionKey.CK_GREATER_EQUAL, value);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setValue_LessEqual(String value) {
+        setValue_LessEqual(value, null);
+    }
+
+    public void setValue_LessEqual(String value, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("value", ConditionKey.CK_LESS_EQUAL, value);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+}

src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsSearchLogCF.java

@@ -0,0 +1,1434 @@
+package org.codelibs.fess.es.cbean.cf.bs;
+
+import java.util.Collection;
+
+import org.codelibs.fess.es.cbean.cf.SearchLogCF;
+import org.codelibs.fess.es.cbean.cq.SearchLogCQ;
+import org.dbflute.exception.IllegalConditionBeanOperationException;
+import org.dbflute.cbean.ckey.ConditionKey;
+import org.elasticsearch.index.query.AndFilterBuilder;
+import org.elasticsearch.index.query.BoolFilterBuilder;
+import org.elasticsearch.index.query.ExistsFilterBuilder;
+import org.elasticsearch.index.query.MissingFilterBuilder;
+import org.elasticsearch.index.query.NotFilterBuilder;
+import org.elasticsearch.index.query.OrFilterBuilder;
+import org.elasticsearch.index.query.PrefixFilterBuilder;
+import org.elasticsearch.index.query.QueryFilterBuilder;
+import org.elasticsearch.index.query.RangeFilterBuilder;
+import org.elasticsearch.index.query.TermFilterBuilder;
+import org.elasticsearch.index.query.TermsFilterBuilder;
+
+/**
+ * @author FreeGen
+ */
+public abstract class BsSearchLogCF extends AbstractConditionFilter {
+
+    public void bool(BoolCall<SearchLogCF> boolLambda) {
+        bool(boolLambda, null);
+    }
+
+    public void bool(BoolCall<SearchLogCF> boolLambda, ConditionOptionCall<BoolFilterBuilder> opLambda) {
+        SearchLogCF mustFilter = new SearchLogCF();
+        SearchLogCF shouldFilter = new SearchLogCF();
+        SearchLogCF mustNotFilter = new SearchLogCF();
+        boolLambda.callback(mustFilter, shouldFilter, mustNotFilter);
+        if (mustFilter.hasFilters() || shouldFilter.hasFilters() || mustNotFilter.hasFilters()) {
+            BoolFilterBuilder builder =
+                    regBoolF(mustFilter.filterBuilderList, shouldFilter.filterBuilderList, mustNotFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void and(OperatorCall<SearchLogCF> andLambda) {
+        and(andLambda, null);
+    }
+
+    public void and(OperatorCall<SearchLogCF> andLambda, ConditionOptionCall<AndFilterBuilder> opLambda) {
+        SearchLogCF andFilter = new SearchLogCF();
+        andLambda.callback(andFilter);
+        if (andFilter.hasFilters()) {
+            AndFilterBuilder builder = regAndF(andFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void or(OperatorCall<SearchLogCF> orLambda) {
+        or(orLambda, null);
+    }
+
+    public void or(OperatorCall<SearchLogCF> orLambda, ConditionOptionCall<OrFilterBuilder> opLambda) {
+        SearchLogCF orFilter = new SearchLogCF();
+        orLambda.callback(orFilter);
+        if (orFilter.hasFilters()) {
+            OrFilterBuilder builder = regOrF(orFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void not(OperatorCall<SearchLogCF> notLambda) {
+        not(notLambda, null);
+    }
+
+    public void not(OperatorCall<SearchLogCF> notLambda, ConditionOptionCall<NotFilterBuilder> opLambda) {
+        SearchLogCF notFilter = new SearchLogCF();
+        notLambda.callback(notFilter);
+        if (notFilter.hasFilters()) {
+            if (notFilter.filterBuilderList.size() > 1) {
+                final String msg = "not filter must be one filter.";
+                throw new IllegalConditionBeanOperationException(msg);
+            }
+            NotFilterBuilder builder = regNotF(notFilter.filterBuilderList.get(0));
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall<SearchLogCQ> queryLambda) {
+        query(queryLambda, null);
+    }
+
+    public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall<SearchLogCQ> queryLambda,
+            ConditionOptionCall<QueryFilterBuilder> opLambda) {
+        SearchLogCQ query = new SearchLogCQ();
+        queryLambda.callback(query);
+        if (query.hasQueries()) {
+            QueryFilterBuilder builder = regQueryF(query.getQuery());
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void setAccessType_Term(String accessType) {
+        setAccessType_Term(accessType, null);
+    }
+
+    public void setAccessType_Term(String accessType, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("accessType", accessType);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setAccessType_Terms(Collection<String> accessTypeList) {
+        setAccessType_Terms(accessTypeList, null);
+    }
+
+    public void setAccessType_Terms(Collection<String> accessTypeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("accessType", accessTypeList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setAccessType_InScope(Collection<String> accessTypeList) {
+        setAccessType_Terms(accessTypeList, null);
+    }
+
+    public void setAccessType_InScope(Collection<String> accessTypeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setAccessType_Terms(accessTypeList, opLambda);
+    }
+
+    public void setAccessType_Prefix(String accessType) {
+        setAccessType_Prefix(accessType, null);
+    }
+
+    public void setAccessType_Prefix(String accessType, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("accessType", accessType);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setAccessType_Exists() {
+        setAccessType_Exists(null);
+    }
+
+    public void setAccessType_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("accessType");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setAccessType_Missing() {
+        setAccessType_Missing(null);
+    }
+
+    public void setAccessType_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("accessType");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setAccessType_GreaterThan(String accessType) {
+        setAccessType_GreaterThan(accessType, null);
+    }
+
+    public void setAccessType_GreaterThan(String accessType, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("accessType", ConditionKey.CK_GREATER_THAN, accessType);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setAccessType_LessThan(String accessType) {
+        setAccessType_LessThan(accessType, null);
+    }
+
+    public void setAccessType_LessThan(String accessType, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("accessType", ConditionKey.CK_LESS_THAN, accessType);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setAccessType_GreaterEqual(String accessType) {
+        setAccessType_GreaterEqual(accessType, null);
+    }
+
+    public void setAccessType_GreaterEqual(String accessType, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("accessType", ConditionKey.CK_GREATER_EQUAL, accessType);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setAccessType_LessEqual(String accessType) {
+        setAccessType_LessEqual(accessType, null);
+    }
+
+    public void setAccessType_LessEqual(String accessType, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("accessType", ConditionKey.CK_LESS_EQUAL, accessType);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setClientIp_Term(String clientIp) {
+        setClientIp_Term(clientIp, null);
+    }
+
+    public void setClientIp_Term(String clientIp, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("clientIp", clientIp);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setClientIp_Terms(Collection<String> clientIpList) {
+        setClientIp_Terms(clientIpList, null);
+    }
+
+    public void setClientIp_Terms(Collection<String> clientIpList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("clientIp", clientIpList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setClientIp_InScope(Collection<String> clientIpList) {
+        setClientIp_Terms(clientIpList, null);
+    }
+
+    public void setClientIp_InScope(Collection<String> clientIpList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setClientIp_Terms(clientIpList, opLambda);
+    }
+
+    public void setClientIp_Prefix(String clientIp) {
+        setClientIp_Prefix(clientIp, null);
+    }
+
+    public void setClientIp_Prefix(String clientIp, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("clientIp", clientIp);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setClientIp_Exists() {
+        setClientIp_Exists(null);
+    }
+
+    public void setClientIp_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("clientIp");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setClientIp_Missing() {
+        setClientIp_Missing(null);
+    }
+
+    public void setClientIp_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("clientIp");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setClientIp_GreaterThan(String clientIp) {
+        setClientIp_GreaterThan(clientIp, null);
+    }
+
+    public void setClientIp_GreaterThan(String clientIp, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("clientIp", ConditionKey.CK_GREATER_THAN, clientIp);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setClientIp_LessThan(String clientIp) {
+        setClientIp_LessThan(clientIp, null);
+    }
+
+    public void setClientIp_LessThan(String clientIp, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("clientIp", ConditionKey.CK_LESS_THAN, clientIp);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setClientIp_GreaterEqual(String clientIp) {
+        setClientIp_GreaterEqual(clientIp, null);
+    }
+
+    public void setClientIp_GreaterEqual(String clientIp, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("clientIp", ConditionKey.CK_GREATER_EQUAL, clientIp);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setClientIp_LessEqual(String clientIp) {
+        setClientIp_LessEqual(clientIp, null);
+    }
+
+    public void setClientIp_LessEqual(String clientIp, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("clientIp", ConditionKey.CK_LESS_EQUAL, clientIp);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setHitCount_Term(Long hitCount) {
+        setHitCount_Term(hitCount, null);
+    }
+
+    public void setHitCount_Term(Long hitCount, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("hitCount", hitCount);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setHitCount_Terms(Collection<Long> hitCountList) {
+        setHitCount_Terms(hitCountList, null);
+    }
+
+    public void setHitCount_Terms(Collection<Long> hitCountList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("hitCount", hitCountList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setHitCount_InScope(Collection<Long> hitCountList) {
+        setHitCount_Terms(hitCountList, null);
+    }
+
+    public void setHitCount_InScope(Collection<Long> hitCountList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setHitCount_Terms(hitCountList, opLambda);
+    }
+
+    public void setHitCount_Exists() {
+        setHitCount_Exists(null);
+    }
+
+    public void setHitCount_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("hitCount");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setHitCount_Missing() {
+        setHitCount_Missing(null);
+    }
+
+    public void setHitCount_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("hitCount");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setHitCount_GreaterThan(Long hitCount) {
+        setHitCount_GreaterThan(hitCount, null);
+    }
+
+    public void setHitCount_GreaterThan(Long hitCount, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("hitCount", ConditionKey.CK_GREATER_THAN, hitCount);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setHitCount_LessThan(Long hitCount) {
+        setHitCount_LessThan(hitCount, null);
+    }
+
+    public void setHitCount_LessThan(Long hitCount, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("hitCount", ConditionKey.CK_LESS_THAN, hitCount);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setHitCount_GreaterEqual(Long hitCount) {
+        setHitCount_GreaterEqual(hitCount, null);
+    }
+
+    public void setHitCount_GreaterEqual(Long hitCount, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("hitCount", ConditionKey.CK_GREATER_EQUAL, hitCount);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setHitCount_LessEqual(Long hitCount) {
+        setHitCount_LessEqual(hitCount, null);
+    }
+
+    public void setHitCount_LessEqual(Long hitCount, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("hitCount", ConditionKey.CK_LESS_EQUAL, hitCount);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Term(String id) {
+        setId_Term(id, null);
+    }
+
+    public void setId_Term(String id, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("id", id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Terms(Collection<String> idList) {
+        setId_Terms(idList, null);
+    }
+
+    public void setId_Terms(Collection<String> idList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("id", idList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_InScope(Collection<String> idList) {
+        setId_Terms(idList, null);
+    }
+
+    public void setId_InScope(Collection<String> idList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setId_Terms(idList, opLambda);
+    }
+
+    public void setId_Prefix(String id) {
+        setId_Prefix(id, null);
+    }
+
+    public void setId_Prefix(String id, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("id", id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Exists() {
+        setId_Exists(null);
+    }
+
+    public void setId_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("id");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Missing() {
+        setId_Missing(null);
+    }
+
+    public void setId_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("id");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_GreaterThan(String id) {
+        setId_GreaterThan(id, null);
+    }
+
+    public void setId_GreaterThan(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_THAN, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_LessThan(String id) {
+        setId_LessThan(id, null);
+    }
+
+    public void setId_LessThan(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_THAN, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_GreaterEqual(String id) {
+        setId_GreaterEqual(id, null);
+    }
+
+    public void setId_GreaterEqual(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_EQUAL, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_LessEqual(String id) {
+        setId_LessEqual(id, null);
+    }
+
+    public void setId_LessEqual(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_EQUAL, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setQueryOffset_Term(Integer queryOffset) {
+        setQueryOffset_Term(queryOffset, null);
+    }
+
+    public void setQueryOffset_Term(Integer queryOffset, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("queryOffset", queryOffset);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setQueryOffset_Terms(Collection<Integer> queryOffsetList) {
+        setQueryOffset_Terms(queryOffsetList, null);
+    }
+
+    public void setQueryOffset_Terms(Collection<Integer> queryOffsetList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("queryOffset", queryOffsetList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setQueryOffset_InScope(Collection<Integer> queryOffsetList) {
+        setQueryOffset_Terms(queryOffsetList, null);
+    }
+
+    public void setQueryOffset_InScope(Collection<Integer> queryOffsetList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setQueryOffset_Terms(queryOffsetList, opLambda);
+    }
+
+    public void setQueryOffset_Exists() {
+        setQueryOffset_Exists(null);
+    }
+
+    public void setQueryOffset_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("queryOffset");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setQueryOffset_Missing() {
+        setQueryOffset_Missing(null);
+    }
+
+    public void setQueryOffset_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("queryOffset");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setQueryOffset_GreaterThan(Integer queryOffset) {
+        setQueryOffset_GreaterThan(queryOffset, null);
+    }
+
+    public void setQueryOffset_GreaterThan(Integer queryOffset, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("queryOffset", ConditionKey.CK_GREATER_THAN, queryOffset);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setQueryOffset_LessThan(Integer queryOffset) {
+        setQueryOffset_LessThan(queryOffset, null);
+    }
+
+    public void setQueryOffset_LessThan(Integer queryOffset, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("queryOffset", ConditionKey.CK_LESS_THAN, queryOffset);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setQueryOffset_GreaterEqual(Integer queryOffset) {
+        setQueryOffset_GreaterEqual(queryOffset, null);
+    }
+
+    public void setQueryOffset_GreaterEqual(Integer queryOffset, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("queryOffset", ConditionKey.CK_GREATER_EQUAL, queryOffset);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setQueryOffset_LessEqual(Integer queryOffset) {
+        setQueryOffset_LessEqual(queryOffset, null);
+    }
+
+    public void setQueryOffset_LessEqual(Integer queryOffset, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("queryOffset", ConditionKey.CK_LESS_EQUAL, queryOffset);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setQueryPageSize_Term(Integer queryPageSize) {
+        setQueryPageSize_Term(queryPageSize, null);
+    }
+
+    public void setQueryPageSize_Term(Integer queryPageSize, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("queryPageSize", queryPageSize);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setQueryPageSize_Terms(Collection<Integer> queryPageSizeList) {
+        setQueryPageSize_Terms(queryPageSizeList, null);
+    }
+
+    public void setQueryPageSize_Terms(Collection<Integer> queryPageSizeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("queryPageSize", queryPageSizeList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setQueryPageSize_InScope(Collection<Integer> queryPageSizeList) {
+        setQueryPageSize_Terms(queryPageSizeList, null);
+    }
+
+    public void setQueryPageSize_InScope(Collection<Integer> queryPageSizeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setQueryPageSize_Terms(queryPageSizeList, opLambda);
+    }
+
+    public void setQueryPageSize_Exists() {
+        setQueryPageSize_Exists(null);
+    }
+
+    public void setQueryPageSize_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("queryPageSize");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setQueryPageSize_Missing() {
+        setQueryPageSize_Missing(null);
+    }
+
+    public void setQueryPageSize_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("queryPageSize");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setQueryPageSize_GreaterThan(Integer queryPageSize) {
+        setQueryPageSize_GreaterThan(queryPageSize, null);
+    }
+
+    public void setQueryPageSize_GreaterThan(Integer queryPageSize, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("queryPageSize", ConditionKey.CK_GREATER_THAN, queryPageSize);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setQueryPageSize_LessThan(Integer queryPageSize) {
+        setQueryPageSize_LessThan(queryPageSize, null);
+    }
+
+    public void setQueryPageSize_LessThan(Integer queryPageSize, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("queryPageSize", ConditionKey.CK_LESS_THAN, queryPageSize);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setQueryPageSize_GreaterEqual(Integer queryPageSize) {
+        setQueryPageSize_GreaterEqual(queryPageSize, null);
+    }
+
+    public void setQueryPageSize_GreaterEqual(Integer queryPageSize, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("queryPageSize", ConditionKey.CK_GREATER_EQUAL, queryPageSize);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setQueryPageSize_LessEqual(Integer queryPageSize) {
+        setQueryPageSize_LessEqual(queryPageSize, null);
+    }
+
+    public void setQueryPageSize_LessEqual(Integer queryPageSize, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("queryPageSize", ConditionKey.CK_LESS_EQUAL, queryPageSize);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setReferer_Term(String referer) {
+        setReferer_Term(referer, null);
+    }
+
+    public void setReferer_Term(String referer, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("referer", referer);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setReferer_Terms(Collection<String> refererList) {
+        setReferer_Terms(refererList, null);
+    }
+
+    public void setReferer_Terms(Collection<String> refererList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("referer", refererList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setReferer_InScope(Collection<String> refererList) {
+        setReferer_Terms(refererList, null);
+    }
+
+    public void setReferer_InScope(Collection<String> refererList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setReferer_Terms(refererList, opLambda);
+    }
+
+    public void setReferer_Prefix(String referer) {
+        setReferer_Prefix(referer, null);
+    }
+
+    public void setReferer_Prefix(String referer, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("referer", referer);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setReferer_Exists() {
+        setReferer_Exists(null);
+    }
+
+    public void setReferer_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("referer");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setReferer_Missing() {
+        setReferer_Missing(null);
+    }
+
+    public void setReferer_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("referer");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setReferer_GreaterThan(String referer) {
+        setReferer_GreaterThan(referer, null);
+    }
+
+    public void setReferer_GreaterThan(String referer, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("referer", ConditionKey.CK_GREATER_THAN, referer);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setReferer_LessThan(String referer) {
+        setReferer_LessThan(referer, null);
+    }
+
+    public void setReferer_LessThan(String referer, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("referer", ConditionKey.CK_LESS_THAN, referer);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setReferer_GreaterEqual(String referer) {
+        setReferer_GreaterEqual(referer, null);
+    }
+
+    public void setReferer_GreaterEqual(String referer, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("referer", ConditionKey.CK_GREATER_EQUAL, referer);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setReferer_LessEqual(String referer) {
+        setReferer_LessEqual(referer, null);
+    }
+
+    public void setReferer_LessEqual(String referer, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("referer", ConditionKey.CK_LESS_EQUAL, referer);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRequestedTime_Term(Long requestedTime) {
+        setRequestedTime_Term(requestedTime, null);
+    }
+
+    public void setRequestedTime_Term(Long requestedTime, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("requestedTime", requestedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRequestedTime_Terms(Collection<Long> requestedTimeList) {
+        setRequestedTime_Terms(requestedTimeList, null);
+    }
+
+    public void setRequestedTime_Terms(Collection<Long> requestedTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("requestedTime", requestedTimeList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRequestedTime_InScope(Collection<Long> requestedTimeList) {
+        setRequestedTime_Terms(requestedTimeList, null);
+    }
+
+    public void setRequestedTime_InScope(Collection<Long> requestedTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setRequestedTime_Terms(requestedTimeList, opLambda);
+    }
+
+    public void setRequestedTime_Exists() {
+        setRequestedTime_Exists(null);
+    }
+
+    public void setRequestedTime_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("requestedTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRequestedTime_Missing() {
+        setRequestedTime_Missing(null);
+    }
+
+    public void setRequestedTime_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("requestedTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRequestedTime_GreaterThan(Long requestedTime) {
+        setRequestedTime_GreaterThan(requestedTime, null);
+    }
+
+    public void setRequestedTime_GreaterThan(Long requestedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("requestedTime", ConditionKey.CK_GREATER_THAN, requestedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRequestedTime_LessThan(Long requestedTime) {
+        setRequestedTime_LessThan(requestedTime, null);
+    }
+
+    public void setRequestedTime_LessThan(Long requestedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("requestedTime", ConditionKey.CK_LESS_THAN, requestedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRequestedTime_GreaterEqual(Long requestedTime) {
+        setRequestedTime_GreaterEqual(requestedTime, null);
+    }
+
+    public void setRequestedTime_GreaterEqual(Long requestedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("requestedTime", ConditionKey.CK_GREATER_EQUAL, requestedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRequestedTime_LessEqual(Long requestedTime) {
+        setRequestedTime_LessEqual(requestedTime, null);
+    }
+
+    public void setRequestedTime_LessEqual(Long requestedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("requestedTime", ConditionKey.CK_LESS_EQUAL, requestedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setResponseTime_Term(Integer responseTime) {
+        setResponseTime_Term(responseTime, null);
+    }
+
+    public void setResponseTime_Term(Integer responseTime, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("responseTime", responseTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setResponseTime_Terms(Collection<Integer> responseTimeList) {
+        setResponseTime_Terms(responseTimeList, null);
+    }
+
+    public void setResponseTime_Terms(Collection<Integer> responseTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("responseTime", responseTimeList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setResponseTime_InScope(Collection<Integer> responseTimeList) {
+        setResponseTime_Terms(responseTimeList, null);
+    }
+
+    public void setResponseTime_InScope(Collection<Integer> responseTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setResponseTime_Terms(responseTimeList, opLambda);
+    }
+
+    public void setResponseTime_Exists() {
+        setResponseTime_Exists(null);
+    }
+
+    public void setResponseTime_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("responseTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setResponseTime_Missing() {
+        setResponseTime_Missing(null);
+    }
+
+    public void setResponseTime_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("responseTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setResponseTime_GreaterThan(Integer responseTime) {
+        setResponseTime_GreaterThan(responseTime, null);
+    }
+
+    public void setResponseTime_GreaterThan(Integer responseTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("responseTime", ConditionKey.CK_GREATER_THAN, responseTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setResponseTime_LessThan(Integer responseTime) {
+        setResponseTime_LessThan(responseTime, null);
+    }
+
+    public void setResponseTime_LessThan(Integer responseTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("responseTime", ConditionKey.CK_LESS_THAN, responseTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setResponseTime_GreaterEqual(Integer responseTime) {
+        setResponseTime_GreaterEqual(responseTime, null);
+    }
+
+    public void setResponseTime_GreaterEqual(Integer responseTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("responseTime", ConditionKey.CK_GREATER_EQUAL, responseTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setResponseTime_LessEqual(Integer responseTime) {
+        setResponseTime_LessEqual(responseTime, null);
+    }
+
+    public void setResponseTime_LessEqual(Integer responseTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("responseTime", ConditionKey.CK_LESS_EQUAL, responseTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSearchWord_Term(String searchWord) {
+        setSearchWord_Term(searchWord, null);
+    }
+
+    public void setSearchWord_Term(String searchWord, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("searchWord", searchWord);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSearchWord_Terms(Collection<String> searchWordList) {
+        setSearchWord_Terms(searchWordList, null);
+    }
+
+    public void setSearchWord_Terms(Collection<String> searchWordList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("searchWord", searchWordList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSearchWord_InScope(Collection<String> searchWordList) {
+        setSearchWord_Terms(searchWordList, null);
+    }
+
+    public void setSearchWord_InScope(Collection<String> searchWordList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setSearchWord_Terms(searchWordList, opLambda);
+    }
+
+    public void setSearchWord_Prefix(String searchWord) {
+        setSearchWord_Prefix(searchWord, null);
+    }
+
+    public void setSearchWord_Prefix(String searchWord, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("searchWord", searchWord);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSearchWord_Exists() {
+        setSearchWord_Exists(null);
+    }
+
+    public void setSearchWord_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("searchWord");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSearchWord_Missing() {
+        setSearchWord_Missing(null);
+    }
+
+    public void setSearchWord_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("searchWord");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSearchWord_GreaterThan(String searchWord) {
+        setSearchWord_GreaterThan(searchWord, null);
+    }
+
+    public void setSearchWord_GreaterThan(String searchWord, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("searchWord", ConditionKey.CK_GREATER_THAN, searchWord);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSearchWord_LessThan(String searchWord) {
+        setSearchWord_LessThan(searchWord, null);
+    }
+
+    public void setSearchWord_LessThan(String searchWord, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("searchWord", ConditionKey.CK_LESS_THAN, searchWord);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSearchWord_GreaterEqual(String searchWord) {
+        setSearchWord_GreaterEqual(searchWord, null);
+    }
+
+    public void setSearchWord_GreaterEqual(String searchWord, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("searchWord", ConditionKey.CK_GREATER_EQUAL, searchWord);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSearchWord_LessEqual(String searchWord) {
+        setSearchWord_LessEqual(searchWord, null);
+    }
+
+    public void setSearchWord_LessEqual(String searchWord, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("searchWord", ConditionKey.CK_LESS_EQUAL, searchWord);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUserAgent_Term(String userAgent) {
+        setUserAgent_Term(userAgent, null);
+    }
+
+    public void setUserAgent_Term(String userAgent, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("userAgent", userAgent);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUserAgent_Terms(Collection<String> userAgentList) {
+        setUserAgent_Terms(userAgentList, null);
+    }
+
+    public void setUserAgent_Terms(Collection<String> userAgentList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("userAgent", userAgentList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUserAgent_InScope(Collection<String> userAgentList) {
+        setUserAgent_Terms(userAgentList, null);
+    }
+
+    public void setUserAgent_InScope(Collection<String> userAgentList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setUserAgent_Terms(userAgentList, opLambda);
+    }
+
+    public void setUserAgent_Prefix(String userAgent) {
+        setUserAgent_Prefix(userAgent, null);
+    }
+
+    public void setUserAgent_Prefix(String userAgent, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("userAgent", userAgent);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUserAgent_Exists() {
+        setUserAgent_Exists(null);
+    }
+
+    public void setUserAgent_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("userAgent");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUserAgent_Missing() {
+        setUserAgent_Missing(null);
+    }
+
+    public void setUserAgent_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("userAgent");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUserAgent_GreaterThan(String userAgent) {
+        setUserAgent_GreaterThan(userAgent, null);
+    }
+
+    public void setUserAgent_GreaterThan(String userAgent, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("userAgent", ConditionKey.CK_GREATER_THAN, userAgent);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUserAgent_LessThan(String userAgent) {
+        setUserAgent_LessThan(userAgent, null);
+    }
+
+    public void setUserAgent_LessThan(String userAgent, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("userAgent", ConditionKey.CK_LESS_THAN, userAgent);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUserAgent_GreaterEqual(String userAgent) {
+        setUserAgent_GreaterEqual(userAgent, null);
+    }
+
+    public void setUserAgent_GreaterEqual(String userAgent, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("userAgent", ConditionKey.CK_GREATER_EQUAL, userAgent);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUserAgent_LessEqual(String userAgent) {
+        setUserAgent_LessEqual(userAgent, null);
+    }
+
+    public void setUserAgent_LessEqual(String userAgent, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("userAgent", ConditionKey.CK_LESS_EQUAL, userAgent);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUserId_Term(Long userId) {
+        setUserId_Term(userId, null);
+    }
+
+    public void setUserId_Term(Long userId, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("userId", userId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUserId_Terms(Collection<Long> userIdList) {
+        setUserId_Terms(userIdList, null);
+    }
+
+    public void setUserId_Terms(Collection<Long> userIdList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("userId", userIdList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUserId_InScope(Collection<Long> userIdList) {
+        setUserId_Terms(userIdList, null);
+    }
+
+    public void setUserId_InScope(Collection<Long> userIdList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setUserId_Terms(userIdList, opLambda);
+    }
+
+    public void setUserId_Exists() {
+        setUserId_Exists(null);
+    }
+
+    public void setUserId_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("userId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUserId_Missing() {
+        setUserId_Missing(null);
+    }
+
+    public void setUserId_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("userId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUserId_GreaterThan(Long userId) {
+        setUserId_GreaterThan(userId, null);
+    }
+
+    public void setUserId_GreaterThan(Long userId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("userId", ConditionKey.CK_GREATER_THAN, userId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUserId_LessThan(Long userId) {
+        setUserId_LessThan(userId, null);
+    }
+
+    public void setUserId_LessThan(Long userId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("userId", ConditionKey.CK_LESS_THAN, userId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUserId_GreaterEqual(Long userId) {
+        setUserId_GreaterEqual(userId, null);
+    }
+
+    public void setUserId_GreaterEqual(Long userId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("userId", ConditionKey.CK_GREATER_EQUAL, userId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUserId_LessEqual(Long userId) {
+        setUserId_LessEqual(userId, null);
+    }
+
+    public void setUserId_LessEqual(Long userId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("userId", ConditionKey.CK_LESS_EQUAL, userId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUserSessionId_Term(String userSessionId) {
+        setUserSessionId_Term(userSessionId, null);
+    }
+
+    public void setUserSessionId_Term(String userSessionId, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("userSessionId", userSessionId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUserSessionId_Terms(Collection<String> userSessionIdList) {
+        setUserSessionId_Terms(userSessionIdList, null);
+    }
+
+    public void setUserSessionId_Terms(Collection<String> userSessionIdList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("userSessionId", userSessionIdList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUserSessionId_InScope(Collection<String> userSessionIdList) {
+        setUserSessionId_Terms(userSessionIdList, null);
+    }
+
+    public void setUserSessionId_InScope(Collection<String> userSessionIdList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setUserSessionId_Terms(userSessionIdList, opLambda);
+    }
+
+    public void setUserSessionId_Prefix(String userSessionId) {
+        setUserSessionId_Prefix(userSessionId, null);
+    }
+
+    public void setUserSessionId_Prefix(String userSessionId, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("userSessionId", userSessionId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUserSessionId_Exists() {
+        setUserSessionId_Exists(null);
+    }
+
+    public void setUserSessionId_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("userSessionId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUserSessionId_Missing() {
+        setUserSessionId_Missing(null);
+    }
+
+    public void setUserSessionId_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("userSessionId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUserSessionId_GreaterThan(String userSessionId) {
+        setUserSessionId_GreaterThan(userSessionId, null);
+    }
+
+    public void setUserSessionId_GreaterThan(String userSessionId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("userSessionId", ConditionKey.CK_GREATER_THAN, userSessionId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUserSessionId_LessThan(String userSessionId) {
+        setUserSessionId_LessThan(userSessionId, null);
+    }
+
+    public void setUserSessionId_LessThan(String userSessionId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("userSessionId", ConditionKey.CK_LESS_THAN, userSessionId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUserSessionId_GreaterEqual(String userSessionId) {
+        setUserSessionId_GreaterEqual(userSessionId, null);
+    }
+
+    public void setUserSessionId_GreaterEqual(String userSessionId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("userSessionId", ConditionKey.CK_GREATER_EQUAL, userSessionId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUserSessionId_LessEqual(String userSessionId) {
+        setUserSessionId_LessEqual(userSessionId, null);
+    }
+
+    public void setUserSessionId_LessEqual(String userSessionId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("userSessionId", ConditionKey.CK_LESS_EQUAL, userSessionId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+}

src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsSuggestBadWordCF.java

@@ -0,0 +1,943 @@
+package org.codelibs.fess.es.cbean.cf.bs;
+
+import java.util.Collection;
+
+import org.codelibs.fess.es.cbean.cf.SuggestBadWordCF;
+import org.codelibs.fess.es.cbean.cq.SuggestBadWordCQ;
+import org.dbflute.exception.IllegalConditionBeanOperationException;
+import org.dbflute.cbean.ckey.ConditionKey;
+import org.elasticsearch.index.query.AndFilterBuilder;
+import org.elasticsearch.index.query.BoolFilterBuilder;
+import org.elasticsearch.index.query.ExistsFilterBuilder;
+import org.elasticsearch.index.query.MissingFilterBuilder;
+import org.elasticsearch.index.query.NotFilterBuilder;
+import org.elasticsearch.index.query.OrFilterBuilder;
+import org.elasticsearch.index.query.PrefixFilterBuilder;
+import org.elasticsearch.index.query.QueryFilterBuilder;
+import org.elasticsearch.index.query.RangeFilterBuilder;
+import org.elasticsearch.index.query.TermFilterBuilder;
+import org.elasticsearch.index.query.TermsFilterBuilder;
+
+/**
+ * @author FreeGen
+ */
+public abstract class BsSuggestBadWordCF extends AbstractConditionFilter {
+
+    public void bool(BoolCall<SuggestBadWordCF> boolLambda) {
+        bool(boolLambda, null);
+    }
+
+    public void bool(BoolCall<SuggestBadWordCF> boolLambda, ConditionOptionCall<BoolFilterBuilder> opLambda) {
+        SuggestBadWordCF mustFilter = new SuggestBadWordCF();
+        SuggestBadWordCF shouldFilter = new SuggestBadWordCF();
+        SuggestBadWordCF mustNotFilter = new SuggestBadWordCF();
+        boolLambda.callback(mustFilter, shouldFilter, mustNotFilter);
+        if (mustFilter.hasFilters() || shouldFilter.hasFilters() || mustNotFilter.hasFilters()) {
+            BoolFilterBuilder builder =
+                    regBoolF(mustFilter.filterBuilderList, shouldFilter.filterBuilderList, mustNotFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void and(OperatorCall<SuggestBadWordCF> andLambda) {
+        and(andLambda, null);
+    }
+
+    public void and(OperatorCall<SuggestBadWordCF> andLambda, ConditionOptionCall<AndFilterBuilder> opLambda) {
+        SuggestBadWordCF andFilter = new SuggestBadWordCF();
+        andLambda.callback(andFilter);
+        if (andFilter.hasFilters()) {
+            AndFilterBuilder builder = regAndF(andFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void or(OperatorCall<SuggestBadWordCF> orLambda) {
+        or(orLambda, null);
+    }
+
+    public void or(OperatorCall<SuggestBadWordCF> orLambda, ConditionOptionCall<OrFilterBuilder> opLambda) {
+        SuggestBadWordCF orFilter = new SuggestBadWordCF();
+        orLambda.callback(orFilter);
+        if (orFilter.hasFilters()) {
+            OrFilterBuilder builder = regOrF(orFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void not(OperatorCall<SuggestBadWordCF> notLambda) {
+        not(notLambda, null);
+    }
+
+    public void not(OperatorCall<SuggestBadWordCF> notLambda, ConditionOptionCall<NotFilterBuilder> opLambda) {
+        SuggestBadWordCF notFilter = new SuggestBadWordCF();
+        notLambda.callback(notFilter);
+        if (notFilter.hasFilters()) {
+            if (notFilter.filterBuilderList.size() > 1) {
+                final String msg = "not filter must be one filter.";
+                throw new IllegalConditionBeanOperationException(msg);
+            }
+            NotFilterBuilder builder = regNotF(notFilter.filterBuilderList.get(0));
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall<SuggestBadWordCQ> queryLambda) {
+        query(queryLambda, null);
+    }
+
+    public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall<SuggestBadWordCQ> queryLambda,
+            ConditionOptionCall<QueryFilterBuilder> opLambda) {
+        SuggestBadWordCQ query = new SuggestBadWordCQ();
+        queryLambda.callback(query);
+        if (query.hasQueries()) {
+            QueryFilterBuilder builder = regQueryF(query.getQuery());
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void setCreatedBy_Term(String createdBy) {
+        setCreatedBy_Term(createdBy, null);
+    }
+
+    public void setCreatedBy_Term(String createdBy, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_Terms(Collection<String> createdByList) {
+        setCreatedBy_Terms(createdByList, null);
+    }
+
+    public void setCreatedBy_Terms(Collection<String> createdByList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("createdBy", createdByList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_InScope(Collection<String> createdByList) {
+        setCreatedBy_Terms(createdByList, null);
+    }
+
+    public void setCreatedBy_InScope(Collection<String> createdByList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setCreatedBy_Terms(createdByList, opLambda);
+    }
+
+    public void setCreatedBy_Prefix(String createdBy) {
+        setCreatedBy_Prefix(createdBy, null);
+    }
+
+    public void setCreatedBy_Prefix(String createdBy, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_Exists() {
+        setCreatedBy_Exists(null);
+    }
+
+    public void setCreatedBy_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("createdBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_Missing() {
+        setCreatedBy_Missing(null);
+    }
+
+    public void setCreatedBy_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("createdBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_GreaterThan(String createdBy) {
+        setCreatedBy_GreaterThan(createdBy, null);
+    }
+
+    public void setCreatedBy_GreaterThan(String createdBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_GREATER_THAN, createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_LessThan(String createdBy) {
+        setCreatedBy_LessThan(createdBy, null);
+    }
+
+    public void setCreatedBy_LessThan(String createdBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_LESS_THAN, createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_GreaterEqual(String createdBy) {
+        setCreatedBy_GreaterEqual(createdBy, null);
+    }
+
+    public void setCreatedBy_GreaterEqual(String createdBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_LessEqual(String createdBy) {
+        setCreatedBy_LessEqual(createdBy, null);
+    }
+
+    public void setCreatedBy_LessEqual(String createdBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_Term(Long createdTime) {
+        setCreatedTime_Term(createdTime, null);
+    }
+
+    public void setCreatedTime_Term(Long createdTime, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("createdTime", createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_Terms(Collection<Long> createdTimeList) {
+        setCreatedTime_Terms(createdTimeList, null);
+    }
+
+    public void setCreatedTime_Terms(Collection<Long> createdTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("createdTime", createdTimeList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_InScope(Collection<Long> createdTimeList) {
+        setCreatedTime_Terms(createdTimeList, null);
+    }
+
+    public void setCreatedTime_InScope(Collection<Long> createdTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setCreatedTime_Terms(createdTimeList, opLambda);
+    }
+
+    public void setCreatedTime_Exists() {
+        setCreatedTime_Exists(null);
+    }
+
+    public void setCreatedTime_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("createdTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_Missing() {
+        setCreatedTime_Missing(null);
+    }
+
+    public void setCreatedTime_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("createdTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_GreaterThan(Long createdTime) {
+        setCreatedTime_GreaterThan(createdTime, null);
+    }
+
+    public void setCreatedTime_GreaterThan(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_THAN, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_LessThan(Long createdTime) {
+        setCreatedTime_LessThan(createdTime, null);
+    }
+
+    public void setCreatedTime_LessThan(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_THAN, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_GreaterEqual(Long createdTime) {
+        setCreatedTime_GreaterEqual(createdTime, null);
+    }
+
+    public void setCreatedTime_GreaterEqual(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_LessEqual(Long createdTime) {
+        setCreatedTime_LessEqual(createdTime, null);
+    }
+
+    public void setCreatedTime_LessEqual(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Term(String id) {
+        setId_Term(id, null);
+    }
+
+    public void setId_Term(String id, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("id", id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Terms(Collection<String> idList) {
+        setId_Terms(idList, null);
+    }
+
+    public void setId_Terms(Collection<String> idList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("id", idList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_InScope(Collection<String> idList) {
+        setId_Terms(idList, null);
+    }
+
+    public void setId_InScope(Collection<String> idList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setId_Terms(idList, opLambda);
+    }
+
+    public void setId_Prefix(String id) {
+        setId_Prefix(id, null);
+    }
+
+    public void setId_Prefix(String id, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("id", id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Exists() {
+        setId_Exists(null);
+    }
+
+    public void setId_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("id");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Missing() {
+        setId_Missing(null);
+    }
+
+    public void setId_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("id");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_GreaterThan(String id) {
+        setId_GreaterThan(id, null);
+    }
+
+    public void setId_GreaterThan(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_THAN, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_LessThan(String id) {
+        setId_LessThan(id, null);
+    }
+
+    public void setId_LessThan(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_THAN, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_GreaterEqual(String id) {
+        setId_GreaterEqual(id, null);
+    }
+
+    public void setId_GreaterEqual(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_EQUAL, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_LessEqual(String id) {
+        setId_LessEqual(id, null);
+    }
+
+    public void setId_LessEqual(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_EQUAL, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSuggestWord_Term(String suggestWord) {
+        setSuggestWord_Term(suggestWord, null);
+    }
+
+    public void setSuggestWord_Term(String suggestWord, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("suggestWord", suggestWord);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSuggestWord_Terms(Collection<String> suggestWordList) {
+        setSuggestWord_Terms(suggestWordList, null);
+    }
+
+    public void setSuggestWord_Terms(Collection<String> suggestWordList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("suggestWord", suggestWordList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSuggestWord_InScope(Collection<String> suggestWordList) {
+        setSuggestWord_Terms(suggestWordList, null);
+    }
+
+    public void setSuggestWord_InScope(Collection<String> suggestWordList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setSuggestWord_Terms(suggestWordList, opLambda);
+    }
+
+    public void setSuggestWord_Prefix(String suggestWord) {
+        setSuggestWord_Prefix(suggestWord, null);
+    }
+
+    public void setSuggestWord_Prefix(String suggestWord, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("suggestWord", suggestWord);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSuggestWord_Exists() {
+        setSuggestWord_Exists(null);
+    }
+
+    public void setSuggestWord_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("suggestWord");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSuggestWord_Missing() {
+        setSuggestWord_Missing(null);
+    }
+
+    public void setSuggestWord_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("suggestWord");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSuggestWord_GreaterThan(String suggestWord) {
+        setSuggestWord_GreaterThan(suggestWord, null);
+    }
+
+    public void setSuggestWord_GreaterThan(String suggestWord, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("suggestWord", ConditionKey.CK_GREATER_THAN, suggestWord);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSuggestWord_LessThan(String suggestWord) {
+        setSuggestWord_LessThan(suggestWord, null);
+    }
+
+    public void setSuggestWord_LessThan(String suggestWord, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("suggestWord", ConditionKey.CK_LESS_THAN, suggestWord);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSuggestWord_GreaterEqual(String suggestWord) {
+        setSuggestWord_GreaterEqual(suggestWord, null);
+    }
+
+    public void setSuggestWord_GreaterEqual(String suggestWord, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("suggestWord", ConditionKey.CK_GREATER_EQUAL, suggestWord);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSuggestWord_LessEqual(String suggestWord) {
+        setSuggestWord_LessEqual(suggestWord, null);
+    }
+
+    public void setSuggestWord_LessEqual(String suggestWord, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("suggestWord", ConditionKey.CK_LESS_EQUAL, suggestWord);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTargetLabel_Term(String targetLabel) {
+        setTargetLabel_Term(targetLabel, null);
+    }
+
+    public void setTargetLabel_Term(String targetLabel, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("targetLabel", targetLabel);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTargetLabel_Terms(Collection<String> targetLabelList) {
+        setTargetLabel_Terms(targetLabelList, null);
+    }
+
+    public void setTargetLabel_Terms(Collection<String> targetLabelList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("targetLabel", targetLabelList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTargetLabel_InScope(Collection<String> targetLabelList) {
+        setTargetLabel_Terms(targetLabelList, null);
+    }
+
+    public void setTargetLabel_InScope(Collection<String> targetLabelList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setTargetLabel_Terms(targetLabelList, opLambda);
+    }
+
+    public void setTargetLabel_Prefix(String targetLabel) {
+        setTargetLabel_Prefix(targetLabel, null);
+    }
+
+    public void setTargetLabel_Prefix(String targetLabel, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("targetLabel", targetLabel);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTargetLabel_Exists() {
+        setTargetLabel_Exists(null);
+    }
+
+    public void setTargetLabel_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("targetLabel");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTargetLabel_Missing() {
+        setTargetLabel_Missing(null);
+    }
+
+    public void setTargetLabel_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("targetLabel");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTargetLabel_GreaterThan(String targetLabel) {
+        setTargetLabel_GreaterThan(targetLabel, null);
+    }
+
+    public void setTargetLabel_GreaterThan(String targetLabel, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("targetLabel", ConditionKey.CK_GREATER_THAN, targetLabel);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTargetLabel_LessThan(String targetLabel) {
+        setTargetLabel_LessThan(targetLabel, null);
+    }
+
+    public void setTargetLabel_LessThan(String targetLabel, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("targetLabel", ConditionKey.CK_LESS_THAN, targetLabel);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTargetLabel_GreaterEqual(String targetLabel) {
+        setTargetLabel_GreaterEqual(targetLabel, null);
+    }
+
+    public void setTargetLabel_GreaterEqual(String targetLabel, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("targetLabel", ConditionKey.CK_GREATER_EQUAL, targetLabel);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTargetLabel_LessEqual(String targetLabel) {
+        setTargetLabel_LessEqual(targetLabel, null);
+    }
+
+    public void setTargetLabel_LessEqual(String targetLabel, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("targetLabel", ConditionKey.CK_LESS_EQUAL, targetLabel);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTargetRole_Term(String targetRole) {
+        setTargetRole_Term(targetRole, null);
+    }
+
+    public void setTargetRole_Term(String targetRole, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("targetRole", targetRole);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTargetRole_Terms(Collection<String> targetRoleList) {
+        setTargetRole_Terms(targetRoleList, null);
+    }
+
+    public void setTargetRole_Terms(Collection<String> targetRoleList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("targetRole", targetRoleList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTargetRole_InScope(Collection<String> targetRoleList) {
+        setTargetRole_Terms(targetRoleList, null);
+    }
+
+    public void setTargetRole_InScope(Collection<String> targetRoleList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setTargetRole_Terms(targetRoleList, opLambda);
+    }
+
+    public void setTargetRole_Prefix(String targetRole) {
+        setTargetRole_Prefix(targetRole, null);
+    }
+
+    public void setTargetRole_Prefix(String targetRole, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("targetRole", targetRole);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTargetRole_Exists() {
+        setTargetRole_Exists(null);
+    }
+
+    public void setTargetRole_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("targetRole");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTargetRole_Missing() {
+        setTargetRole_Missing(null);
+    }
+
+    public void setTargetRole_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("targetRole");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTargetRole_GreaterThan(String targetRole) {
+        setTargetRole_GreaterThan(targetRole, null);
+    }
+
+    public void setTargetRole_GreaterThan(String targetRole, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("targetRole", ConditionKey.CK_GREATER_THAN, targetRole);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTargetRole_LessThan(String targetRole) {
+        setTargetRole_LessThan(targetRole, null);
+    }
+
+    public void setTargetRole_LessThan(String targetRole, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("targetRole", ConditionKey.CK_LESS_THAN, targetRole);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTargetRole_GreaterEqual(String targetRole) {
+        setTargetRole_GreaterEqual(targetRole, null);
+    }
+
+    public void setTargetRole_GreaterEqual(String targetRole, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("targetRole", ConditionKey.CK_GREATER_EQUAL, targetRole);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTargetRole_LessEqual(String targetRole) {
+        setTargetRole_LessEqual(targetRole, null);
+    }
+
+    public void setTargetRole_LessEqual(String targetRole, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("targetRole", ConditionKey.CK_LESS_EQUAL, targetRole);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Term(String updatedBy) {
+        setUpdatedBy_Term(updatedBy, null);
+    }
+
+    public void setUpdatedBy_Term(String updatedBy, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Terms(Collection<String> updatedByList) {
+        setUpdatedBy_Terms(updatedByList, null);
+    }
+
+    public void setUpdatedBy_Terms(Collection<String> updatedByList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("updatedBy", updatedByList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_InScope(Collection<String> updatedByList) {
+        setUpdatedBy_Terms(updatedByList, null);
+    }
+
+    public void setUpdatedBy_InScope(Collection<String> updatedByList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setUpdatedBy_Terms(updatedByList, opLambda);
+    }
+
+    public void setUpdatedBy_Prefix(String updatedBy) {
+        setUpdatedBy_Prefix(updatedBy, null);
+    }
+
+    public void setUpdatedBy_Prefix(String updatedBy, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Exists() {
+        setUpdatedBy_Exists(null);
+    }
+
+    public void setUpdatedBy_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("updatedBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Missing() {
+        setUpdatedBy_Missing(null);
+    }
+
+    public void setUpdatedBy_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("updatedBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_GreaterThan(String updatedBy) {
+        setUpdatedBy_GreaterThan(updatedBy, null);
+    }
+
+    public void setUpdatedBy_GreaterThan(String updatedBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_LessThan(String updatedBy) {
+        setUpdatedBy_LessThan(updatedBy, null);
+    }
+
+    public void setUpdatedBy_LessThan(String updatedBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_GreaterEqual(String updatedBy) {
+        setUpdatedBy_GreaterEqual(updatedBy, null);
+    }
+
+    public void setUpdatedBy_GreaterEqual(String updatedBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_LessEqual(String updatedBy) {
+        setUpdatedBy_LessEqual(updatedBy, null);
+    }
+
+    public void setUpdatedBy_LessEqual(String updatedBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_Term(Long updatedTime) {
+        setUpdatedTime_Term(updatedTime, null);
+    }
+
+    public void setUpdatedTime_Term(Long updatedTime, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("updatedTime", updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_Terms(Collection<Long> updatedTimeList) {
+        setUpdatedTime_Terms(updatedTimeList, null);
+    }
+
+    public void setUpdatedTime_Terms(Collection<Long> updatedTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("updatedTime", updatedTimeList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_InScope(Collection<Long> updatedTimeList) {
+        setUpdatedTime_Terms(updatedTimeList, null);
+    }
+
+    public void setUpdatedTime_InScope(Collection<Long> updatedTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setUpdatedTime_Terms(updatedTimeList, opLambda);
+    }
+
+    public void setUpdatedTime_Exists() {
+        setUpdatedTime_Exists(null);
+    }
+
+    public void setUpdatedTime_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("updatedTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_Missing() {
+        setUpdatedTime_Missing(null);
+    }
+
+    public void setUpdatedTime_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("updatedTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_GreaterThan(Long updatedTime) {
+        setUpdatedTime_GreaterThan(updatedTime, null);
+    }
+
+    public void setUpdatedTime_GreaterThan(Long updatedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_LessThan(Long updatedTime) {
+        setUpdatedTime_LessThan(updatedTime, null);
+    }
+
+    public void setUpdatedTime_LessThan(Long updatedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_GreaterEqual(Long updatedTime) {
+        setUpdatedTime_GreaterEqual(updatedTime, null);
+    }
+
+    public void setUpdatedTime_GreaterEqual(Long updatedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_LessEqual(Long updatedTime) {
+        setUpdatedTime_LessEqual(updatedTime, null);
+    }
+
+    public void setUpdatedTime_LessEqual(Long updatedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+}

src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsSuggestElevateWordCF.java

@@ -0,0 +1,1146 @@
+package org.codelibs.fess.es.cbean.cf.bs;
+
+import java.util.Collection;
+
+import org.codelibs.fess.es.cbean.cf.SuggestElevateWordCF;
+import org.codelibs.fess.es.cbean.cq.SuggestElevateWordCQ;
+import org.dbflute.exception.IllegalConditionBeanOperationException;
+import org.dbflute.cbean.ckey.ConditionKey;
+import org.elasticsearch.index.query.AndFilterBuilder;
+import org.elasticsearch.index.query.BoolFilterBuilder;
+import org.elasticsearch.index.query.ExistsFilterBuilder;
+import org.elasticsearch.index.query.MissingFilterBuilder;
+import org.elasticsearch.index.query.NotFilterBuilder;
+import org.elasticsearch.index.query.OrFilterBuilder;
+import org.elasticsearch.index.query.PrefixFilterBuilder;
+import org.elasticsearch.index.query.QueryFilterBuilder;
+import org.elasticsearch.index.query.RangeFilterBuilder;
+import org.elasticsearch.index.query.TermFilterBuilder;
+import org.elasticsearch.index.query.TermsFilterBuilder;
+
+/**
+ * @author FreeGen
+ */
+public abstract class BsSuggestElevateWordCF extends AbstractConditionFilter {
+
+    public void bool(BoolCall<SuggestElevateWordCF> boolLambda) {
+        bool(boolLambda, null);
+    }
+
+    public void bool(BoolCall<SuggestElevateWordCF> boolLambda, ConditionOptionCall<BoolFilterBuilder> opLambda) {
+        SuggestElevateWordCF mustFilter = new SuggestElevateWordCF();
+        SuggestElevateWordCF shouldFilter = new SuggestElevateWordCF();
+        SuggestElevateWordCF mustNotFilter = new SuggestElevateWordCF();
+        boolLambda.callback(mustFilter, shouldFilter, mustNotFilter);
+        if (mustFilter.hasFilters() || shouldFilter.hasFilters() || mustNotFilter.hasFilters()) {
+            BoolFilterBuilder builder =
+                    regBoolF(mustFilter.filterBuilderList, shouldFilter.filterBuilderList, mustNotFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void and(OperatorCall<SuggestElevateWordCF> andLambda) {
+        and(andLambda, null);
+    }
+
+    public void and(OperatorCall<SuggestElevateWordCF> andLambda, ConditionOptionCall<AndFilterBuilder> opLambda) {
+        SuggestElevateWordCF andFilter = new SuggestElevateWordCF();
+        andLambda.callback(andFilter);
+        if (andFilter.hasFilters()) {
+            AndFilterBuilder builder = regAndF(andFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void or(OperatorCall<SuggestElevateWordCF> orLambda) {
+        or(orLambda, null);
+    }
+
+    public void or(OperatorCall<SuggestElevateWordCF> orLambda, ConditionOptionCall<OrFilterBuilder> opLambda) {
+        SuggestElevateWordCF orFilter = new SuggestElevateWordCF();
+        orLambda.callback(orFilter);
+        if (orFilter.hasFilters()) {
+            OrFilterBuilder builder = regOrF(orFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void not(OperatorCall<SuggestElevateWordCF> notLambda) {
+        not(notLambda, null);
+    }
+
+    public void not(OperatorCall<SuggestElevateWordCF> notLambda, ConditionOptionCall<NotFilterBuilder> opLambda) {
+        SuggestElevateWordCF notFilter = new SuggestElevateWordCF();
+        notLambda.callback(notFilter);
+        if (notFilter.hasFilters()) {
+            if (notFilter.filterBuilderList.size() > 1) {
+                final String msg = "not filter must be one filter.";
+                throw new IllegalConditionBeanOperationException(msg);
+            }
+            NotFilterBuilder builder = regNotF(notFilter.filterBuilderList.get(0));
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall<SuggestElevateWordCQ> queryLambda) {
+        query(queryLambda, null);
+    }
+
+    public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall<SuggestElevateWordCQ> queryLambda,
+            ConditionOptionCall<QueryFilterBuilder> opLambda) {
+        SuggestElevateWordCQ query = new SuggestElevateWordCQ();
+        queryLambda.callback(query);
+        if (query.hasQueries()) {
+            QueryFilterBuilder builder = regQueryF(query.getQuery());
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void setBoost_Term(Float boost) {
+        setBoost_Term(boost, null);
+    }
+
+    public void setBoost_Term(Float boost, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("boost", boost);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setBoost_Terms(Collection<Float> boostList) {
+        setBoost_Terms(boostList, null);
+    }
+
+    public void setBoost_Terms(Collection<Float> boostList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("boost", boostList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setBoost_InScope(Collection<Float> boostList) {
+        setBoost_Terms(boostList, null);
+    }
+
+    public void setBoost_InScope(Collection<Float> boostList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setBoost_Terms(boostList, opLambda);
+    }
+
+    public void setBoost_Exists() {
+        setBoost_Exists(null);
+    }
+
+    public void setBoost_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("boost");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setBoost_Missing() {
+        setBoost_Missing(null);
+    }
+
+    public void setBoost_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("boost");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setBoost_GreaterThan(Float boost) {
+        setBoost_GreaterThan(boost, null);
+    }
+
+    public void setBoost_GreaterThan(Float boost, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("boost", ConditionKey.CK_GREATER_THAN, boost);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setBoost_LessThan(Float boost) {
+        setBoost_LessThan(boost, null);
+    }
+
+    public void setBoost_LessThan(Float boost, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("boost", ConditionKey.CK_LESS_THAN, boost);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setBoost_GreaterEqual(Float boost) {
+        setBoost_GreaterEqual(boost, null);
+    }
+
+    public void setBoost_GreaterEqual(Float boost, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("boost", ConditionKey.CK_GREATER_EQUAL, boost);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setBoost_LessEqual(Float boost) {
+        setBoost_LessEqual(boost, null);
+    }
+
+    public void setBoost_LessEqual(Float boost, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("boost", ConditionKey.CK_LESS_EQUAL, boost);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_Term(String createdBy) {
+        setCreatedBy_Term(createdBy, null);
+    }
+
+    public void setCreatedBy_Term(String createdBy, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_Terms(Collection<String> createdByList) {
+        setCreatedBy_Terms(createdByList, null);
+    }
+
+    public void setCreatedBy_Terms(Collection<String> createdByList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("createdBy", createdByList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_InScope(Collection<String> createdByList) {
+        setCreatedBy_Terms(createdByList, null);
+    }
+
+    public void setCreatedBy_InScope(Collection<String> createdByList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setCreatedBy_Terms(createdByList, opLambda);
+    }
+
+    public void setCreatedBy_Prefix(String createdBy) {
+        setCreatedBy_Prefix(createdBy, null);
+    }
+
+    public void setCreatedBy_Prefix(String createdBy, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_Exists() {
+        setCreatedBy_Exists(null);
+    }
+
+    public void setCreatedBy_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("createdBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_Missing() {
+        setCreatedBy_Missing(null);
+    }
+
+    public void setCreatedBy_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("createdBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_GreaterThan(String createdBy) {
+        setCreatedBy_GreaterThan(createdBy, null);
+    }
+
+    public void setCreatedBy_GreaterThan(String createdBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_GREATER_THAN, createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_LessThan(String createdBy) {
+        setCreatedBy_LessThan(createdBy, null);
+    }
+
+    public void setCreatedBy_LessThan(String createdBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_LESS_THAN, createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_GreaterEqual(String createdBy) {
+        setCreatedBy_GreaterEqual(createdBy, null);
+    }
+
+    public void setCreatedBy_GreaterEqual(String createdBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_LessEqual(String createdBy) {
+        setCreatedBy_LessEqual(createdBy, null);
+    }
+
+    public void setCreatedBy_LessEqual(String createdBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_Term(Long createdTime) {
+        setCreatedTime_Term(createdTime, null);
+    }
+
+    public void setCreatedTime_Term(Long createdTime, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("createdTime", createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_Terms(Collection<Long> createdTimeList) {
+        setCreatedTime_Terms(createdTimeList, null);
+    }
+
+    public void setCreatedTime_Terms(Collection<Long> createdTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("createdTime", createdTimeList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_InScope(Collection<Long> createdTimeList) {
+        setCreatedTime_Terms(createdTimeList, null);
+    }
+
+    public void setCreatedTime_InScope(Collection<Long> createdTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setCreatedTime_Terms(createdTimeList, opLambda);
+    }
+
+    public void setCreatedTime_Exists() {
+        setCreatedTime_Exists(null);
+    }
+
+    public void setCreatedTime_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("createdTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_Missing() {
+        setCreatedTime_Missing(null);
+    }
+
+    public void setCreatedTime_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("createdTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_GreaterThan(Long createdTime) {
+        setCreatedTime_GreaterThan(createdTime, null);
+    }
+
+    public void setCreatedTime_GreaterThan(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_THAN, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_LessThan(Long createdTime) {
+        setCreatedTime_LessThan(createdTime, null);
+    }
+
+    public void setCreatedTime_LessThan(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_THAN, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_GreaterEqual(Long createdTime) {
+        setCreatedTime_GreaterEqual(createdTime, null);
+    }
+
+    public void setCreatedTime_GreaterEqual(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_LessEqual(Long createdTime) {
+        setCreatedTime_LessEqual(createdTime, null);
+    }
+
+    public void setCreatedTime_LessEqual(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Term(String id) {
+        setId_Term(id, null);
+    }
+
+    public void setId_Term(String id, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("id", id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Terms(Collection<String> idList) {
+        setId_Terms(idList, null);
+    }
+
+    public void setId_Terms(Collection<String> idList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("id", idList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_InScope(Collection<String> idList) {
+        setId_Terms(idList, null);
+    }
+
+    public void setId_InScope(Collection<String> idList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setId_Terms(idList, opLambda);
+    }
+
+    public void setId_Prefix(String id) {
+        setId_Prefix(id, null);
+    }
+
+    public void setId_Prefix(String id, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("id", id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Exists() {
+        setId_Exists(null);
+    }
+
+    public void setId_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("id");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Missing() {
+        setId_Missing(null);
+    }
+
+    public void setId_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("id");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_GreaterThan(String id) {
+        setId_GreaterThan(id, null);
+    }
+
+    public void setId_GreaterThan(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_THAN, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_LessThan(String id) {
+        setId_LessThan(id, null);
+    }
+
+    public void setId_LessThan(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_THAN, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_GreaterEqual(String id) {
+        setId_GreaterEqual(id, null);
+    }
+
+    public void setId_GreaterEqual(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_EQUAL, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_LessEqual(String id) {
+        setId_LessEqual(id, null);
+    }
+
+    public void setId_LessEqual(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_EQUAL, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setReading_Term(String reading) {
+        setReading_Term(reading, null);
+    }
+
+    public void setReading_Term(String reading, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("reading", reading);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setReading_Terms(Collection<String> readingList) {
+        setReading_Terms(readingList, null);
+    }
+
+    public void setReading_Terms(Collection<String> readingList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("reading", readingList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setReading_InScope(Collection<String> readingList) {
+        setReading_Terms(readingList, null);
+    }
+
+    public void setReading_InScope(Collection<String> readingList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setReading_Terms(readingList, opLambda);
+    }
+
+    public void setReading_Prefix(String reading) {
+        setReading_Prefix(reading, null);
+    }
+
+    public void setReading_Prefix(String reading, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("reading", reading);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setReading_Exists() {
+        setReading_Exists(null);
+    }
+
+    public void setReading_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("reading");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setReading_Missing() {
+        setReading_Missing(null);
+    }
+
+    public void setReading_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("reading");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setReading_GreaterThan(String reading) {
+        setReading_GreaterThan(reading, null);
+    }
+
+    public void setReading_GreaterThan(String reading, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("reading", ConditionKey.CK_GREATER_THAN, reading);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setReading_LessThan(String reading) {
+        setReading_LessThan(reading, null);
+    }
+
+    public void setReading_LessThan(String reading, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("reading", ConditionKey.CK_LESS_THAN, reading);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setReading_GreaterEqual(String reading) {
+        setReading_GreaterEqual(reading, null);
+    }
+
+    public void setReading_GreaterEqual(String reading, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("reading", ConditionKey.CK_GREATER_EQUAL, reading);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setReading_LessEqual(String reading) {
+        setReading_LessEqual(reading, null);
+    }
+
+    public void setReading_LessEqual(String reading, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("reading", ConditionKey.CK_LESS_EQUAL, reading);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSuggestWord_Term(String suggestWord) {
+        setSuggestWord_Term(suggestWord, null);
+    }
+
+    public void setSuggestWord_Term(String suggestWord, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("suggestWord", suggestWord);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSuggestWord_Terms(Collection<String> suggestWordList) {
+        setSuggestWord_Terms(suggestWordList, null);
+    }
+
+    public void setSuggestWord_Terms(Collection<String> suggestWordList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("suggestWord", suggestWordList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSuggestWord_InScope(Collection<String> suggestWordList) {
+        setSuggestWord_Terms(suggestWordList, null);
+    }
+
+    public void setSuggestWord_InScope(Collection<String> suggestWordList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setSuggestWord_Terms(suggestWordList, opLambda);
+    }
+
+    public void setSuggestWord_Prefix(String suggestWord) {
+        setSuggestWord_Prefix(suggestWord, null);
+    }
+
+    public void setSuggestWord_Prefix(String suggestWord, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("suggestWord", suggestWord);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSuggestWord_Exists() {
+        setSuggestWord_Exists(null);
+    }
+
+    public void setSuggestWord_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("suggestWord");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSuggestWord_Missing() {
+        setSuggestWord_Missing(null);
+    }
+
+    public void setSuggestWord_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("suggestWord");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSuggestWord_GreaterThan(String suggestWord) {
+        setSuggestWord_GreaterThan(suggestWord, null);
+    }
+
+    public void setSuggestWord_GreaterThan(String suggestWord, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("suggestWord", ConditionKey.CK_GREATER_THAN, suggestWord);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSuggestWord_LessThan(String suggestWord) {
+        setSuggestWord_LessThan(suggestWord, null);
+    }
+
+    public void setSuggestWord_LessThan(String suggestWord, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("suggestWord", ConditionKey.CK_LESS_THAN, suggestWord);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSuggestWord_GreaterEqual(String suggestWord) {
+        setSuggestWord_GreaterEqual(suggestWord, null);
+    }
+
+    public void setSuggestWord_GreaterEqual(String suggestWord, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("suggestWord", ConditionKey.CK_GREATER_EQUAL, suggestWord);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSuggestWord_LessEqual(String suggestWord) {
+        setSuggestWord_LessEqual(suggestWord, null);
+    }
+
+    public void setSuggestWord_LessEqual(String suggestWord, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("suggestWord", ConditionKey.CK_LESS_EQUAL, suggestWord);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTargetLabel_Term(String targetLabel) {
+        setTargetLabel_Term(targetLabel, null);
+    }
+
+    public void setTargetLabel_Term(String targetLabel, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("targetLabel", targetLabel);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTargetLabel_Terms(Collection<String> targetLabelList) {
+        setTargetLabel_Terms(targetLabelList, null);
+    }
+
+    public void setTargetLabel_Terms(Collection<String> targetLabelList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("targetLabel", targetLabelList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTargetLabel_InScope(Collection<String> targetLabelList) {
+        setTargetLabel_Terms(targetLabelList, null);
+    }
+
+    public void setTargetLabel_InScope(Collection<String> targetLabelList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setTargetLabel_Terms(targetLabelList, opLambda);
+    }
+
+    public void setTargetLabel_Prefix(String targetLabel) {
+        setTargetLabel_Prefix(targetLabel, null);
+    }
+
+    public void setTargetLabel_Prefix(String targetLabel, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("targetLabel", targetLabel);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTargetLabel_Exists() {
+        setTargetLabel_Exists(null);
+    }
+
+    public void setTargetLabel_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("targetLabel");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTargetLabel_Missing() {
+        setTargetLabel_Missing(null);
+    }
+
+    public void setTargetLabel_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("targetLabel");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTargetLabel_GreaterThan(String targetLabel) {
+        setTargetLabel_GreaterThan(targetLabel, null);
+    }
+
+    public void setTargetLabel_GreaterThan(String targetLabel, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("targetLabel", ConditionKey.CK_GREATER_THAN, targetLabel);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTargetLabel_LessThan(String targetLabel) {
+        setTargetLabel_LessThan(targetLabel, null);
+    }
+
+    public void setTargetLabel_LessThan(String targetLabel, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("targetLabel", ConditionKey.CK_LESS_THAN, targetLabel);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTargetLabel_GreaterEqual(String targetLabel) {
+        setTargetLabel_GreaterEqual(targetLabel, null);
+    }
+
+    public void setTargetLabel_GreaterEqual(String targetLabel, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("targetLabel", ConditionKey.CK_GREATER_EQUAL, targetLabel);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTargetLabel_LessEqual(String targetLabel) {
+        setTargetLabel_LessEqual(targetLabel, null);
+    }
+
+    public void setTargetLabel_LessEqual(String targetLabel, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("targetLabel", ConditionKey.CK_LESS_EQUAL, targetLabel);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTargetRole_Term(String targetRole) {
+        setTargetRole_Term(targetRole, null);
+    }
+
+    public void setTargetRole_Term(String targetRole, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("targetRole", targetRole);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTargetRole_Terms(Collection<String> targetRoleList) {
+        setTargetRole_Terms(targetRoleList, null);
+    }
+
+    public void setTargetRole_Terms(Collection<String> targetRoleList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("targetRole", targetRoleList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTargetRole_InScope(Collection<String> targetRoleList) {
+        setTargetRole_Terms(targetRoleList, null);
+    }
+
+    public void setTargetRole_InScope(Collection<String> targetRoleList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setTargetRole_Terms(targetRoleList, opLambda);
+    }
+
+    public void setTargetRole_Prefix(String targetRole) {
+        setTargetRole_Prefix(targetRole, null);
+    }
+
+    public void setTargetRole_Prefix(String targetRole, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("targetRole", targetRole);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTargetRole_Exists() {
+        setTargetRole_Exists(null);
+    }
+
+    public void setTargetRole_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("targetRole");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTargetRole_Missing() {
+        setTargetRole_Missing(null);
+    }
+
+    public void setTargetRole_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("targetRole");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTargetRole_GreaterThan(String targetRole) {
+        setTargetRole_GreaterThan(targetRole, null);
+    }
+
+    public void setTargetRole_GreaterThan(String targetRole, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("targetRole", ConditionKey.CK_GREATER_THAN, targetRole);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTargetRole_LessThan(String targetRole) {
+        setTargetRole_LessThan(targetRole, null);
+    }
+
+    public void setTargetRole_LessThan(String targetRole, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("targetRole", ConditionKey.CK_LESS_THAN, targetRole);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTargetRole_GreaterEqual(String targetRole) {
+        setTargetRole_GreaterEqual(targetRole, null);
+    }
+
+    public void setTargetRole_GreaterEqual(String targetRole, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("targetRole", ConditionKey.CK_GREATER_EQUAL, targetRole);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTargetRole_LessEqual(String targetRole) {
+        setTargetRole_LessEqual(targetRole, null);
+    }
+
+    public void setTargetRole_LessEqual(String targetRole, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("targetRole", ConditionKey.CK_LESS_EQUAL, targetRole);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Term(String updatedBy) {
+        setUpdatedBy_Term(updatedBy, null);
+    }
+
+    public void setUpdatedBy_Term(String updatedBy, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Terms(Collection<String> updatedByList) {
+        setUpdatedBy_Terms(updatedByList, null);
+    }
+
+    public void setUpdatedBy_Terms(Collection<String> updatedByList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("updatedBy", updatedByList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_InScope(Collection<String> updatedByList) {
+        setUpdatedBy_Terms(updatedByList, null);
+    }
+
+    public void setUpdatedBy_InScope(Collection<String> updatedByList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setUpdatedBy_Terms(updatedByList, opLambda);
+    }
+
+    public void setUpdatedBy_Prefix(String updatedBy) {
+        setUpdatedBy_Prefix(updatedBy, null);
+    }
+
+    public void setUpdatedBy_Prefix(String updatedBy, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Exists() {
+        setUpdatedBy_Exists(null);
+    }
+
+    public void setUpdatedBy_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("updatedBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Missing() {
+        setUpdatedBy_Missing(null);
+    }
+
+    public void setUpdatedBy_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("updatedBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_GreaterThan(String updatedBy) {
+        setUpdatedBy_GreaterThan(updatedBy, null);
+    }
+
+    public void setUpdatedBy_GreaterThan(String updatedBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_LessThan(String updatedBy) {
+        setUpdatedBy_LessThan(updatedBy, null);
+    }
+
+    public void setUpdatedBy_LessThan(String updatedBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_GreaterEqual(String updatedBy) {
+        setUpdatedBy_GreaterEqual(updatedBy, null);
+    }
+
+    public void setUpdatedBy_GreaterEqual(String updatedBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_LessEqual(String updatedBy) {
+        setUpdatedBy_LessEqual(updatedBy, null);
+    }
+
+    public void setUpdatedBy_LessEqual(String updatedBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_Term(Long updatedTime) {
+        setUpdatedTime_Term(updatedTime, null);
+    }
+
+    public void setUpdatedTime_Term(Long updatedTime, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("updatedTime", updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_Terms(Collection<Long> updatedTimeList) {
+        setUpdatedTime_Terms(updatedTimeList, null);
+    }
+
+    public void setUpdatedTime_Terms(Collection<Long> updatedTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("updatedTime", updatedTimeList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_InScope(Collection<Long> updatedTimeList) {
+        setUpdatedTime_Terms(updatedTimeList, null);
+    }
+
+    public void setUpdatedTime_InScope(Collection<Long> updatedTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setUpdatedTime_Terms(updatedTimeList, opLambda);
+    }
+
+    public void setUpdatedTime_Exists() {
+        setUpdatedTime_Exists(null);
+    }
+
+    public void setUpdatedTime_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("updatedTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_Missing() {
+        setUpdatedTime_Missing(null);
+    }
+
+    public void setUpdatedTime_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("updatedTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_GreaterThan(Long updatedTime) {
+        setUpdatedTime_GreaterThan(updatedTime, null);
+    }
+
+    public void setUpdatedTime_GreaterThan(Long updatedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_LessThan(Long updatedTime) {
+        setUpdatedTime_LessThan(updatedTime, null);
+    }
+
+    public void setUpdatedTime_LessThan(Long updatedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_GreaterEqual(Long updatedTime) {
+        setUpdatedTime_GreaterEqual(updatedTime, null);
+    }
+
+    public void setUpdatedTime_GreaterEqual(Long updatedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_LessEqual(Long updatedTime) {
+        setUpdatedTime_LessEqual(updatedTime, null);
+    }
+
+    public void setUpdatedTime_LessEqual(Long updatedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+}

src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsUserInfoCF.java

@@ -0,0 +1,515 @@
+package org.codelibs.fess.es.cbean.cf.bs;
+
+import java.util.Collection;
+
+import org.codelibs.fess.es.cbean.cf.UserInfoCF;
+import org.codelibs.fess.es.cbean.cq.UserInfoCQ;
+import org.dbflute.exception.IllegalConditionBeanOperationException;
+import org.dbflute.cbean.ckey.ConditionKey;
+import org.elasticsearch.index.query.AndFilterBuilder;
+import org.elasticsearch.index.query.BoolFilterBuilder;
+import org.elasticsearch.index.query.ExistsFilterBuilder;
+import org.elasticsearch.index.query.MissingFilterBuilder;
+import org.elasticsearch.index.query.NotFilterBuilder;
+import org.elasticsearch.index.query.OrFilterBuilder;
+import org.elasticsearch.index.query.PrefixFilterBuilder;
+import org.elasticsearch.index.query.QueryFilterBuilder;
+import org.elasticsearch.index.query.RangeFilterBuilder;
+import org.elasticsearch.index.query.TermFilterBuilder;
+import org.elasticsearch.index.query.TermsFilterBuilder;
+
+/**
+ * @author FreeGen
+ */
+public abstract class BsUserInfoCF extends AbstractConditionFilter {
+
+    public void bool(BoolCall<UserInfoCF> boolLambda) {
+        bool(boolLambda, null);
+    }
+
+    public void bool(BoolCall<UserInfoCF> boolLambda, ConditionOptionCall<BoolFilterBuilder> opLambda) {
+        UserInfoCF mustFilter = new UserInfoCF();
+        UserInfoCF shouldFilter = new UserInfoCF();
+        UserInfoCF mustNotFilter = new UserInfoCF();
+        boolLambda.callback(mustFilter, shouldFilter, mustNotFilter);
+        if (mustFilter.hasFilters() || shouldFilter.hasFilters() || mustNotFilter.hasFilters()) {
+            BoolFilterBuilder builder =
+                    regBoolF(mustFilter.filterBuilderList, shouldFilter.filterBuilderList, mustNotFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void and(OperatorCall<UserInfoCF> andLambda) {
+        and(andLambda, null);
+    }
+
+    public void and(OperatorCall<UserInfoCF> andLambda, ConditionOptionCall<AndFilterBuilder> opLambda) {
+        UserInfoCF andFilter = new UserInfoCF();
+        andLambda.callback(andFilter);
+        if (andFilter.hasFilters()) {
+            AndFilterBuilder builder = regAndF(andFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void or(OperatorCall<UserInfoCF> orLambda) {
+        or(orLambda, null);
+    }
+
+    public void or(OperatorCall<UserInfoCF> orLambda, ConditionOptionCall<OrFilterBuilder> opLambda) {
+        UserInfoCF orFilter = new UserInfoCF();
+        orLambda.callback(orFilter);
+        if (orFilter.hasFilters()) {
+            OrFilterBuilder builder = regOrF(orFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void not(OperatorCall<UserInfoCF> notLambda) {
+        not(notLambda, null);
+    }
+
+    public void not(OperatorCall<UserInfoCF> notLambda, ConditionOptionCall<NotFilterBuilder> opLambda) {
+        UserInfoCF notFilter = new UserInfoCF();
+        notLambda.callback(notFilter);
+        if (notFilter.hasFilters()) {
+            if (notFilter.filterBuilderList.size() > 1) {
+                final String msg = "not filter must be one filter.";
+                throw new IllegalConditionBeanOperationException(msg);
+            }
+            NotFilterBuilder builder = regNotF(notFilter.filterBuilderList.get(0));
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall<UserInfoCQ> queryLambda) {
+        query(queryLambda, null);
+    }
+
+    public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall<UserInfoCQ> queryLambda,
+            ConditionOptionCall<QueryFilterBuilder> opLambda) {
+        UserInfoCQ query = new UserInfoCQ();
+        queryLambda.callback(query);
+        if (query.hasQueries()) {
+            QueryFilterBuilder builder = regQueryF(query.getQuery());
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void setCode_Term(String code) {
+        setCode_Term(code, null);
+    }
+
+    public void setCode_Term(String code, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("code", code);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCode_Terms(Collection<String> codeList) {
+        setCode_Terms(codeList, null);
+    }
+
+    public void setCode_Terms(Collection<String> codeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("code", codeList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCode_InScope(Collection<String> codeList) {
+        setCode_Terms(codeList, null);
+    }
+
+    public void setCode_InScope(Collection<String> codeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setCode_Terms(codeList, opLambda);
+    }
+
+    public void setCode_Prefix(String code) {
+        setCode_Prefix(code, null);
+    }
+
+    public void setCode_Prefix(String code, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("code", code);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCode_Exists() {
+        setCode_Exists(null);
+    }
+
+    public void setCode_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("code");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCode_Missing() {
+        setCode_Missing(null);
+    }
+
+    public void setCode_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("code");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCode_GreaterThan(String code) {
+        setCode_GreaterThan(code, null);
+    }
+
+    public void setCode_GreaterThan(String code, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("code", ConditionKey.CK_GREATER_THAN, code);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCode_LessThan(String code) {
+        setCode_LessThan(code, null);
+    }
+
+    public void setCode_LessThan(String code, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("code", ConditionKey.CK_LESS_THAN, code);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCode_GreaterEqual(String code) {
+        setCode_GreaterEqual(code, null);
+    }
+
+    public void setCode_GreaterEqual(String code, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("code", ConditionKey.CK_GREATER_EQUAL, code);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCode_LessEqual(String code) {
+        setCode_LessEqual(code, null);
+    }
+
+    public void setCode_LessEqual(String code, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("code", ConditionKey.CK_LESS_EQUAL, code);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_Term(Long createdTime) {
+        setCreatedTime_Term(createdTime, null);
+    }
+
+    public void setCreatedTime_Term(Long createdTime, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("createdTime", createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_Terms(Collection<Long> createdTimeList) {
+        setCreatedTime_Terms(createdTimeList, null);
+    }
+
+    public void setCreatedTime_Terms(Collection<Long> createdTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("createdTime", createdTimeList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_InScope(Collection<Long> createdTimeList) {
+        setCreatedTime_Terms(createdTimeList, null);
+    }
+
+    public void setCreatedTime_InScope(Collection<Long> createdTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setCreatedTime_Terms(createdTimeList, opLambda);
+    }
+
+    public void setCreatedTime_Exists() {
+        setCreatedTime_Exists(null);
+    }
+
+    public void setCreatedTime_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("createdTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_Missing() {
+        setCreatedTime_Missing(null);
+    }
+
+    public void setCreatedTime_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("createdTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_GreaterThan(Long createdTime) {
+        setCreatedTime_GreaterThan(createdTime, null);
+    }
+
+    public void setCreatedTime_GreaterThan(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_THAN, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_LessThan(Long createdTime) {
+        setCreatedTime_LessThan(createdTime, null);
+    }
+
+    public void setCreatedTime_LessThan(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_THAN, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_GreaterEqual(Long createdTime) {
+        setCreatedTime_GreaterEqual(createdTime, null);
+    }
+
+    public void setCreatedTime_GreaterEqual(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_LessEqual(Long createdTime) {
+        setCreatedTime_LessEqual(createdTime, null);
+    }
+
+    public void setCreatedTime_LessEqual(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Term(String id) {
+        setId_Term(id, null);
+    }
+
+    public void setId_Term(String id, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("id", id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Terms(Collection<String> idList) {
+        setId_Terms(idList, null);
+    }
+
+    public void setId_Terms(Collection<String> idList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("id", idList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_InScope(Collection<String> idList) {
+        setId_Terms(idList, null);
+    }
+
+    public void setId_InScope(Collection<String> idList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setId_Terms(idList, opLambda);
+    }
+
+    public void setId_Prefix(String id) {
+        setId_Prefix(id, null);
+    }
+
+    public void setId_Prefix(String id, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("id", id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Exists() {
+        setId_Exists(null);
+    }
+
+    public void setId_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("id");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Missing() {
+        setId_Missing(null);
+    }
+
+    public void setId_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("id");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_GreaterThan(String id) {
+        setId_GreaterThan(id, null);
+    }
+
+    public void setId_GreaterThan(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_THAN, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_LessThan(String id) {
+        setId_LessThan(id, null);
+    }
+
+    public void setId_LessThan(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_THAN, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_GreaterEqual(String id) {
+        setId_GreaterEqual(id, null);
+    }
+
+    public void setId_GreaterEqual(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_EQUAL, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_LessEqual(String id) {
+        setId_LessEqual(id, null);
+    }
+
+    public void setId_LessEqual(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_EQUAL, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_Term(Long updatedTime) {
+        setUpdatedTime_Term(updatedTime, null);
+    }
+
+    public void setUpdatedTime_Term(Long updatedTime, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("updatedTime", updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_Terms(Collection<Long> updatedTimeList) {
+        setUpdatedTime_Terms(updatedTimeList, null);
+    }
+
+    public void setUpdatedTime_Terms(Collection<Long> updatedTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("updatedTime", updatedTimeList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_InScope(Collection<Long> updatedTimeList) {
+        setUpdatedTime_Terms(updatedTimeList, null);
+    }
+
+    public void setUpdatedTime_InScope(Collection<Long> updatedTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setUpdatedTime_Terms(updatedTimeList, opLambda);
+    }
+
+    public void setUpdatedTime_Exists() {
+        setUpdatedTime_Exists(null);
+    }
+
+    public void setUpdatedTime_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("updatedTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_Missing() {
+        setUpdatedTime_Missing(null);
+    }
+
+    public void setUpdatedTime_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("updatedTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_GreaterThan(Long updatedTime) {
+        setUpdatedTime_GreaterThan(updatedTime, null);
+    }
+
+    public void setUpdatedTime_GreaterThan(Long updatedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_LessThan(Long updatedTime) {
+        setUpdatedTime_LessThan(updatedTime, null);
+    }
+
+    public void setUpdatedTime_LessThan(Long updatedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_GreaterEqual(Long updatedTime) {
+        setUpdatedTime_GreaterEqual(updatedTime, null);
+    }
+
+    public void setUpdatedTime_GreaterEqual(Long updatedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_LessEqual(Long updatedTime) {
+        setUpdatedTime_LessEqual(updatedTime, null);
+    }
+
+    public void setUpdatedTime_LessEqual(Long updatedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+}

src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsWebAuthenticationCF.java

@@ -0,0 +1,1467 @@
+package org.codelibs.fess.es.cbean.cf.bs;
+
+import java.util.Collection;
+
+import org.codelibs.fess.es.cbean.cf.WebAuthenticationCF;
+import org.codelibs.fess.es.cbean.cq.WebAuthenticationCQ;
+import org.dbflute.exception.IllegalConditionBeanOperationException;
+import org.dbflute.cbean.ckey.ConditionKey;
+import org.elasticsearch.index.query.AndFilterBuilder;
+import org.elasticsearch.index.query.BoolFilterBuilder;
+import org.elasticsearch.index.query.ExistsFilterBuilder;
+import org.elasticsearch.index.query.MissingFilterBuilder;
+import org.elasticsearch.index.query.NotFilterBuilder;
+import org.elasticsearch.index.query.OrFilterBuilder;
+import org.elasticsearch.index.query.PrefixFilterBuilder;
+import org.elasticsearch.index.query.QueryFilterBuilder;
+import org.elasticsearch.index.query.RangeFilterBuilder;
+import org.elasticsearch.index.query.TermFilterBuilder;
+import org.elasticsearch.index.query.TermsFilterBuilder;
+
+/**
+ * @author FreeGen
+ */
+public abstract class BsWebAuthenticationCF extends AbstractConditionFilter {
+
+    public void bool(BoolCall<WebAuthenticationCF> boolLambda) {
+        bool(boolLambda, null);
+    }
+
+    public void bool(BoolCall<WebAuthenticationCF> boolLambda, ConditionOptionCall<BoolFilterBuilder> opLambda) {
+        WebAuthenticationCF mustFilter = new WebAuthenticationCF();
+        WebAuthenticationCF shouldFilter = new WebAuthenticationCF();
+        WebAuthenticationCF mustNotFilter = new WebAuthenticationCF();
+        boolLambda.callback(mustFilter, shouldFilter, mustNotFilter);
+        if (mustFilter.hasFilters() || shouldFilter.hasFilters() || mustNotFilter.hasFilters()) {
+            BoolFilterBuilder builder =
+                    regBoolF(mustFilter.filterBuilderList, shouldFilter.filterBuilderList, mustNotFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void and(OperatorCall<WebAuthenticationCF> andLambda) {
+        and(andLambda, null);
+    }
+
+    public void and(OperatorCall<WebAuthenticationCF> andLambda, ConditionOptionCall<AndFilterBuilder> opLambda) {
+        WebAuthenticationCF andFilter = new WebAuthenticationCF();
+        andLambda.callback(andFilter);
+        if (andFilter.hasFilters()) {
+            AndFilterBuilder builder = regAndF(andFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void or(OperatorCall<WebAuthenticationCF> orLambda) {
+        or(orLambda, null);
+    }
+
+    public void or(OperatorCall<WebAuthenticationCF> orLambda, ConditionOptionCall<OrFilterBuilder> opLambda) {
+        WebAuthenticationCF orFilter = new WebAuthenticationCF();
+        orLambda.callback(orFilter);
+        if (orFilter.hasFilters()) {
+            OrFilterBuilder builder = regOrF(orFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void not(OperatorCall<WebAuthenticationCF> notLambda) {
+        not(notLambda, null);
+    }
+
+    public void not(OperatorCall<WebAuthenticationCF> notLambda, ConditionOptionCall<NotFilterBuilder> opLambda) {
+        WebAuthenticationCF notFilter = new WebAuthenticationCF();
+        notLambda.callback(notFilter);
+        if (notFilter.hasFilters()) {
+            if (notFilter.filterBuilderList.size() > 1) {
+                final String msg = "not filter must be one filter.";
+                throw new IllegalConditionBeanOperationException(msg);
+            }
+            NotFilterBuilder builder = regNotF(notFilter.filterBuilderList.get(0));
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall<WebAuthenticationCQ> queryLambda) {
+        query(queryLambda, null);
+    }
+
+    public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall<WebAuthenticationCQ> queryLambda,
+            ConditionOptionCall<QueryFilterBuilder> opLambda) {
+        WebAuthenticationCQ query = new WebAuthenticationCQ();
+        queryLambda.callback(query);
+        if (query.hasQueries()) {
+            QueryFilterBuilder builder = regQueryF(query.getQuery());
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void setAuthRealm_Term(String authRealm) {
+        setAuthRealm_Term(authRealm, null);
+    }
+
+    public void setAuthRealm_Term(String authRealm, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("authRealm", authRealm);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setAuthRealm_Terms(Collection<String> authRealmList) {
+        setAuthRealm_Terms(authRealmList, null);
+    }
+
+    public void setAuthRealm_Terms(Collection<String> authRealmList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("authRealm", authRealmList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setAuthRealm_InScope(Collection<String> authRealmList) {
+        setAuthRealm_Terms(authRealmList, null);
+    }
+
+    public void setAuthRealm_InScope(Collection<String> authRealmList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setAuthRealm_Terms(authRealmList, opLambda);
+    }
+
+    public void setAuthRealm_Prefix(String authRealm) {
+        setAuthRealm_Prefix(authRealm, null);
+    }
+
+    public void setAuthRealm_Prefix(String authRealm, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("authRealm", authRealm);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setAuthRealm_Exists() {
+        setAuthRealm_Exists(null);
+    }
+
+    public void setAuthRealm_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("authRealm");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setAuthRealm_Missing() {
+        setAuthRealm_Missing(null);
+    }
+
+    public void setAuthRealm_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("authRealm");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setAuthRealm_GreaterThan(String authRealm) {
+        setAuthRealm_GreaterThan(authRealm, null);
+    }
+
+    public void setAuthRealm_GreaterThan(String authRealm, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("authRealm", ConditionKey.CK_GREATER_THAN, authRealm);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setAuthRealm_LessThan(String authRealm) {
+        setAuthRealm_LessThan(authRealm, null);
+    }
+
+    public void setAuthRealm_LessThan(String authRealm, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("authRealm", ConditionKey.CK_LESS_THAN, authRealm);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setAuthRealm_GreaterEqual(String authRealm) {
+        setAuthRealm_GreaterEqual(authRealm, null);
+    }
+
+    public void setAuthRealm_GreaterEqual(String authRealm, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("authRealm", ConditionKey.CK_GREATER_EQUAL, authRealm);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setAuthRealm_LessEqual(String authRealm) {
+        setAuthRealm_LessEqual(authRealm, null);
+    }
+
+    public void setAuthRealm_LessEqual(String authRealm, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("authRealm", ConditionKey.CK_LESS_EQUAL, authRealm);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_Term(String createdBy) {
+        setCreatedBy_Term(createdBy, null);
+    }
+
+    public void setCreatedBy_Term(String createdBy, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_Terms(Collection<String> createdByList) {
+        setCreatedBy_Terms(createdByList, null);
+    }
+
+    public void setCreatedBy_Terms(Collection<String> createdByList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("createdBy", createdByList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_InScope(Collection<String> createdByList) {
+        setCreatedBy_Terms(createdByList, null);
+    }
+
+    public void setCreatedBy_InScope(Collection<String> createdByList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setCreatedBy_Terms(createdByList, opLambda);
+    }
+
+    public void setCreatedBy_Prefix(String createdBy) {
+        setCreatedBy_Prefix(createdBy, null);
+    }
+
+    public void setCreatedBy_Prefix(String createdBy, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_Exists() {
+        setCreatedBy_Exists(null);
+    }
+
+    public void setCreatedBy_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("createdBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_Missing() {
+        setCreatedBy_Missing(null);
+    }
+
+    public void setCreatedBy_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("createdBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_GreaterThan(String createdBy) {
+        setCreatedBy_GreaterThan(createdBy, null);
+    }
+
+    public void setCreatedBy_GreaterThan(String createdBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_GREATER_THAN, createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_LessThan(String createdBy) {
+        setCreatedBy_LessThan(createdBy, null);
+    }
+
+    public void setCreatedBy_LessThan(String createdBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_LESS_THAN, createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_GreaterEqual(String createdBy) {
+        setCreatedBy_GreaterEqual(createdBy, null);
+    }
+
+    public void setCreatedBy_GreaterEqual(String createdBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_LessEqual(String createdBy) {
+        setCreatedBy_LessEqual(createdBy, null);
+    }
+
+    public void setCreatedBy_LessEqual(String createdBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_Term(Long createdTime) {
+        setCreatedTime_Term(createdTime, null);
+    }
+
+    public void setCreatedTime_Term(Long createdTime, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("createdTime", createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_Terms(Collection<Long> createdTimeList) {
+        setCreatedTime_Terms(createdTimeList, null);
+    }
+
+    public void setCreatedTime_Terms(Collection<Long> createdTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("createdTime", createdTimeList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_InScope(Collection<Long> createdTimeList) {
+        setCreatedTime_Terms(createdTimeList, null);
+    }
+
+    public void setCreatedTime_InScope(Collection<Long> createdTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setCreatedTime_Terms(createdTimeList, opLambda);
+    }
+
+    public void setCreatedTime_Exists() {
+        setCreatedTime_Exists(null);
+    }
+
+    public void setCreatedTime_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("createdTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_Missing() {
+        setCreatedTime_Missing(null);
+    }
+
+    public void setCreatedTime_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("createdTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_GreaterThan(Long createdTime) {
+        setCreatedTime_GreaterThan(createdTime, null);
+    }
+
+    public void setCreatedTime_GreaterThan(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_THAN, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_LessThan(Long createdTime) {
+        setCreatedTime_LessThan(createdTime, null);
+    }
+
+    public void setCreatedTime_LessThan(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_THAN, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_GreaterEqual(Long createdTime) {
+        setCreatedTime_GreaterEqual(createdTime, null);
+    }
+
+    public void setCreatedTime_GreaterEqual(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_LessEqual(Long createdTime) {
+        setCreatedTime_LessEqual(createdTime, null);
+    }
+
+    public void setCreatedTime_LessEqual(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setHostname_Term(String hostname) {
+        setHostname_Term(hostname, null);
+    }
+
+    public void setHostname_Term(String hostname, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("hostname", hostname);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setHostname_Terms(Collection<String> hostnameList) {
+        setHostname_Terms(hostnameList, null);
+    }
+
+    public void setHostname_Terms(Collection<String> hostnameList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("hostname", hostnameList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setHostname_InScope(Collection<String> hostnameList) {
+        setHostname_Terms(hostnameList, null);
+    }
+
+    public void setHostname_InScope(Collection<String> hostnameList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setHostname_Terms(hostnameList, opLambda);
+    }
+
+    public void setHostname_Prefix(String hostname) {
+        setHostname_Prefix(hostname, null);
+    }
+
+    public void setHostname_Prefix(String hostname, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("hostname", hostname);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setHostname_Exists() {
+        setHostname_Exists(null);
+    }
+
+    public void setHostname_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("hostname");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setHostname_Missing() {
+        setHostname_Missing(null);
+    }
+
+    public void setHostname_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("hostname");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setHostname_GreaterThan(String hostname) {
+        setHostname_GreaterThan(hostname, null);
+    }
+
+    public void setHostname_GreaterThan(String hostname, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("hostname", ConditionKey.CK_GREATER_THAN, hostname);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setHostname_LessThan(String hostname) {
+        setHostname_LessThan(hostname, null);
+    }
+
+    public void setHostname_LessThan(String hostname, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("hostname", ConditionKey.CK_LESS_THAN, hostname);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setHostname_GreaterEqual(String hostname) {
+        setHostname_GreaterEqual(hostname, null);
+    }
+
+    public void setHostname_GreaterEqual(String hostname, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("hostname", ConditionKey.CK_GREATER_EQUAL, hostname);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setHostname_LessEqual(String hostname) {
+        setHostname_LessEqual(hostname, null);
+    }
+
+    public void setHostname_LessEqual(String hostname, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("hostname", ConditionKey.CK_LESS_EQUAL, hostname);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Term(String id) {
+        setId_Term(id, null);
+    }
+
+    public void setId_Term(String id, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("id", id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Terms(Collection<String> idList) {
+        setId_Terms(idList, null);
+    }
+
+    public void setId_Terms(Collection<String> idList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("id", idList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_InScope(Collection<String> idList) {
+        setId_Terms(idList, null);
+    }
+
+    public void setId_InScope(Collection<String> idList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setId_Terms(idList, opLambda);
+    }
+
+    public void setId_Prefix(String id) {
+        setId_Prefix(id, null);
+    }
+
+    public void setId_Prefix(String id, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("id", id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Exists() {
+        setId_Exists(null);
+    }
+
+    public void setId_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("id");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Missing() {
+        setId_Missing(null);
+    }
+
+    public void setId_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("id");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_GreaterThan(String id) {
+        setId_GreaterThan(id, null);
+    }
+
+    public void setId_GreaterThan(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_THAN, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_LessThan(String id) {
+        setId_LessThan(id, null);
+    }
+
+    public void setId_LessThan(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_THAN, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_GreaterEqual(String id) {
+        setId_GreaterEqual(id, null);
+    }
+
+    public void setId_GreaterEqual(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_EQUAL, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_LessEqual(String id) {
+        setId_LessEqual(id, null);
+    }
+
+    public void setId_LessEqual(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_EQUAL, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setParameters_Term(String parameters) {
+        setParameters_Term(parameters, null);
+    }
+
+    public void setParameters_Term(String parameters, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("parameters", parameters);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setParameters_Terms(Collection<String> parametersList) {
+        setParameters_Terms(parametersList, null);
+    }
+
+    public void setParameters_Terms(Collection<String> parametersList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("parameters", parametersList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setParameters_InScope(Collection<String> parametersList) {
+        setParameters_Terms(parametersList, null);
+    }
+
+    public void setParameters_InScope(Collection<String> parametersList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setParameters_Terms(parametersList, opLambda);
+    }
+
+    public void setParameters_Prefix(String parameters) {
+        setParameters_Prefix(parameters, null);
+    }
+
+    public void setParameters_Prefix(String parameters, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("parameters", parameters);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setParameters_Exists() {
+        setParameters_Exists(null);
+    }
+
+    public void setParameters_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("parameters");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setParameters_Missing() {
+        setParameters_Missing(null);
+    }
+
+    public void setParameters_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("parameters");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setParameters_GreaterThan(String parameters) {
+        setParameters_GreaterThan(parameters, null);
+    }
+
+    public void setParameters_GreaterThan(String parameters, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("parameters", ConditionKey.CK_GREATER_THAN, parameters);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setParameters_LessThan(String parameters) {
+        setParameters_LessThan(parameters, null);
+    }
+
+    public void setParameters_LessThan(String parameters, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("parameters", ConditionKey.CK_LESS_THAN, parameters);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setParameters_GreaterEqual(String parameters) {
+        setParameters_GreaterEqual(parameters, null);
+    }
+
+    public void setParameters_GreaterEqual(String parameters, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("parameters", ConditionKey.CK_GREATER_EQUAL, parameters);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setParameters_LessEqual(String parameters) {
+        setParameters_LessEqual(parameters, null);
+    }
+
+    public void setParameters_LessEqual(String parameters, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("parameters", ConditionKey.CK_LESS_EQUAL, parameters);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setPassword_Term(String password) {
+        setPassword_Term(password, null);
+    }
+
+    public void setPassword_Term(String password, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("password", password);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setPassword_Terms(Collection<String> passwordList) {
+        setPassword_Terms(passwordList, null);
+    }
+
+    public void setPassword_Terms(Collection<String> passwordList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("password", passwordList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setPassword_InScope(Collection<String> passwordList) {
+        setPassword_Terms(passwordList, null);
+    }
+
+    public void setPassword_InScope(Collection<String> passwordList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setPassword_Terms(passwordList, opLambda);
+    }
+
+    public void setPassword_Prefix(String password) {
+        setPassword_Prefix(password, null);
+    }
+
+    public void setPassword_Prefix(String password, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("password", password);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setPassword_Exists() {
+        setPassword_Exists(null);
+    }
+
+    public void setPassword_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("password");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setPassword_Missing() {
+        setPassword_Missing(null);
+    }
+
+    public void setPassword_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("password");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setPassword_GreaterThan(String password) {
+        setPassword_GreaterThan(password, null);
+    }
+
+    public void setPassword_GreaterThan(String password, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("password", ConditionKey.CK_GREATER_THAN, password);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setPassword_LessThan(String password) {
+        setPassword_LessThan(password, null);
+    }
+
+    public void setPassword_LessThan(String password, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("password", ConditionKey.CK_LESS_THAN, password);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setPassword_GreaterEqual(String password) {
+        setPassword_GreaterEqual(password, null);
+    }
+
+    public void setPassword_GreaterEqual(String password, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("password", ConditionKey.CK_GREATER_EQUAL, password);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setPassword_LessEqual(String password) {
+        setPassword_LessEqual(password, null);
+    }
+
+    public void setPassword_LessEqual(String password, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("password", ConditionKey.CK_LESS_EQUAL, password);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setPort_Term(Integer port) {
+        setPort_Term(port, null);
+    }
+
+    public void setPort_Term(Integer port, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("port", port);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setPort_Terms(Collection<Integer> portList) {
+        setPort_Terms(portList, null);
+    }
+
+    public void setPort_Terms(Collection<Integer> portList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("port", portList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setPort_InScope(Collection<Integer> portList) {
+        setPort_Terms(portList, null);
+    }
+
+    public void setPort_InScope(Collection<Integer> portList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setPort_Terms(portList, opLambda);
+    }
+
+    public void setPort_Exists() {
+        setPort_Exists(null);
+    }
+
+    public void setPort_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("port");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setPort_Missing() {
+        setPort_Missing(null);
+    }
+
+    public void setPort_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("port");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setPort_GreaterThan(Integer port) {
+        setPort_GreaterThan(port, null);
+    }
+
+    public void setPort_GreaterThan(Integer port, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("port", ConditionKey.CK_GREATER_THAN, port);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setPort_LessThan(Integer port) {
+        setPort_LessThan(port, null);
+    }
+
+    public void setPort_LessThan(Integer port, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("port", ConditionKey.CK_LESS_THAN, port);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setPort_GreaterEqual(Integer port) {
+        setPort_GreaterEqual(port, null);
+    }
+
+    public void setPort_GreaterEqual(Integer port, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("port", ConditionKey.CK_GREATER_EQUAL, port);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setPort_LessEqual(Integer port) {
+        setPort_LessEqual(port, null);
+    }
+
+    public void setPort_LessEqual(Integer port, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("port", ConditionKey.CK_LESS_EQUAL, port);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setProtocolScheme_Term(String protocolScheme) {
+        setProtocolScheme_Term(protocolScheme, null);
+    }
+
+    public void setProtocolScheme_Term(String protocolScheme, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("protocolScheme", protocolScheme);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setProtocolScheme_Terms(Collection<String> protocolSchemeList) {
+        setProtocolScheme_Terms(protocolSchemeList, null);
+    }
+
+    public void setProtocolScheme_Terms(Collection<String> protocolSchemeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("protocolScheme", protocolSchemeList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setProtocolScheme_InScope(Collection<String> protocolSchemeList) {
+        setProtocolScheme_Terms(protocolSchemeList, null);
+    }
+
+    public void setProtocolScheme_InScope(Collection<String> protocolSchemeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setProtocolScheme_Terms(protocolSchemeList, opLambda);
+    }
+
+    public void setProtocolScheme_Prefix(String protocolScheme) {
+        setProtocolScheme_Prefix(protocolScheme, null);
+    }
+
+    public void setProtocolScheme_Prefix(String protocolScheme, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("protocolScheme", protocolScheme);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setProtocolScheme_Exists() {
+        setProtocolScheme_Exists(null);
+    }
+
+    public void setProtocolScheme_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("protocolScheme");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setProtocolScheme_Missing() {
+        setProtocolScheme_Missing(null);
+    }
+
+    public void setProtocolScheme_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("protocolScheme");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setProtocolScheme_GreaterThan(String protocolScheme) {
+        setProtocolScheme_GreaterThan(protocolScheme, null);
+    }
+
+    public void setProtocolScheme_GreaterThan(String protocolScheme, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("protocolScheme", ConditionKey.CK_GREATER_THAN, protocolScheme);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setProtocolScheme_LessThan(String protocolScheme) {
+        setProtocolScheme_LessThan(protocolScheme, null);
+    }
+
+    public void setProtocolScheme_LessThan(String protocolScheme, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("protocolScheme", ConditionKey.CK_LESS_THAN, protocolScheme);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setProtocolScheme_GreaterEqual(String protocolScheme) {
+        setProtocolScheme_GreaterEqual(protocolScheme, null);
+    }
+
+    public void setProtocolScheme_GreaterEqual(String protocolScheme, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("protocolScheme", ConditionKey.CK_GREATER_EQUAL, protocolScheme);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setProtocolScheme_LessEqual(String protocolScheme) {
+        setProtocolScheme_LessEqual(protocolScheme, null);
+    }
+
+    public void setProtocolScheme_LessEqual(String protocolScheme, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("protocolScheme", ConditionKey.CK_LESS_EQUAL, protocolScheme);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Term(String updatedBy) {
+        setUpdatedBy_Term(updatedBy, null);
+    }
+
+    public void setUpdatedBy_Term(String updatedBy, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Terms(Collection<String> updatedByList) {
+        setUpdatedBy_Terms(updatedByList, null);
+    }
+
+    public void setUpdatedBy_Terms(Collection<String> updatedByList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("updatedBy", updatedByList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_InScope(Collection<String> updatedByList) {
+        setUpdatedBy_Terms(updatedByList, null);
+    }
+
+    public void setUpdatedBy_InScope(Collection<String> updatedByList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setUpdatedBy_Terms(updatedByList, opLambda);
+    }
+
+    public void setUpdatedBy_Prefix(String updatedBy) {
+        setUpdatedBy_Prefix(updatedBy, null);
+    }
+
+    public void setUpdatedBy_Prefix(String updatedBy, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Exists() {
+        setUpdatedBy_Exists(null);
+    }
+
+    public void setUpdatedBy_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("updatedBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Missing() {
+        setUpdatedBy_Missing(null);
+    }
+
+    public void setUpdatedBy_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("updatedBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_GreaterThan(String updatedBy) {
+        setUpdatedBy_GreaterThan(updatedBy, null);
+    }
+
+    public void setUpdatedBy_GreaterThan(String updatedBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_LessThan(String updatedBy) {
+        setUpdatedBy_LessThan(updatedBy, null);
+    }
+
+    public void setUpdatedBy_LessThan(String updatedBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_GreaterEqual(String updatedBy) {
+        setUpdatedBy_GreaterEqual(updatedBy, null);
+    }
+
+    public void setUpdatedBy_GreaterEqual(String updatedBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_LessEqual(String updatedBy) {
+        setUpdatedBy_LessEqual(updatedBy, null);
+    }
+
+    public void setUpdatedBy_LessEqual(String updatedBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_Term(Long updatedTime) {
+        setUpdatedTime_Term(updatedTime, null);
+    }
+
+    public void setUpdatedTime_Term(Long updatedTime, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("updatedTime", updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_Terms(Collection<Long> updatedTimeList) {
+        setUpdatedTime_Terms(updatedTimeList, null);
+    }
+
+    public void setUpdatedTime_Terms(Collection<Long> updatedTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("updatedTime", updatedTimeList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_InScope(Collection<Long> updatedTimeList) {
+        setUpdatedTime_Terms(updatedTimeList, null);
+    }
+
+    public void setUpdatedTime_InScope(Collection<Long> updatedTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setUpdatedTime_Terms(updatedTimeList, opLambda);
+    }
+
+    public void setUpdatedTime_Exists() {
+        setUpdatedTime_Exists(null);
+    }
+
+    public void setUpdatedTime_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("updatedTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_Missing() {
+        setUpdatedTime_Missing(null);
+    }
+
+    public void setUpdatedTime_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("updatedTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_GreaterThan(Long updatedTime) {
+        setUpdatedTime_GreaterThan(updatedTime, null);
+    }
+
+    public void setUpdatedTime_GreaterThan(Long updatedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_LessThan(Long updatedTime) {
+        setUpdatedTime_LessThan(updatedTime, null);
+    }
+
+    public void setUpdatedTime_LessThan(Long updatedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_GreaterEqual(Long updatedTime) {
+        setUpdatedTime_GreaterEqual(updatedTime, null);
+    }
+
+    public void setUpdatedTime_GreaterEqual(Long updatedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_LessEqual(Long updatedTime) {
+        setUpdatedTime_LessEqual(updatedTime, null);
+    }
+
+    public void setUpdatedTime_LessEqual(Long updatedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUsername_Term(String username) {
+        setUsername_Term(username, null);
+    }
+
+    public void setUsername_Term(String username, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("username", username);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUsername_Terms(Collection<String> usernameList) {
+        setUsername_Terms(usernameList, null);
+    }
+
+    public void setUsername_Terms(Collection<String> usernameList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("username", usernameList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUsername_InScope(Collection<String> usernameList) {
+        setUsername_Terms(usernameList, null);
+    }
+
+    public void setUsername_InScope(Collection<String> usernameList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setUsername_Terms(usernameList, opLambda);
+    }
+
+    public void setUsername_Prefix(String username) {
+        setUsername_Prefix(username, null);
+    }
+
+    public void setUsername_Prefix(String username, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("username", username);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUsername_Exists() {
+        setUsername_Exists(null);
+    }
+
+    public void setUsername_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("username");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUsername_Missing() {
+        setUsername_Missing(null);
+    }
+
+    public void setUsername_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("username");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUsername_GreaterThan(String username) {
+        setUsername_GreaterThan(username, null);
+    }
+
+    public void setUsername_GreaterThan(String username, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("username", ConditionKey.CK_GREATER_THAN, username);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUsername_LessThan(String username) {
+        setUsername_LessThan(username, null);
+    }
+
+    public void setUsername_LessThan(String username, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("username", ConditionKey.CK_LESS_THAN, username);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUsername_GreaterEqual(String username) {
+        setUsername_GreaterEqual(username, null);
+    }
+
+    public void setUsername_GreaterEqual(String username, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("username", ConditionKey.CK_GREATER_EQUAL, username);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUsername_LessEqual(String username) {
+        setUsername_LessEqual(username, null);
+    }
+
+    public void setUsername_LessEqual(String username, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("username", ConditionKey.CK_LESS_EQUAL, username);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setWebConfigId_Term(String webConfigId) {
+        setWebConfigId_Term(webConfigId, null);
+    }
+
+    public void setWebConfigId_Term(String webConfigId, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("webConfigId", webConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setWebConfigId_Terms(Collection<String> webConfigIdList) {
+        setWebConfigId_Terms(webConfigIdList, null);
+    }
+
+    public void setWebConfigId_Terms(Collection<String> webConfigIdList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("webConfigId", webConfigIdList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setWebConfigId_InScope(Collection<String> webConfigIdList) {
+        setWebConfigId_Terms(webConfigIdList, null);
+    }
+
+    public void setWebConfigId_InScope(Collection<String> webConfigIdList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setWebConfigId_Terms(webConfigIdList, opLambda);
+    }
+
+    public void setWebConfigId_Prefix(String webConfigId) {
+        setWebConfigId_Prefix(webConfigId, null);
+    }
+
+    public void setWebConfigId_Prefix(String webConfigId, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("webConfigId", webConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setWebConfigId_Exists() {
+        setWebConfigId_Exists(null);
+    }
+
+    public void setWebConfigId_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("webConfigId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setWebConfigId_Missing() {
+        setWebConfigId_Missing(null);
+    }
+
+    public void setWebConfigId_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("webConfigId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setWebConfigId_GreaterThan(String webConfigId) {
+        setWebConfigId_GreaterThan(webConfigId, null);
+    }
+
+    public void setWebConfigId_GreaterThan(String webConfigId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("webConfigId", ConditionKey.CK_GREATER_THAN, webConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setWebConfigId_LessThan(String webConfigId) {
+        setWebConfigId_LessThan(webConfigId, null);
+    }
+
+    public void setWebConfigId_LessThan(String webConfigId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("webConfigId", ConditionKey.CK_LESS_THAN, webConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setWebConfigId_GreaterEqual(String webConfigId) {
+        setWebConfigId_GreaterEqual(webConfigId, null);
+    }
+
+    public void setWebConfigId_GreaterEqual(String webConfigId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("webConfigId", ConditionKey.CK_GREATER_EQUAL, webConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setWebConfigId_LessEqual(String webConfigId) {
+        setWebConfigId_LessEqual(webConfigId, null);
+    }
+
+    public void setWebConfigId_LessEqual(String webConfigId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("webConfigId", ConditionKey.CK_LESS_EQUAL, webConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+}

src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsWebConfigCF.java

@@ -0,0 +1,2150 @@
+package org.codelibs.fess.es.cbean.cf.bs;
+
+import java.util.Collection;
+
+import org.codelibs.fess.es.cbean.cf.WebConfigCF;
+import org.codelibs.fess.es.cbean.cq.WebConfigCQ;
+import org.dbflute.exception.IllegalConditionBeanOperationException;
+import org.dbflute.cbean.ckey.ConditionKey;
+import org.elasticsearch.index.query.AndFilterBuilder;
+import org.elasticsearch.index.query.BoolFilterBuilder;
+import org.elasticsearch.index.query.ExistsFilterBuilder;
+import org.elasticsearch.index.query.MissingFilterBuilder;
+import org.elasticsearch.index.query.NotFilterBuilder;
+import org.elasticsearch.index.query.OrFilterBuilder;
+import org.elasticsearch.index.query.PrefixFilterBuilder;
+import org.elasticsearch.index.query.QueryFilterBuilder;
+import org.elasticsearch.index.query.RangeFilterBuilder;
+import org.elasticsearch.index.query.TermFilterBuilder;
+import org.elasticsearch.index.query.TermsFilterBuilder;
+
+/**
+ * @author FreeGen
+ */
+public abstract class BsWebConfigCF extends AbstractConditionFilter {
+
+    public void bool(BoolCall<WebConfigCF> boolLambda) {
+        bool(boolLambda, null);
+    }
+
+    public void bool(BoolCall<WebConfigCF> boolLambda, ConditionOptionCall<BoolFilterBuilder> opLambda) {
+        WebConfigCF mustFilter = new WebConfigCF();
+        WebConfigCF shouldFilter = new WebConfigCF();
+        WebConfigCF mustNotFilter = new WebConfigCF();
+        boolLambda.callback(mustFilter, shouldFilter, mustNotFilter);
+        if (mustFilter.hasFilters() || shouldFilter.hasFilters() || mustNotFilter.hasFilters()) {
+            BoolFilterBuilder builder =
+                    regBoolF(mustFilter.filterBuilderList, shouldFilter.filterBuilderList, mustNotFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void and(OperatorCall<WebConfigCF> andLambda) {
+        and(andLambda, null);
+    }
+
+    public void and(OperatorCall<WebConfigCF> andLambda, ConditionOptionCall<AndFilterBuilder> opLambda) {
+        WebConfigCF andFilter = new WebConfigCF();
+        andLambda.callback(andFilter);
+        if (andFilter.hasFilters()) {
+            AndFilterBuilder builder = regAndF(andFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void or(OperatorCall<WebConfigCF> orLambda) {
+        or(orLambda, null);
+    }
+
+    public void or(OperatorCall<WebConfigCF> orLambda, ConditionOptionCall<OrFilterBuilder> opLambda) {
+        WebConfigCF orFilter = new WebConfigCF();
+        orLambda.callback(orFilter);
+        if (orFilter.hasFilters()) {
+            OrFilterBuilder builder = regOrF(orFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void not(OperatorCall<WebConfigCF> notLambda) {
+        not(notLambda, null);
+    }
+
+    public void not(OperatorCall<WebConfigCF> notLambda, ConditionOptionCall<NotFilterBuilder> opLambda) {
+        WebConfigCF notFilter = new WebConfigCF();
+        notLambda.callback(notFilter);
+        if (notFilter.hasFilters()) {
+            if (notFilter.filterBuilderList.size() > 1) {
+                final String msg = "not filter must be one filter.";
+                throw new IllegalConditionBeanOperationException(msg);
+            }
+            NotFilterBuilder builder = regNotF(notFilter.filterBuilderList.get(0));
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall<WebConfigCQ> queryLambda) {
+        query(queryLambda, null);
+    }
+
+    public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall<WebConfigCQ> queryLambda,
+            ConditionOptionCall<QueryFilterBuilder> opLambda) {
+        WebConfigCQ query = new WebConfigCQ();
+        queryLambda.callback(query);
+        if (query.hasQueries()) {
+            QueryFilterBuilder builder = regQueryF(query.getQuery());
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void setAvailable_Term(Boolean available) {
+        setAvailable_Term(available, null);
+    }
+
+    public void setAvailable_Term(Boolean available, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("available", available);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setAvailable_Terms(Collection<Boolean> availableList) {
+        setAvailable_Terms(availableList, null);
+    }
+
+    public void setAvailable_Terms(Collection<Boolean> availableList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("available", availableList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setAvailable_InScope(Collection<Boolean> availableList) {
+        setAvailable_Terms(availableList, null);
+    }
+
+    public void setAvailable_InScope(Collection<Boolean> availableList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setAvailable_Terms(availableList, opLambda);
+    }
+
+    public void setAvailable_Exists() {
+        setAvailable_Exists(null);
+    }
+
+    public void setAvailable_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("available");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setAvailable_Missing() {
+        setAvailable_Missing(null);
+    }
+
+    public void setAvailable_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("available");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setAvailable_GreaterThan(Boolean available) {
+        setAvailable_GreaterThan(available, null);
+    }
+
+    public void setAvailable_GreaterThan(Boolean available, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("available", ConditionKey.CK_GREATER_THAN, available);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setAvailable_LessThan(Boolean available) {
+        setAvailable_LessThan(available, null);
+    }
+
+    public void setAvailable_LessThan(Boolean available, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("available", ConditionKey.CK_LESS_THAN, available);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setAvailable_GreaterEqual(Boolean available) {
+        setAvailable_GreaterEqual(available, null);
+    }
+
+    public void setAvailable_GreaterEqual(Boolean available, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("available", ConditionKey.CK_GREATER_EQUAL, available);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setAvailable_LessEqual(Boolean available) {
+        setAvailable_LessEqual(available, null);
+    }
+
+    public void setAvailable_LessEqual(Boolean available, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("available", ConditionKey.CK_LESS_EQUAL, available);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setBoost_Term(Float boost) {
+        setBoost_Term(boost, null);
+    }
+
+    public void setBoost_Term(Float boost, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("boost", boost);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setBoost_Terms(Collection<Float> boostList) {
+        setBoost_Terms(boostList, null);
+    }
+
+    public void setBoost_Terms(Collection<Float> boostList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("boost", boostList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setBoost_InScope(Collection<Float> boostList) {
+        setBoost_Terms(boostList, null);
+    }
+
+    public void setBoost_InScope(Collection<Float> boostList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setBoost_Terms(boostList, opLambda);
+    }
+
+    public void setBoost_Exists() {
+        setBoost_Exists(null);
+    }
+
+    public void setBoost_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("boost");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setBoost_Missing() {
+        setBoost_Missing(null);
+    }
+
+    public void setBoost_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("boost");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setBoost_GreaterThan(Float boost) {
+        setBoost_GreaterThan(boost, null);
+    }
+
+    public void setBoost_GreaterThan(Float boost, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("boost", ConditionKey.CK_GREATER_THAN, boost);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setBoost_LessThan(Float boost) {
+        setBoost_LessThan(boost, null);
+    }
+
+    public void setBoost_LessThan(Float boost, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("boost", ConditionKey.CK_LESS_THAN, boost);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setBoost_GreaterEqual(Float boost) {
+        setBoost_GreaterEqual(boost, null);
+    }
+
+    public void setBoost_GreaterEqual(Float boost, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("boost", ConditionKey.CK_GREATER_EQUAL, boost);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setBoost_LessEqual(Float boost) {
+        setBoost_LessEqual(boost, null);
+    }
+
+    public void setBoost_LessEqual(Float boost, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("boost", ConditionKey.CK_LESS_EQUAL, boost);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setConfigParameter_Term(String configParameter) {
+        setConfigParameter_Term(configParameter, null);
+    }
+
+    public void setConfigParameter_Term(String configParameter, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("configParameter", configParameter);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setConfigParameter_Terms(Collection<String> configParameterList) {
+        setConfigParameter_Terms(configParameterList, null);
+    }
+
+    public void setConfigParameter_Terms(Collection<String> configParameterList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("configParameter", configParameterList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setConfigParameter_InScope(Collection<String> configParameterList) {
+        setConfigParameter_Terms(configParameterList, null);
+    }
+
+    public void setConfigParameter_InScope(Collection<String> configParameterList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setConfigParameter_Terms(configParameterList, opLambda);
+    }
+
+    public void setConfigParameter_Prefix(String configParameter) {
+        setConfigParameter_Prefix(configParameter, null);
+    }
+
+    public void setConfigParameter_Prefix(String configParameter, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("configParameter", configParameter);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setConfigParameter_Exists() {
+        setConfigParameter_Exists(null);
+    }
+
+    public void setConfigParameter_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("configParameter");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setConfigParameter_Missing() {
+        setConfigParameter_Missing(null);
+    }
+
+    public void setConfigParameter_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("configParameter");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setConfigParameter_GreaterThan(String configParameter) {
+        setConfigParameter_GreaterThan(configParameter, null);
+    }
+
+    public void setConfigParameter_GreaterThan(String configParameter, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("configParameter", ConditionKey.CK_GREATER_THAN, configParameter);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setConfigParameter_LessThan(String configParameter) {
+        setConfigParameter_LessThan(configParameter, null);
+    }
+
+    public void setConfigParameter_LessThan(String configParameter, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("configParameter", ConditionKey.CK_LESS_THAN, configParameter);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setConfigParameter_GreaterEqual(String configParameter) {
+        setConfigParameter_GreaterEqual(configParameter, null);
+    }
+
+    public void setConfigParameter_GreaterEqual(String configParameter, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("configParameter", ConditionKey.CK_GREATER_EQUAL, configParameter);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setConfigParameter_LessEqual(String configParameter) {
+        setConfigParameter_LessEqual(configParameter, null);
+    }
+
+    public void setConfigParameter_LessEqual(String configParameter, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("configParameter", ConditionKey.CK_LESS_EQUAL, configParameter);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_Term(String createdBy) {
+        setCreatedBy_Term(createdBy, null);
+    }
+
+    public void setCreatedBy_Term(String createdBy, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_Terms(Collection<String> createdByList) {
+        setCreatedBy_Terms(createdByList, null);
+    }
+
+    public void setCreatedBy_Terms(Collection<String> createdByList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("createdBy", createdByList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_InScope(Collection<String> createdByList) {
+        setCreatedBy_Terms(createdByList, null);
+    }
+
+    public void setCreatedBy_InScope(Collection<String> createdByList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setCreatedBy_Terms(createdByList, opLambda);
+    }
+
+    public void setCreatedBy_Prefix(String createdBy) {
+        setCreatedBy_Prefix(createdBy, null);
+    }
+
+    public void setCreatedBy_Prefix(String createdBy, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_Exists() {
+        setCreatedBy_Exists(null);
+    }
+
+    public void setCreatedBy_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("createdBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_Missing() {
+        setCreatedBy_Missing(null);
+    }
+
+    public void setCreatedBy_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("createdBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_GreaterThan(String createdBy) {
+        setCreatedBy_GreaterThan(createdBy, null);
+    }
+
+    public void setCreatedBy_GreaterThan(String createdBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_GREATER_THAN, createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_LessThan(String createdBy) {
+        setCreatedBy_LessThan(createdBy, null);
+    }
+
+    public void setCreatedBy_LessThan(String createdBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_LESS_THAN, createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_GreaterEqual(String createdBy) {
+        setCreatedBy_GreaterEqual(createdBy, null);
+    }
+
+    public void setCreatedBy_GreaterEqual(String createdBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_LessEqual(String createdBy) {
+        setCreatedBy_LessEqual(createdBy, null);
+    }
+
+    public void setCreatedBy_LessEqual(String createdBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_Term(Long createdTime) {
+        setCreatedTime_Term(createdTime, null);
+    }
+
+    public void setCreatedTime_Term(Long createdTime, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("createdTime", createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_Terms(Collection<Long> createdTimeList) {
+        setCreatedTime_Terms(createdTimeList, null);
+    }
+
+    public void setCreatedTime_Terms(Collection<Long> createdTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("createdTime", createdTimeList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_InScope(Collection<Long> createdTimeList) {
+        setCreatedTime_Terms(createdTimeList, null);
+    }
+
+    public void setCreatedTime_InScope(Collection<Long> createdTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setCreatedTime_Terms(createdTimeList, opLambda);
+    }
+
+    public void setCreatedTime_Exists() {
+        setCreatedTime_Exists(null);
+    }
+
+    public void setCreatedTime_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("createdTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_Missing() {
+        setCreatedTime_Missing(null);
+    }
+
+    public void setCreatedTime_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("createdTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_GreaterThan(Long createdTime) {
+        setCreatedTime_GreaterThan(createdTime, null);
+    }
+
+    public void setCreatedTime_GreaterThan(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_THAN, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_LessThan(Long createdTime) {
+        setCreatedTime_LessThan(createdTime, null);
+    }
+
+    public void setCreatedTime_LessThan(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_THAN, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_GreaterEqual(Long createdTime) {
+        setCreatedTime_GreaterEqual(createdTime, null);
+    }
+
+    public void setCreatedTime_GreaterEqual(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_LessEqual(Long createdTime) {
+        setCreatedTime_LessEqual(createdTime, null);
+    }
+
+    public void setCreatedTime_LessEqual(Long createdTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setDepth_Term(Integer depth) {
+        setDepth_Term(depth, null);
+    }
+
+    public void setDepth_Term(Integer depth, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("depth", depth);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setDepth_Terms(Collection<Integer> depthList) {
+        setDepth_Terms(depthList, null);
+    }
+
+    public void setDepth_Terms(Collection<Integer> depthList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("depth", depthList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setDepth_InScope(Collection<Integer> depthList) {
+        setDepth_Terms(depthList, null);
+    }
+
+    public void setDepth_InScope(Collection<Integer> depthList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setDepth_Terms(depthList, opLambda);
+    }
+
+    public void setDepth_Exists() {
+        setDepth_Exists(null);
+    }
+
+    public void setDepth_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("depth");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setDepth_Missing() {
+        setDepth_Missing(null);
+    }
+
+    public void setDepth_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("depth");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setDepth_GreaterThan(Integer depth) {
+        setDepth_GreaterThan(depth, null);
+    }
+
+    public void setDepth_GreaterThan(Integer depth, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("depth", ConditionKey.CK_GREATER_THAN, depth);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setDepth_LessThan(Integer depth) {
+        setDepth_LessThan(depth, null);
+    }
+
+    public void setDepth_LessThan(Integer depth, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("depth", ConditionKey.CK_LESS_THAN, depth);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setDepth_GreaterEqual(Integer depth) {
+        setDepth_GreaterEqual(depth, null);
+    }
+
+    public void setDepth_GreaterEqual(Integer depth, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("depth", ConditionKey.CK_GREATER_EQUAL, depth);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setDepth_LessEqual(Integer depth) {
+        setDepth_LessEqual(depth, null);
+    }
+
+    public void setDepth_LessEqual(Integer depth, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("depth", ConditionKey.CK_LESS_EQUAL, depth);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setExcludedDocUrls_Term(String excludedDocUrls) {
+        setExcludedDocUrls_Term(excludedDocUrls, null);
+    }
+
+    public void setExcludedDocUrls_Term(String excludedDocUrls, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("excludedDocUrls", excludedDocUrls);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setExcludedDocUrls_Terms(Collection<String> excludedDocUrlsList) {
+        setExcludedDocUrls_Terms(excludedDocUrlsList, null);
+    }
+
+    public void setExcludedDocUrls_Terms(Collection<String> excludedDocUrlsList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("excludedDocUrls", excludedDocUrlsList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setExcludedDocUrls_InScope(Collection<String> excludedDocUrlsList) {
+        setExcludedDocUrls_Terms(excludedDocUrlsList, null);
+    }
+
+    public void setExcludedDocUrls_InScope(Collection<String> excludedDocUrlsList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setExcludedDocUrls_Terms(excludedDocUrlsList, opLambda);
+    }
+
+    public void setExcludedDocUrls_Prefix(String excludedDocUrls) {
+        setExcludedDocUrls_Prefix(excludedDocUrls, null);
+    }
+
+    public void setExcludedDocUrls_Prefix(String excludedDocUrls, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("excludedDocUrls", excludedDocUrls);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setExcludedDocUrls_Exists() {
+        setExcludedDocUrls_Exists(null);
+    }
+
+    public void setExcludedDocUrls_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("excludedDocUrls");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setExcludedDocUrls_Missing() {
+        setExcludedDocUrls_Missing(null);
+    }
+
+    public void setExcludedDocUrls_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("excludedDocUrls");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setExcludedDocUrls_GreaterThan(String excludedDocUrls) {
+        setExcludedDocUrls_GreaterThan(excludedDocUrls, null);
+    }
+
+    public void setExcludedDocUrls_GreaterThan(String excludedDocUrls, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("excludedDocUrls", ConditionKey.CK_GREATER_THAN, excludedDocUrls);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setExcludedDocUrls_LessThan(String excludedDocUrls) {
+        setExcludedDocUrls_LessThan(excludedDocUrls, null);
+    }
+
+    public void setExcludedDocUrls_LessThan(String excludedDocUrls, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("excludedDocUrls", ConditionKey.CK_LESS_THAN, excludedDocUrls);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setExcludedDocUrls_GreaterEqual(String excludedDocUrls) {
+        setExcludedDocUrls_GreaterEqual(excludedDocUrls, null);
+    }
+
+    public void setExcludedDocUrls_GreaterEqual(String excludedDocUrls, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("excludedDocUrls", ConditionKey.CK_GREATER_EQUAL, excludedDocUrls);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setExcludedDocUrls_LessEqual(String excludedDocUrls) {
+        setExcludedDocUrls_LessEqual(excludedDocUrls, null);
+    }
+
+    public void setExcludedDocUrls_LessEqual(String excludedDocUrls, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("excludedDocUrls", ConditionKey.CK_LESS_EQUAL, excludedDocUrls);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setExcludedUrls_Term(String excludedUrls) {
+        setExcludedUrls_Term(excludedUrls, null);
+    }
+
+    public void setExcludedUrls_Term(String excludedUrls, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("excludedUrls", excludedUrls);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setExcludedUrls_Terms(Collection<String> excludedUrlsList) {
+        setExcludedUrls_Terms(excludedUrlsList, null);
+    }
+
+    public void setExcludedUrls_Terms(Collection<String> excludedUrlsList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("excludedUrls", excludedUrlsList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setExcludedUrls_InScope(Collection<String> excludedUrlsList) {
+        setExcludedUrls_Terms(excludedUrlsList, null);
+    }
+
+    public void setExcludedUrls_InScope(Collection<String> excludedUrlsList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setExcludedUrls_Terms(excludedUrlsList, opLambda);
+    }
+
+    public void setExcludedUrls_Prefix(String excludedUrls) {
+        setExcludedUrls_Prefix(excludedUrls, null);
+    }
+
+    public void setExcludedUrls_Prefix(String excludedUrls, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("excludedUrls", excludedUrls);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setExcludedUrls_Exists() {
+        setExcludedUrls_Exists(null);
+    }
+
+    public void setExcludedUrls_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("excludedUrls");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setExcludedUrls_Missing() {
+        setExcludedUrls_Missing(null);
+    }
+
+    public void setExcludedUrls_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("excludedUrls");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setExcludedUrls_GreaterThan(String excludedUrls) {
+        setExcludedUrls_GreaterThan(excludedUrls, null);
+    }
+
+    public void setExcludedUrls_GreaterThan(String excludedUrls, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("excludedUrls", ConditionKey.CK_GREATER_THAN, excludedUrls);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setExcludedUrls_LessThan(String excludedUrls) {
+        setExcludedUrls_LessThan(excludedUrls, null);
+    }
+
+    public void setExcludedUrls_LessThan(String excludedUrls, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("excludedUrls", ConditionKey.CK_LESS_THAN, excludedUrls);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setExcludedUrls_GreaterEqual(String excludedUrls) {
+        setExcludedUrls_GreaterEqual(excludedUrls, null);
+    }
+
+    public void setExcludedUrls_GreaterEqual(String excludedUrls, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("excludedUrls", ConditionKey.CK_GREATER_EQUAL, excludedUrls);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setExcludedUrls_LessEqual(String excludedUrls) {
+        setExcludedUrls_LessEqual(excludedUrls, null);
+    }
+
+    public void setExcludedUrls_LessEqual(String excludedUrls, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("excludedUrls", ConditionKey.CK_LESS_EQUAL, excludedUrls);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Term(String id) {
+        setId_Term(id, null);
+    }
+
+    public void setId_Term(String id, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("id", id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Terms(Collection<String> idList) {
+        setId_Terms(idList, null);
+    }
+
+    public void setId_Terms(Collection<String> idList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("id", idList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_InScope(Collection<String> idList) {
+        setId_Terms(idList, null);
+    }
+
+    public void setId_InScope(Collection<String> idList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setId_Terms(idList, opLambda);
+    }
+
+    public void setId_Prefix(String id) {
+        setId_Prefix(id, null);
+    }
+
+    public void setId_Prefix(String id, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("id", id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Exists() {
+        setId_Exists(null);
+    }
+
+    public void setId_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("id");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Missing() {
+        setId_Missing(null);
+    }
+
+    public void setId_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("id");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_GreaterThan(String id) {
+        setId_GreaterThan(id, null);
+    }
+
+    public void setId_GreaterThan(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_THAN, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_LessThan(String id) {
+        setId_LessThan(id, null);
+    }
+
+    public void setId_LessThan(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_THAN, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_GreaterEqual(String id) {
+        setId_GreaterEqual(id, null);
+    }
+
+    public void setId_GreaterEqual(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_EQUAL, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_LessEqual(String id) {
+        setId_LessEqual(id, null);
+    }
+
+    public void setId_LessEqual(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_EQUAL, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIncludedDocUrls_Term(String includedDocUrls) {
+        setIncludedDocUrls_Term(includedDocUrls, null);
+    }
+
+    public void setIncludedDocUrls_Term(String includedDocUrls, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("includedDocUrls", includedDocUrls);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIncludedDocUrls_Terms(Collection<String> includedDocUrlsList) {
+        setIncludedDocUrls_Terms(includedDocUrlsList, null);
+    }
+
+    public void setIncludedDocUrls_Terms(Collection<String> includedDocUrlsList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("includedDocUrls", includedDocUrlsList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIncludedDocUrls_InScope(Collection<String> includedDocUrlsList) {
+        setIncludedDocUrls_Terms(includedDocUrlsList, null);
+    }
+
+    public void setIncludedDocUrls_InScope(Collection<String> includedDocUrlsList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setIncludedDocUrls_Terms(includedDocUrlsList, opLambda);
+    }
+
+    public void setIncludedDocUrls_Prefix(String includedDocUrls) {
+        setIncludedDocUrls_Prefix(includedDocUrls, null);
+    }
+
+    public void setIncludedDocUrls_Prefix(String includedDocUrls, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("includedDocUrls", includedDocUrls);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIncludedDocUrls_Exists() {
+        setIncludedDocUrls_Exists(null);
+    }
+
+    public void setIncludedDocUrls_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("includedDocUrls");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIncludedDocUrls_Missing() {
+        setIncludedDocUrls_Missing(null);
+    }
+
+    public void setIncludedDocUrls_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("includedDocUrls");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIncludedDocUrls_GreaterThan(String includedDocUrls) {
+        setIncludedDocUrls_GreaterThan(includedDocUrls, null);
+    }
+
+    public void setIncludedDocUrls_GreaterThan(String includedDocUrls, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("includedDocUrls", ConditionKey.CK_GREATER_THAN, includedDocUrls);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIncludedDocUrls_LessThan(String includedDocUrls) {
+        setIncludedDocUrls_LessThan(includedDocUrls, null);
+    }
+
+    public void setIncludedDocUrls_LessThan(String includedDocUrls, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("includedDocUrls", ConditionKey.CK_LESS_THAN, includedDocUrls);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIncludedDocUrls_GreaterEqual(String includedDocUrls) {
+        setIncludedDocUrls_GreaterEqual(includedDocUrls, null);
+    }
+
+    public void setIncludedDocUrls_GreaterEqual(String includedDocUrls, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("includedDocUrls", ConditionKey.CK_GREATER_EQUAL, includedDocUrls);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIncludedDocUrls_LessEqual(String includedDocUrls) {
+        setIncludedDocUrls_LessEqual(includedDocUrls, null);
+    }
+
+    public void setIncludedDocUrls_LessEqual(String includedDocUrls, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("includedDocUrls", ConditionKey.CK_LESS_EQUAL, includedDocUrls);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIncludedUrls_Term(String includedUrls) {
+        setIncludedUrls_Term(includedUrls, null);
+    }
+
+    public void setIncludedUrls_Term(String includedUrls, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("includedUrls", includedUrls);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIncludedUrls_Terms(Collection<String> includedUrlsList) {
+        setIncludedUrls_Terms(includedUrlsList, null);
+    }
+
+    public void setIncludedUrls_Terms(Collection<String> includedUrlsList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("includedUrls", includedUrlsList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIncludedUrls_InScope(Collection<String> includedUrlsList) {
+        setIncludedUrls_Terms(includedUrlsList, null);
+    }
+
+    public void setIncludedUrls_InScope(Collection<String> includedUrlsList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setIncludedUrls_Terms(includedUrlsList, opLambda);
+    }
+
+    public void setIncludedUrls_Prefix(String includedUrls) {
+        setIncludedUrls_Prefix(includedUrls, null);
+    }
+
+    public void setIncludedUrls_Prefix(String includedUrls, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("includedUrls", includedUrls);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIncludedUrls_Exists() {
+        setIncludedUrls_Exists(null);
+    }
+
+    public void setIncludedUrls_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("includedUrls");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIncludedUrls_Missing() {
+        setIncludedUrls_Missing(null);
+    }
+
+    public void setIncludedUrls_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("includedUrls");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIncludedUrls_GreaterThan(String includedUrls) {
+        setIncludedUrls_GreaterThan(includedUrls, null);
+    }
+
+    public void setIncludedUrls_GreaterThan(String includedUrls, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("includedUrls", ConditionKey.CK_GREATER_THAN, includedUrls);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIncludedUrls_LessThan(String includedUrls) {
+        setIncludedUrls_LessThan(includedUrls, null);
+    }
+
+    public void setIncludedUrls_LessThan(String includedUrls, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("includedUrls", ConditionKey.CK_LESS_THAN, includedUrls);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIncludedUrls_GreaterEqual(String includedUrls) {
+        setIncludedUrls_GreaterEqual(includedUrls, null);
+    }
+
+    public void setIncludedUrls_GreaterEqual(String includedUrls, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("includedUrls", ConditionKey.CK_GREATER_EQUAL, includedUrls);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIncludedUrls_LessEqual(String includedUrls) {
+        setIncludedUrls_LessEqual(includedUrls, null);
+    }
+
+    public void setIncludedUrls_LessEqual(String includedUrls, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("includedUrls", ConditionKey.CK_LESS_EQUAL, includedUrls);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIntervalTime_Term(Integer intervalTime) {
+        setIntervalTime_Term(intervalTime, null);
+    }
+
+    public void setIntervalTime_Term(Integer intervalTime, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("intervalTime", intervalTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIntervalTime_Terms(Collection<Integer> intervalTimeList) {
+        setIntervalTime_Terms(intervalTimeList, null);
+    }
+
+    public void setIntervalTime_Terms(Collection<Integer> intervalTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("intervalTime", intervalTimeList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIntervalTime_InScope(Collection<Integer> intervalTimeList) {
+        setIntervalTime_Terms(intervalTimeList, null);
+    }
+
+    public void setIntervalTime_InScope(Collection<Integer> intervalTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setIntervalTime_Terms(intervalTimeList, opLambda);
+    }
+
+    public void setIntervalTime_Exists() {
+        setIntervalTime_Exists(null);
+    }
+
+    public void setIntervalTime_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("intervalTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIntervalTime_Missing() {
+        setIntervalTime_Missing(null);
+    }
+
+    public void setIntervalTime_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("intervalTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIntervalTime_GreaterThan(Integer intervalTime) {
+        setIntervalTime_GreaterThan(intervalTime, null);
+    }
+
+    public void setIntervalTime_GreaterThan(Integer intervalTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("intervalTime", ConditionKey.CK_GREATER_THAN, intervalTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIntervalTime_LessThan(Integer intervalTime) {
+        setIntervalTime_LessThan(intervalTime, null);
+    }
+
+    public void setIntervalTime_LessThan(Integer intervalTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("intervalTime", ConditionKey.CK_LESS_THAN, intervalTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIntervalTime_GreaterEqual(Integer intervalTime) {
+        setIntervalTime_GreaterEqual(intervalTime, null);
+    }
+
+    public void setIntervalTime_GreaterEqual(Integer intervalTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("intervalTime", ConditionKey.CK_GREATER_EQUAL, intervalTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIntervalTime_LessEqual(Integer intervalTime) {
+        setIntervalTime_LessEqual(intervalTime, null);
+    }
+
+    public void setIntervalTime_LessEqual(Integer intervalTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("intervalTime", ConditionKey.CK_LESS_EQUAL, intervalTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setMaxAccessCount_Term(Long maxAccessCount) {
+        setMaxAccessCount_Term(maxAccessCount, null);
+    }
+
+    public void setMaxAccessCount_Term(Long maxAccessCount, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("maxAccessCount", maxAccessCount);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setMaxAccessCount_Terms(Collection<Long> maxAccessCountList) {
+        setMaxAccessCount_Terms(maxAccessCountList, null);
+    }
+
+    public void setMaxAccessCount_Terms(Collection<Long> maxAccessCountList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("maxAccessCount", maxAccessCountList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setMaxAccessCount_InScope(Collection<Long> maxAccessCountList) {
+        setMaxAccessCount_Terms(maxAccessCountList, null);
+    }
+
+    public void setMaxAccessCount_InScope(Collection<Long> maxAccessCountList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setMaxAccessCount_Terms(maxAccessCountList, opLambda);
+    }
+
+    public void setMaxAccessCount_Exists() {
+        setMaxAccessCount_Exists(null);
+    }
+
+    public void setMaxAccessCount_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("maxAccessCount");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setMaxAccessCount_Missing() {
+        setMaxAccessCount_Missing(null);
+    }
+
+    public void setMaxAccessCount_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("maxAccessCount");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setMaxAccessCount_GreaterThan(Long maxAccessCount) {
+        setMaxAccessCount_GreaterThan(maxAccessCount, null);
+    }
+
+    public void setMaxAccessCount_GreaterThan(Long maxAccessCount, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("maxAccessCount", ConditionKey.CK_GREATER_THAN, maxAccessCount);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setMaxAccessCount_LessThan(Long maxAccessCount) {
+        setMaxAccessCount_LessThan(maxAccessCount, null);
+    }
+
+    public void setMaxAccessCount_LessThan(Long maxAccessCount, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("maxAccessCount", ConditionKey.CK_LESS_THAN, maxAccessCount);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setMaxAccessCount_GreaterEqual(Long maxAccessCount) {
+        setMaxAccessCount_GreaterEqual(maxAccessCount, null);
+    }
+
+    public void setMaxAccessCount_GreaterEqual(Long maxAccessCount, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("maxAccessCount", ConditionKey.CK_GREATER_EQUAL, maxAccessCount);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setMaxAccessCount_LessEqual(Long maxAccessCount) {
+        setMaxAccessCount_LessEqual(maxAccessCount, null);
+    }
+
+    public void setMaxAccessCount_LessEqual(Long maxAccessCount, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("maxAccessCount", ConditionKey.CK_LESS_EQUAL, maxAccessCount);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_Term(String name) {
+        setName_Term(name, null);
+    }
+
+    public void setName_Term(String name, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("name", name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_Terms(Collection<String> nameList) {
+        setName_Terms(nameList, null);
+    }
+
+    public void setName_Terms(Collection<String> nameList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("name", nameList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_InScope(Collection<String> nameList) {
+        setName_Terms(nameList, null);
+    }
+
+    public void setName_InScope(Collection<String> nameList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setName_Terms(nameList, opLambda);
+    }
+
+    public void setName_Prefix(String name) {
+        setName_Prefix(name, null);
+    }
+
+    public void setName_Prefix(String name, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("name", name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_Exists() {
+        setName_Exists(null);
+    }
+
+    public void setName_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("name");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_Missing() {
+        setName_Missing(null);
+    }
+
+    public void setName_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("name");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_GreaterThan(String name) {
+        setName_GreaterThan(name, null);
+    }
+
+    public void setName_GreaterThan(String name, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_GREATER_THAN, name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_LessThan(String name) {
+        setName_LessThan(name, null);
+    }
+
+    public void setName_LessThan(String name, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_LESS_THAN, name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_GreaterEqual(String name) {
+        setName_GreaterEqual(name, null);
+    }
+
+    public void setName_GreaterEqual(String name, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_GREATER_EQUAL, name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_LessEqual(String name) {
+        setName_LessEqual(name, null);
+    }
+
+    public void setName_LessEqual(String name, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_LESS_EQUAL, name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setNumOfThread_Term(Integer numOfThread) {
+        setNumOfThread_Term(numOfThread, null);
+    }
+
+    public void setNumOfThread_Term(Integer numOfThread, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("numOfThread", numOfThread);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setNumOfThread_Terms(Collection<Integer> numOfThreadList) {
+        setNumOfThread_Terms(numOfThreadList, null);
+    }
+
+    public void setNumOfThread_Terms(Collection<Integer> numOfThreadList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("numOfThread", numOfThreadList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setNumOfThread_InScope(Collection<Integer> numOfThreadList) {
+        setNumOfThread_Terms(numOfThreadList, null);
+    }
+
+    public void setNumOfThread_InScope(Collection<Integer> numOfThreadList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setNumOfThread_Terms(numOfThreadList, opLambda);
+    }
+
+    public void setNumOfThread_Exists() {
+        setNumOfThread_Exists(null);
+    }
+
+    public void setNumOfThread_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("numOfThread");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setNumOfThread_Missing() {
+        setNumOfThread_Missing(null);
+    }
+
+    public void setNumOfThread_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("numOfThread");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setNumOfThread_GreaterThan(Integer numOfThread) {
+        setNumOfThread_GreaterThan(numOfThread, null);
+    }
+
+    public void setNumOfThread_GreaterThan(Integer numOfThread, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("numOfThread", ConditionKey.CK_GREATER_THAN, numOfThread);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setNumOfThread_LessThan(Integer numOfThread) {
+        setNumOfThread_LessThan(numOfThread, null);
+    }
+
+    public void setNumOfThread_LessThan(Integer numOfThread, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("numOfThread", ConditionKey.CK_LESS_THAN, numOfThread);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setNumOfThread_GreaterEqual(Integer numOfThread) {
+        setNumOfThread_GreaterEqual(numOfThread, null);
+    }
+
+    public void setNumOfThread_GreaterEqual(Integer numOfThread, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("numOfThread", ConditionKey.CK_GREATER_EQUAL, numOfThread);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setNumOfThread_LessEqual(Integer numOfThread) {
+        setNumOfThread_LessEqual(numOfThread, null);
+    }
+
+    public void setNumOfThread_LessEqual(Integer numOfThread, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("numOfThread", ConditionKey.CK_LESS_EQUAL, numOfThread);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_Term(Integer sortOrder) {
+        setSortOrder_Term(sortOrder, null);
+    }
+
+    public void setSortOrder_Term(Integer sortOrder, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("sortOrder", sortOrder);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_Terms(Collection<Integer> sortOrderList) {
+        setSortOrder_Terms(sortOrderList, null);
+    }
+
+    public void setSortOrder_Terms(Collection<Integer> sortOrderList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("sortOrder", sortOrderList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_InScope(Collection<Integer> sortOrderList) {
+        setSortOrder_Terms(sortOrderList, null);
+    }
+
+    public void setSortOrder_InScope(Collection<Integer> sortOrderList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setSortOrder_Terms(sortOrderList, opLambda);
+    }
+
+    public void setSortOrder_Exists() {
+        setSortOrder_Exists(null);
+    }
+
+    public void setSortOrder_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("sortOrder");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_Missing() {
+        setSortOrder_Missing(null);
+    }
+
+    public void setSortOrder_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("sortOrder");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_GreaterThan(Integer sortOrder) {
+        setSortOrder_GreaterThan(sortOrder, null);
+    }
+
+    public void setSortOrder_GreaterThan(Integer sortOrder, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_GREATER_THAN, sortOrder);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_LessThan(Integer sortOrder) {
+        setSortOrder_LessThan(sortOrder, null);
+    }
+
+    public void setSortOrder_LessThan(Integer sortOrder, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_LESS_THAN, sortOrder);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_GreaterEqual(Integer sortOrder) {
+        setSortOrder_GreaterEqual(sortOrder, null);
+    }
+
+    public void setSortOrder_GreaterEqual(Integer sortOrder, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_GREATER_EQUAL, sortOrder);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_LessEqual(Integer sortOrder) {
+        setSortOrder_LessEqual(sortOrder, null);
+    }
+
+    public void setSortOrder_LessEqual(Integer sortOrder, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_LESS_EQUAL, sortOrder);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Term(String updatedBy) {
+        setUpdatedBy_Term(updatedBy, null);
+    }
+
+    public void setUpdatedBy_Term(String updatedBy, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Terms(Collection<String> updatedByList) {
+        setUpdatedBy_Terms(updatedByList, null);
+    }
+
+    public void setUpdatedBy_Terms(Collection<String> updatedByList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("updatedBy", updatedByList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_InScope(Collection<String> updatedByList) {
+        setUpdatedBy_Terms(updatedByList, null);
+    }
+
+    public void setUpdatedBy_InScope(Collection<String> updatedByList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setUpdatedBy_Terms(updatedByList, opLambda);
+    }
+
+    public void setUpdatedBy_Prefix(String updatedBy) {
+        setUpdatedBy_Prefix(updatedBy, null);
+    }
+
+    public void setUpdatedBy_Prefix(String updatedBy, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Exists() {
+        setUpdatedBy_Exists(null);
+    }
+
+    public void setUpdatedBy_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("updatedBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Missing() {
+        setUpdatedBy_Missing(null);
+    }
+
+    public void setUpdatedBy_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("updatedBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_GreaterThan(String updatedBy) {
+        setUpdatedBy_GreaterThan(updatedBy, null);
+    }
+
+    public void setUpdatedBy_GreaterThan(String updatedBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_LessThan(String updatedBy) {
+        setUpdatedBy_LessThan(updatedBy, null);
+    }
+
+    public void setUpdatedBy_LessThan(String updatedBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_GreaterEqual(String updatedBy) {
+        setUpdatedBy_GreaterEqual(updatedBy, null);
+    }
+
+    public void setUpdatedBy_GreaterEqual(String updatedBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_LessEqual(String updatedBy) {
+        setUpdatedBy_LessEqual(updatedBy, null);
+    }
+
+    public void setUpdatedBy_LessEqual(String updatedBy, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_Term(Long updatedTime) {
+        setUpdatedTime_Term(updatedTime, null);
+    }
+
+    public void setUpdatedTime_Term(Long updatedTime, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("updatedTime", updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_Terms(Collection<Long> updatedTimeList) {
+        setUpdatedTime_Terms(updatedTimeList, null);
+    }
+
+    public void setUpdatedTime_Terms(Collection<Long> updatedTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("updatedTime", updatedTimeList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_InScope(Collection<Long> updatedTimeList) {
+        setUpdatedTime_Terms(updatedTimeList, null);
+    }
+
+    public void setUpdatedTime_InScope(Collection<Long> updatedTimeList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setUpdatedTime_Terms(updatedTimeList, opLambda);
+    }
+
+    public void setUpdatedTime_Exists() {
+        setUpdatedTime_Exists(null);
+    }
+
+    public void setUpdatedTime_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("updatedTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_Missing() {
+        setUpdatedTime_Missing(null);
+    }
+
+    public void setUpdatedTime_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("updatedTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_GreaterThan(Long updatedTime) {
+        setUpdatedTime_GreaterThan(updatedTime, null);
+    }
+
+    public void setUpdatedTime_GreaterThan(Long updatedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_LessThan(Long updatedTime) {
+        setUpdatedTime_LessThan(updatedTime, null);
+    }
+
+    public void setUpdatedTime_LessThan(Long updatedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_GreaterEqual(Long updatedTime) {
+        setUpdatedTime_GreaterEqual(updatedTime, null);
+    }
+
+    public void setUpdatedTime_GreaterEqual(Long updatedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_LessEqual(Long updatedTime) {
+        setUpdatedTime_LessEqual(updatedTime, null);
+    }
+
+    public void setUpdatedTime_LessEqual(Long updatedTime, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUrls_Term(String urls) {
+        setUrls_Term(urls, null);
+    }
+
+    public void setUrls_Term(String urls, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("urls", urls);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUrls_Terms(Collection<String> urlsList) {
+        setUrls_Terms(urlsList, null);
+    }
+
+    public void setUrls_Terms(Collection<String> urlsList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("urls", urlsList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUrls_InScope(Collection<String> urlsList) {
+        setUrls_Terms(urlsList, null);
+    }
+
+    public void setUrls_InScope(Collection<String> urlsList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setUrls_Terms(urlsList, opLambda);
+    }
+
+    public void setUrls_Prefix(String urls) {
+        setUrls_Prefix(urls, null);
+    }
+
+    public void setUrls_Prefix(String urls, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("urls", urls);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUrls_Exists() {
+        setUrls_Exists(null);
+    }
+
+    public void setUrls_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("urls");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUrls_Missing() {
+        setUrls_Missing(null);
+    }
+
+    public void setUrls_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("urls");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUrls_GreaterThan(String urls) {
+        setUrls_GreaterThan(urls, null);
+    }
+
+    public void setUrls_GreaterThan(String urls, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("urls", ConditionKey.CK_GREATER_THAN, urls);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUrls_LessThan(String urls) {
+        setUrls_LessThan(urls, null);
+    }
+
+    public void setUrls_LessThan(String urls, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("urls", ConditionKey.CK_LESS_THAN, urls);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUrls_GreaterEqual(String urls) {
+        setUrls_GreaterEqual(urls, null);
+    }
+
+    public void setUrls_GreaterEqual(String urls, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("urls", ConditionKey.CK_GREATER_EQUAL, urls);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUrls_LessEqual(String urls) {
+        setUrls_LessEqual(urls, null);
+    }
+
+    public void setUrls_LessEqual(String urls, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("urls", ConditionKey.CK_LESS_EQUAL, urls);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUserAgent_Term(String userAgent) {
+        setUserAgent_Term(userAgent, null);
+    }
+
+    public void setUserAgent_Term(String userAgent, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("userAgent", userAgent);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUserAgent_Terms(Collection<String> userAgentList) {
+        setUserAgent_Terms(userAgentList, null);
+    }
+
+    public void setUserAgent_Terms(Collection<String> userAgentList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("userAgent", userAgentList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUserAgent_InScope(Collection<String> userAgentList) {
+        setUserAgent_Terms(userAgentList, null);
+    }
+
+    public void setUserAgent_InScope(Collection<String> userAgentList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setUserAgent_Terms(userAgentList, opLambda);
+    }
+
+    public void setUserAgent_Prefix(String userAgent) {
+        setUserAgent_Prefix(userAgent, null);
+    }
+
+    public void setUserAgent_Prefix(String userAgent, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("userAgent", userAgent);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUserAgent_Exists() {
+        setUserAgent_Exists(null);
+    }
+
+    public void setUserAgent_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("userAgent");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUserAgent_Missing() {
+        setUserAgent_Missing(null);
+    }
+
+    public void setUserAgent_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("userAgent");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUserAgent_GreaterThan(String userAgent) {
+        setUserAgent_GreaterThan(userAgent, null);
+    }
+
+    public void setUserAgent_GreaterThan(String userAgent, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("userAgent", ConditionKey.CK_GREATER_THAN, userAgent);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUserAgent_LessThan(String userAgent) {
+        setUserAgent_LessThan(userAgent, null);
+    }
+
+    public void setUserAgent_LessThan(String userAgent, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("userAgent", ConditionKey.CK_LESS_THAN, userAgent);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUserAgent_GreaterEqual(String userAgent) {
+        setUserAgent_GreaterEqual(userAgent, null);
+    }
+
+    public void setUserAgent_GreaterEqual(String userAgent, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("userAgent", ConditionKey.CK_GREATER_EQUAL, userAgent);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUserAgent_LessEqual(String userAgent) {
+        setUserAgent_LessEqual(userAgent, null);
+    }
+
+    public void setUserAgent_LessEqual(String userAgent, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("userAgent", ConditionKey.CK_LESS_EQUAL, userAgent);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+}

src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsWebConfigToLabelCF.java

@@ -0,0 +1,430 @@
+package org.codelibs.fess.es.cbean.cf.bs;
+
+import java.util.Collection;
+
+import org.codelibs.fess.es.cbean.cf.WebConfigToLabelCF;
+import org.codelibs.fess.es.cbean.cq.WebConfigToLabelCQ;
+import org.dbflute.exception.IllegalConditionBeanOperationException;
+import org.dbflute.cbean.ckey.ConditionKey;
+import org.elasticsearch.index.query.AndFilterBuilder;
+import org.elasticsearch.index.query.BoolFilterBuilder;
+import org.elasticsearch.index.query.ExistsFilterBuilder;
+import org.elasticsearch.index.query.MissingFilterBuilder;
+import org.elasticsearch.index.query.NotFilterBuilder;
+import org.elasticsearch.index.query.OrFilterBuilder;
+import org.elasticsearch.index.query.PrefixFilterBuilder;
+import org.elasticsearch.index.query.QueryFilterBuilder;
+import org.elasticsearch.index.query.RangeFilterBuilder;
+import org.elasticsearch.index.query.TermFilterBuilder;
+import org.elasticsearch.index.query.TermsFilterBuilder;
+
+/**
+ * @author FreeGen
+ */
+public abstract class BsWebConfigToLabelCF extends AbstractConditionFilter {
+
+    public void bool(BoolCall<WebConfigToLabelCF> boolLambda) {
+        bool(boolLambda, null);
+    }
+
+    public void bool(BoolCall<WebConfigToLabelCF> boolLambda, ConditionOptionCall<BoolFilterBuilder> opLambda) {
+        WebConfigToLabelCF mustFilter = new WebConfigToLabelCF();
+        WebConfigToLabelCF shouldFilter = new WebConfigToLabelCF();
+        WebConfigToLabelCF mustNotFilter = new WebConfigToLabelCF();
+        boolLambda.callback(mustFilter, shouldFilter, mustNotFilter);
+        if (mustFilter.hasFilters() || shouldFilter.hasFilters() || mustNotFilter.hasFilters()) {
+            BoolFilterBuilder builder =
+                    regBoolF(mustFilter.filterBuilderList, shouldFilter.filterBuilderList, mustNotFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void and(OperatorCall<WebConfigToLabelCF> andLambda) {
+        and(andLambda, null);
+    }
+
+    public void and(OperatorCall<WebConfigToLabelCF> andLambda, ConditionOptionCall<AndFilterBuilder> opLambda) {
+        WebConfigToLabelCF andFilter = new WebConfigToLabelCF();
+        andLambda.callback(andFilter);
+        if (andFilter.hasFilters()) {
+            AndFilterBuilder builder = regAndF(andFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void or(OperatorCall<WebConfigToLabelCF> orLambda) {
+        or(orLambda, null);
+    }
+
+    public void or(OperatorCall<WebConfigToLabelCF> orLambda, ConditionOptionCall<OrFilterBuilder> opLambda) {
+        WebConfigToLabelCF orFilter = new WebConfigToLabelCF();
+        orLambda.callback(orFilter);
+        if (orFilter.hasFilters()) {
+            OrFilterBuilder builder = regOrF(orFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void not(OperatorCall<WebConfigToLabelCF> notLambda) {
+        not(notLambda, null);
+    }
+
+    public void not(OperatorCall<WebConfigToLabelCF> notLambda, ConditionOptionCall<NotFilterBuilder> opLambda) {
+        WebConfigToLabelCF notFilter = new WebConfigToLabelCF();
+        notLambda.callback(notFilter);
+        if (notFilter.hasFilters()) {
+            if (notFilter.filterBuilderList.size() > 1) {
+                final String msg = "not filter must be one filter.";
+                throw new IllegalConditionBeanOperationException(msg);
+            }
+            NotFilterBuilder builder = regNotF(notFilter.filterBuilderList.get(0));
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall<WebConfigToLabelCQ> queryLambda) {
+        query(queryLambda, null);
+    }
+
+    public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall<WebConfigToLabelCQ> queryLambda,
+            ConditionOptionCall<QueryFilterBuilder> opLambda) {
+        WebConfigToLabelCQ query = new WebConfigToLabelCQ();
+        queryLambda.callback(query);
+        if (query.hasQueries()) {
+            QueryFilterBuilder builder = regQueryF(query.getQuery());
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void setId_Term(String id) {
+        setId_Term(id, null);
+    }
+
+    public void setId_Term(String id, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("id", id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Terms(Collection<String> idList) {
+        setId_Terms(idList, null);
+    }
+
+    public void setId_Terms(Collection<String> idList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("id", idList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_InScope(Collection<String> idList) {
+        setId_Terms(idList, null);
+    }
+
+    public void setId_InScope(Collection<String> idList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setId_Terms(idList, opLambda);
+    }
+
+    public void setId_Prefix(String id) {
+        setId_Prefix(id, null);
+    }
+
+    public void setId_Prefix(String id, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("id", id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Exists() {
+        setId_Exists(null);
+    }
+
+    public void setId_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("id");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Missing() {
+        setId_Missing(null);
+    }
+
+    public void setId_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("id");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_GreaterThan(String id) {
+        setId_GreaterThan(id, null);
+    }
+
+    public void setId_GreaterThan(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_THAN, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_LessThan(String id) {
+        setId_LessThan(id, null);
+    }
+
+    public void setId_LessThan(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_THAN, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_GreaterEqual(String id) {
+        setId_GreaterEqual(id, null);
+    }
+
+    public void setId_GreaterEqual(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_EQUAL, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_LessEqual(String id) {
+        setId_LessEqual(id, null);
+    }
+
+    public void setId_LessEqual(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_EQUAL, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setLabelTypeId_Term(String labelTypeId) {
+        setLabelTypeId_Term(labelTypeId, null);
+    }
+
+    public void setLabelTypeId_Term(String labelTypeId, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("labelTypeId", labelTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setLabelTypeId_Terms(Collection<String> labelTypeIdList) {
+        setLabelTypeId_Terms(labelTypeIdList, null);
+    }
+
+    public void setLabelTypeId_Terms(Collection<String> labelTypeIdList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("labelTypeId", labelTypeIdList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setLabelTypeId_InScope(Collection<String> labelTypeIdList) {
+        setLabelTypeId_Terms(labelTypeIdList, null);
+    }
+
+    public void setLabelTypeId_InScope(Collection<String> labelTypeIdList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setLabelTypeId_Terms(labelTypeIdList, opLambda);
+    }
+
+    public void setLabelTypeId_Prefix(String labelTypeId) {
+        setLabelTypeId_Prefix(labelTypeId, null);
+    }
+
+    public void setLabelTypeId_Prefix(String labelTypeId, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("labelTypeId", labelTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setLabelTypeId_Exists() {
+        setLabelTypeId_Exists(null);
+    }
+
+    public void setLabelTypeId_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("labelTypeId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setLabelTypeId_Missing() {
+        setLabelTypeId_Missing(null);
+    }
+
+    public void setLabelTypeId_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("labelTypeId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setLabelTypeId_GreaterThan(String labelTypeId) {
+        setLabelTypeId_GreaterThan(labelTypeId, null);
+    }
+
+    public void setLabelTypeId_GreaterThan(String labelTypeId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("labelTypeId", ConditionKey.CK_GREATER_THAN, labelTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setLabelTypeId_LessThan(String labelTypeId) {
+        setLabelTypeId_LessThan(labelTypeId, null);
+    }
+
+    public void setLabelTypeId_LessThan(String labelTypeId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("labelTypeId", ConditionKey.CK_LESS_THAN, labelTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setLabelTypeId_GreaterEqual(String labelTypeId) {
+        setLabelTypeId_GreaterEqual(labelTypeId, null);
+    }
+
+    public void setLabelTypeId_GreaterEqual(String labelTypeId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("labelTypeId", ConditionKey.CK_GREATER_EQUAL, labelTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setLabelTypeId_LessEqual(String labelTypeId) {
+        setLabelTypeId_LessEqual(labelTypeId, null);
+    }
+
+    public void setLabelTypeId_LessEqual(String labelTypeId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("labelTypeId", ConditionKey.CK_LESS_EQUAL, labelTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setWebConfigId_Term(String webConfigId) {
+        setWebConfigId_Term(webConfigId, null);
+    }
+
+    public void setWebConfigId_Term(String webConfigId, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("webConfigId", webConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setWebConfigId_Terms(Collection<String> webConfigIdList) {
+        setWebConfigId_Terms(webConfigIdList, null);
+    }
+
+    public void setWebConfigId_Terms(Collection<String> webConfigIdList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("webConfigId", webConfigIdList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setWebConfigId_InScope(Collection<String> webConfigIdList) {
+        setWebConfigId_Terms(webConfigIdList, null);
+    }
+
+    public void setWebConfigId_InScope(Collection<String> webConfigIdList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setWebConfigId_Terms(webConfigIdList, opLambda);
+    }
+
+    public void setWebConfigId_Prefix(String webConfigId) {
+        setWebConfigId_Prefix(webConfigId, null);
+    }
+
+    public void setWebConfigId_Prefix(String webConfigId, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("webConfigId", webConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setWebConfigId_Exists() {
+        setWebConfigId_Exists(null);
+    }
+
+    public void setWebConfigId_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("webConfigId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setWebConfigId_Missing() {
+        setWebConfigId_Missing(null);
+    }
+
+    public void setWebConfigId_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("webConfigId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setWebConfigId_GreaterThan(String webConfigId) {
+        setWebConfigId_GreaterThan(webConfigId, null);
+    }
+
+    public void setWebConfigId_GreaterThan(String webConfigId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("webConfigId", ConditionKey.CK_GREATER_THAN, webConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setWebConfigId_LessThan(String webConfigId) {
+        setWebConfigId_LessThan(webConfigId, null);
+    }
+
+    public void setWebConfigId_LessThan(String webConfigId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("webConfigId", ConditionKey.CK_LESS_THAN, webConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setWebConfigId_GreaterEqual(String webConfigId) {
+        setWebConfigId_GreaterEqual(webConfigId, null);
+    }
+
+    public void setWebConfigId_GreaterEqual(String webConfigId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("webConfigId", ConditionKey.CK_GREATER_EQUAL, webConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setWebConfigId_LessEqual(String webConfigId) {
+        setWebConfigId_LessEqual(webConfigId, null);
+    }
+
+    public void setWebConfigId_LessEqual(String webConfigId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("webConfigId", ConditionKey.CK_LESS_EQUAL, webConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+}

src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsWebConfigToRoleCF.java

@@ -0,0 +1,430 @@
+package org.codelibs.fess.es.cbean.cf.bs;
+
+import java.util.Collection;
+
+import org.codelibs.fess.es.cbean.cf.WebConfigToRoleCF;
+import org.codelibs.fess.es.cbean.cq.WebConfigToRoleCQ;
+import org.dbflute.exception.IllegalConditionBeanOperationException;
+import org.dbflute.cbean.ckey.ConditionKey;
+import org.elasticsearch.index.query.AndFilterBuilder;
+import org.elasticsearch.index.query.BoolFilterBuilder;
+import org.elasticsearch.index.query.ExistsFilterBuilder;
+import org.elasticsearch.index.query.MissingFilterBuilder;
+import org.elasticsearch.index.query.NotFilterBuilder;
+import org.elasticsearch.index.query.OrFilterBuilder;
+import org.elasticsearch.index.query.PrefixFilterBuilder;
+import org.elasticsearch.index.query.QueryFilterBuilder;
+import org.elasticsearch.index.query.RangeFilterBuilder;
+import org.elasticsearch.index.query.TermFilterBuilder;
+import org.elasticsearch.index.query.TermsFilterBuilder;
+
+/**
+ * @author FreeGen
+ */
+public abstract class BsWebConfigToRoleCF extends AbstractConditionFilter {
+
+    public void bool(BoolCall<WebConfigToRoleCF> boolLambda) {
+        bool(boolLambda, null);
+    }
+
+    public void bool(BoolCall<WebConfigToRoleCF> boolLambda, ConditionOptionCall<BoolFilterBuilder> opLambda) {
+        WebConfigToRoleCF mustFilter = new WebConfigToRoleCF();
+        WebConfigToRoleCF shouldFilter = new WebConfigToRoleCF();
+        WebConfigToRoleCF mustNotFilter = new WebConfigToRoleCF();
+        boolLambda.callback(mustFilter, shouldFilter, mustNotFilter);
+        if (mustFilter.hasFilters() || shouldFilter.hasFilters() || mustNotFilter.hasFilters()) {
+            BoolFilterBuilder builder =
+                    regBoolF(mustFilter.filterBuilderList, shouldFilter.filterBuilderList, mustNotFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void and(OperatorCall<WebConfigToRoleCF> andLambda) {
+        and(andLambda, null);
+    }
+
+    public void and(OperatorCall<WebConfigToRoleCF> andLambda, ConditionOptionCall<AndFilterBuilder> opLambda) {
+        WebConfigToRoleCF andFilter = new WebConfigToRoleCF();
+        andLambda.callback(andFilter);
+        if (andFilter.hasFilters()) {
+            AndFilterBuilder builder = regAndF(andFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void or(OperatorCall<WebConfigToRoleCF> orLambda) {
+        or(orLambda, null);
+    }
+
+    public void or(OperatorCall<WebConfigToRoleCF> orLambda, ConditionOptionCall<OrFilterBuilder> opLambda) {
+        WebConfigToRoleCF orFilter = new WebConfigToRoleCF();
+        orLambda.callback(orFilter);
+        if (orFilter.hasFilters()) {
+            OrFilterBuilder builder = regOrF(orFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void not(OperatorCall<WebConfigToRoleCF> notLambda) {
+        not(notLambda, null);
+    }
+
+    public void not(OperatorCall<WebConfigToRoleCF> notLambda, ConditionOptionCall<NotFilterBuilder> opLambda) {
+        WebConfigToRoleCF notFilter = new WebConfigToRoleCF();
+        notLambda.callback(notFilter);
+        if (notFilter.hasFilters()) {
+            if (notFilter.filterBuilderList.size() > 1) {
+                final String msg = "not filter must be one filter.";
+                throw new IllegalConditionBeanOperationException(msg);
+            }
+            NotFilterBuilder builder = regNotF(notFilter.filterBuilderList.get(0));
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall<WebConfigToRoleCQ> queryLambda) {
+        query(queryLambda, null);
+    }
+
+    public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall<WebConfigToRoleCQ> queryLambda,
+            ConditionOptionCall<QueryFilterBuilder> opLambda) {
+        WebConfigToRoleCQ query = new WebConfigToRoleCQ();
+        queryLambda.callback(query);
+        if (query.hasQueries()) {
+            QueryFilterBuilder builder = regQueryF(query.getQuery());
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void setId_Term(String id) {
+        setId_Term(id, null);
+    }
+
+    public void setId_Term(String id, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("id", id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Terms(Collection<String> idList) {
+        setId_Terms(idList, null);
+    }
+
+    public void setId_Terms(Collection<String> idList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("id", idList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_InScope(Collection<String> idList) {
+        setId_Terms(idList, null);
+    }
+
+    public void setId_InScope(Collection<String> idList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setId_Terms(idList, opLambda);
+    }
+
+    public void setId_Prefix(String id) {
+        setId_Prefix(id, null);
+    }
+
+    public void setId_Prefix(String id, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("id", id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Exists() {
+        setId_Exists(null);
+    }
+
+    public void setId_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("id");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_Missing() {
+        setId_Missing(null);
+    }
+
+    public void setId_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("id");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_GreaterThan(String id) {
+        setId_GreaterThan(id, null);
+    }
+
+    public void setId_GreaterThan(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_THAN, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_LessThan(String id) {
+        setId_LessThan(id, null);
+    }
+
+    public void setId_LessThan(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_THAN, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_GreaterEqual(String id) {
+        setId_GreaterEqual(id, null);
+    }
+
+    public void setId_GreaterEqual(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_EQUAL, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setId_LessEqual(String id) {
+        setId_LessEqual(id, null);
+    }
+
+    public void setId_LessEqual(String id, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_EQUAL, id);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRoleTypeId_Term(String roleTypeId) {
+        setRoleTypeId_Term(roleTypeId, null);
+    }
+
+    public void setRoleTypeId_Term(String roleTypeId, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("roleTypeId", roleTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRoleTypeId_Terms(Collection<String> roleTypeIdList) {
+        setRoleTypeId_Terms(roleTypeIdList, null);
+    }
+
+    public void setRoleTypeId_Terms(Collection<String> roleTypeIdList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("roleTypeId", roleTypeIdList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRoleTypeId_InScope(Collection<String> roleTypeIdList) {
+        setRoleTypeId_Terms(roleTypeIdList, null);
+    }
+
+    public void setRoleTypeId_InScope(Collection<String> roleTypeIdList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setRoleTypeId_Terms(roleTypeIdList, opLambda);
+    }
+
+    public void setRoleTypeId_Prefix(String roleTypeId) {
+        setRoleTypeId_Prefix(roleTypeId, null);
+    }
+
+    public void setRoleTypeId_Prefix(String roleTypeId, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("roleTypeId", roleTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRoleTypeId_Exists() {
+        setRoleTypeId_Exists(null);
+    }
+
+    public void setRoleTypeId_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("roleTypeId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRoleTypeId_Missing() {
+        setRoleTypeId_Missing(null);
+    }
+
+    public void setRoleTypeId_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("roleTypeId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRoleTypeId_GreaterThan(String roleTypeId) {
+        setRoleTypeId_GreaterThan(roleTypeId, null);
+    }
+
+    public void setRoleTypeId_GreaterThan(String roleTypeId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("roleTypeId", ConditionKey.CK_GREATER_THAN, roleTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRoleTypeId_LessThan(String roleTypeId) {
+        setRoleTypeId_LessThan(roleTypeId, null);
+    }
+
+    public void setRoleTypeId_LessThan(String roleTypeId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("roleTypeId", ConditionKey.CK_LESS_THAN, roleTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRoleTypeId_GreaterEqual(String roleTypeId) {
+        setRoleTypeId_GreaterEqual(roleTypeId, null);
+    }
+
+    public void setRoleTypeId_GreaterEqual(String roleTypeId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("roleTypeId", ConditionKey.CK_GREATER_EQUAL, roleTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRoleTypeId_LessEqual(String roleTypeId) {
+        setRoleTypeId_LessEqual(roleTypeId, null);
+    }
+
+    public void setRoleTypeId_LessEqual(String roleTypeId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("roleTypeId", ConditionKey.CK_LESS_EQUAL, roleTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setWebConfigId_Term(String webConfigId) {
+        setWebConfigId_Term(webConfigId, null);
+    }
+
+    public void setWebConfigId_Term(String webConfigId, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("webConfigId", webConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setWebConfigId_Terms(Collection<String> webConfigIdList) {
+        setWebConfigId_Terms(webConfigIdList, null);
+    }
+
+    public void setWebConfigId_Terms(Collection<String> webConfigIdList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("webConfigId", webConfigIdList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setWebConfigId_InScope(Collection<String> webConfigIdList) {
+        setWebConfigId_Terms(webConfigIdList, null);
+    }
+
+    public void setWebConfigId_InScope(Collection<String> webConfigIdList, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        setWebConfigId_Terms(webConfigIdList, opLambda);
+    }
+
+    public void setWebConfigId_Prefix(String webConfigId) {
+        setWebConfigId_Prefix(webConfigId, null);
+    }
+
+    public void setWebConfigId_Prefix(String webConfigId, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("webConfigId", webConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setWebConfigId_Exists() {
+        setWebConfigId_Exists(null);
+    }
+
+    public void setWebConfigId_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("webConfigId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setWebConfigId_Missing() {
+        setWebConfigId_Missing(null);
+    }
+
+    public void setWebConfigId_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("webConfigId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setWebConfigId_GreaterThan(String webConfigId) {
+        setWebConfigId_GreaterThan(webConfigId, null);
+    }
+
+    public void setWebConfigId_GreaterThan(String webConfigId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("webConfigId", ConditionKey.CK_GREATER_THAN, webConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setWebConfigId_LessThan(String webConfigId) {
+        setWebConfigId_LessThan(webConfigId, null);
+    }
+
+    public void setWebConfigId_LessThan(String webConfigId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("webConfigId", ConditionKey.CK_LESS_THAN, webConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setWebConfigId_GreaterEqual(String webConfigId) {
+        setWebConfigId_GreaterEqual(webConfigId, null);
+    }
+
+    public void setWebConfigId_GreaterEqual(String webConfigId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("webConfigId", ConditionKey.CK_GREATER_EQUAL, webConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setWebConfigId_LessEqual(String webConfigId) {
+        setWebConfigId_LessEqual(webConfigId, null);
+    }
+
+    public void setWebConfigId_LessEqual(String webConfigId, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("webConfigId", ConditionKey.CK_LESS_EQUAL, webConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+}

src/main/java/org/codelibs/fess/es/cbean/cq/bs/AbstractConditionQuery.java

@@ -5,6 +5,7 @@ import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
 
+import org.codelibs.fess.es.cbean.cf.bs.AbstractConditionFilter;
 import org.dbflute.cbean.ConditionBean;
 import org.dbflute.cbean.ConditionQuery;
 import org.dbflute.cbean.ckey.ConditionKey;
@@ -20,6 +21,7 @@ import org.elasticsearch.index.query.BoolQueryBuilder;
 import org.elasticsearch.index.query.FilterBuilder;
 import org.elasticsearch.index.query.FilteredQueryBuilder;
 import org.elasticsearch.index.query.FuzzyQueryBuilder;
+import org.elasticsearch.index.query.MatchAllQueryBuilder;
 import org.elasticsearch.index.query.MatchQueryBuilder;
 import org.elasticsearch.index.query.PrefixQueryBuilder;
 import org.elasticsearch.index.query.QueryBuilder;
@@ -56,6 +58,10 @@ public abstract class AbstractConditionQuery implements ConditionQuery {
         return fieldSortBuilderList == null ? Collections.emptyList() : fieldSortBuilderList;
     }
 
+    public boolean hasQueries() {
+        return queryBuilderList != null && !queryBuilderList.isEmpty();
+    }
+
     public QueryBuilder getQuery() {
         if (queryBuilderList == null) {
             return null;
@@ -70,7 +76,7 @@ public abstract class AbstractConditionQuery implements ConditionQuery {
     }
 
     public void addQuery(QueryBuilder queryBuilder) {
-        queryBuilderList.add(queryBuilder);
+        regQ(queryBuilder);
     }
 
     public void queryString(String queryString) {
@@ -85,11 +91,23 @@ public abstract class AbstractConditionQuery implements ConditionQuery {
         }
     }
 
-    protected FilteredQueryBuilder reqFilteredQ(QueryBuilder queryBuilder, FilterBuilder filterBuilder) {
+    public void matchAll() {
+        matchAll(null);
+    }
+
+    public void matchAll(ConditionOptionCall<MatchAllQueryBuilder> opLambda) {
+        MatchAllQueryBuilder builder = QueryBuilders.matchAllQuery();
+        regQ(builder);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    protected FilteredQueryBuilder regFilteredQ(QueryBuilder queryBuilder, FilterBuilder filterBuilder) {
         return QueryBuilders.filteredQuery(queryBuilder, filterBuilder);
     }
 
-    protected BoolQueryBuilder reqBoolCQ(List<QueryBuilder> mustList, List<QueryBuilder> shouldList, List<QueryBuilder> mustNotList) {
+    protected BoolQueryBuilder regBoolCQ(List<QueryBuilder> mustList, List<QueryBuilder> shouldList, List<QueryBuilder> mustNotList) {
         BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
         mustList.forEach(query -> {
             boolQuery.must(query);
@@ -103,49 +121,49 @@ public abstract class AbstractConditionQuery implements ConditionQuery {
         return boolQuery;
     }
 
-    protected TermQueryBuilder reqTermQ(String name, Object value) {
+    protected TermQueryBuilder regTermQ(String name, Object value) {
         TermQueryBuilder termQuery = QueryBuilders.termQuery(name, value);
         regQ(termQuery);
         return termQuery;
     }
 
-    protected TermsQueryBuilder reqTermsQ(String name, Collection<?> value) {
+    protected TermsQueryBuilder regTermsQ(String name, Collection<?> value) {
         TermsQueryBuilder termsQuery = QueryBuilders.termsQuery(name, value);
         regQ(termsQuery);
         return termsQuery;
     }
 
-    protected MatchQueryBuilder reqMatchQ(String name, Object value) {
+    protected MatchQueryBuilder regMatchQ(String name, Object value) {
         MatchQueryBuilder matchQuery = QueryBuilders.matchQuery(name, value);
         regQ(matchQuery);
         return matchQuery;
     }
 
-    protected MatchQueryBuilder reqMatchPhraseQ(String name, Object value) {
+    protected MatchQueryBuilder regMatchPhraseQ(String name, Object value) {
         MatchQueryBuilder matchQuery = QueryBuilders.matchPhraseQuery(name, value);
         regQ(matchQuery);
         return matchQuery;
     }
 
-    protected MatchQueryBuilder reqMatchPhrasePrefixQ(String name, Object value) {
+    protected MatchQueryBuilder regMatchPhrasePrefixQ(String name, Object value) {
         MatchQueryBuilder matchQuery = QueryBuilders.matchPhrasePrefixQuery(name, value);
         regQ(matchQuery);
         return matchQuery;
     }
 
-    protected FuzzyQueryBuilder reqFuzzyQ(String name, Object value) {
+    protected FuzzyQueryBuilder regFuzzyQ(String name, Object value) {
         FuzzyQueryBuilder fuzzyQuery = QueryBuilders.fuzzyQuery(name, value);
         regQ(fuzzyQuery);
         return fuzzyQuery;
     }
 
-    protected PrefixQueryBuilder reqPrefixQ(String name, String prefix) {
+    protected PrefixQueryBuilder regPrefixQ(String name, String prefix) {
         PrefixQueryBuilder prefixQuery = QueryBuilders.prefixQuery(name, prefix);
         regQ(prefixQuery);
         return prefixQuery;
     }
 
-    protected RangeQueryBuilder reqRangeQ(String name, ConditionKey ck, Object value) {
+    protected RangeQueryBuilder regRangeQ(String name, ConditionKey ck, Object value) {
         for (QueryBuilder builder : queryBuilderList) {
             if (builder instanceof RangeQueryBuilder) {
                 RangeQueryBuilder rangeQueryBuilder = (RangeQueryBuilder) builder;
@@ -353,8 +371,14 @@ public abstract class AbstractConditionQuery implements ConditionQuery {
     }
 
     @FunctionalInterface
-    public interface FilteredCall<CQ extends AbstractConditionQuery> {
+    public interface FilteredCall<CQ extends AbstractConditionQuery, CF extends AbstractConditionFilter> {
+
+        void callback(CQ query, CF filter);
+    }
+
+    @FunctionalInterface
+    public interface OperatorCall<CQ extends AbstractConditionQuery> {
 
-        void callback(CQ query);
+        void callback(CQ and);
     }
 }

src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsBoostDocumentRuleCQ.java

@@ -3,6 +3,7 @@ package org.codelibs.fess.es.cbean.cq.bs;
 import java.util.Collection;
 
 import org.codelibs.fess.es.cbean.cq.BoostDocumentRuleCQ;
+import org.codelibs.fess.es.cbean.cf.BoostDocumentRuleCF;
 import org.dbflute.cbean.ckey.ConditionKey;
 import org.elasticsearch.index.query.BoolQueryBuilder;
 import org.elasticsearch.index.query.FilteredQueryBuilder;
@@ -28,16 +29,17 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
         return "boost_document_rule";
     }
 
-    public void filtered(FilteredCall<BoostDocumentRuleCQ> filteredLambda) {
+    public void filtered(FilteredCall<BoostDocumentRuleCQ, BoostDocumentRuleCF> filteredLambda) {
         filtered(filteredLambda, null);
     }
 
-    public void filtered(FilteredCall<BoostDocumentRuleCQ> filteredLambda, ConditionOptionCall<FilteredQueryBuilder> opLambda) {
+    public void filtered(FilteredCall<BoostDocumentRuleCQ, BoostDocumentRuleCF> filteredLambda,
+            ConditionOptionCall<FilteredQueryBuilder> opLambda) {
         BoostDocumentRuleCQ query = new BoostDocumentRuleCQ();
-        filteredLambda.callback(query);
-        if (!query.queryBuilderList.isEmpty()) {
-            // TODO filter
-            FilteredQueryBuilder builder = reqFilteredQ(query.getQuery(), null);
+        BoostDocumentRuleCF filter = new BoostDocumentRuleCF();
+        filteredLambda.callback(query, filter);
+        if (query.hasQueries()) {
+            FilteredQueryBuilder builder = regFilteredQ(query.getQuery(), filter.getFilter());
             if (opLambda != null) {
                 opLambda.callback(builder);
             }
@@ -53,8 +55,8 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
         BoostDocumentRuleCQ shouldQuery = new BoostDocumentRuleCQ();
         BoostDocumentRuleCQ mustNotQuery = new BoostDocumentRuleCQ();
         boolLambda.callback(mustQuery, shouldQuery, mustNotQuery);
-        if (!mustQuery.queryBuilderList.isEmpty() || !shouldQuery.queryBuilderList.isEmpty() || !mustNotQuery.queryBuilderList.isEmpty()) {
-            BoolQueryBuilder builder = reqBoolCQ(mustQuery.queryBuilderList, shouldQuery.queryBuilderList, mustNotQuery.queryBuilderList);
+        if (mustQuery.hasQueries() || shouldQuery.hasQueries() || mustNotQuery.hasQueries()) {
+            BoolQueryBuilder builder = regBoolCQ(mustQuery.queryBuilderList, shouldQuery.queryBuilderList, mustNotQuery.queryBuilderList);
             if (opLambda != null) {
                 opLambda.callback(builder);
             }
@@ -66,29 +68,29 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setBoostExpr_Term(String boostExpr, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("boostExpr", boostExpr);
+        TermQueryBuilder builder = regTermQ("boostExpr", boostExpr);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setBoostExpr_Terms(Collection<String> boostExprList) {
-        setBoostExpr_MatchPhrasePrefix(boostExprList, null);
+        setBoostExpr_Terms(boostExprList, null);
     }
 
-    public void setBoostExpr_MatchPhrasePrefix(Collection<String> boostExprList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("boostExpr", boostExprList);
+    public void setBoostExpr_Terms(Collection<String> boostExprList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("boostExpr", boostExprList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setBoostExpr_InScope(Collection<String> boostExprList) {
-        setBoostExpr_MatchPhrasePrefix(boostExprList, null);
+        setBoostExpr_Terms(boostExprList, null);
     }
 
     public void setBoostExpr_InScope(Collection<String> boostExprList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setBoostExpr_MatchPhrasePrefix(boostExprList, opLambda);
+        setBoostExpr_Terms(boostExprList, opLambda);
     }
 
     public void setBoostExpr_Match(String boostExpr) {
@@ -96,7 +98,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setBoostExpr_Match(String boostExpr, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("boostExpr", boostExpr);
+        MatchQueryBuilder builder = regMatchQ("boostExpr", boostExpr);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -107,7 +109,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setBoostExpr_MatchPhrase(String boostExpr, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("boostExpr", boostExpr);
+        MatchQueryBuilder builder = regMatchPhraseQ("boostExpr", boostExpr);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -118,7 +120,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setBoostExpr_MatchPhrasePrefix(String boostExpr, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("boostExpr", boostExpr);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("boostExpr", boostExpr);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -129,7 +131,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setBoostExpr_Fuzzy(String boostExpr, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("boostExpr", boostExpr);
+        FuzzyQueryBuilder builder = regFuzzyQ("boostExpr", boostExpr);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -140,7 +142,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setBoostExpr_Prefix(String boostExpr, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("boostExpr", boostExpr);
+        PrefixQueryBuilder builder = regPrefixQ("boostExpr", boostExpr);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -151,7 +153,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setBoostExpr_GreaterThan(String boostExpr, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("boostExpr", ConditionKey.CK_GREATER_THAN, boostExpr);
+        RangeQueryBuilder builder = regRangeQ("boostExpr", ConditionKey.CK_GREATER_THAN, boostExpr);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -162,7 +164,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setBoostExpr_LessThan(String boostExpr, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("boostExpr", ConditionKey.CK_LESS_THAN, boostExpr);
+        RangeQueryBuilder builder = regRangeQ("boostExpr", ConditionKey.CK_LESS_THAN, boostExpr);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -173,7 +175,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setBoostExpr_GreaterEqual(String boostExpr, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("boostExpr", ConditionKey.CK_GREATER_EQUAL, boostExpr);
+        RangeQueryBuilder builder = regRangeQ("boostExpr", ConditionKey.CK_GREATER_EQUAL, boostExpr);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -184,7 +186,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setBoostExpr_LessEqual(String boostExpr, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("boostExpr", ConditionKey.CK_LESS_EQUAL, boostExpr);
+        RangeQueryBuilder builder = regRangeQ("boostExpr", ConditionKey.CK_LESS_EQUAL, boostExpr);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -205,29 +207,29 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedBy_Term(String createdBy, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("createdBy", createdBy);
+        TermQueryBuilder builder = regTermQ("createdBy", createdBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setCreatedBy_Terms(Collection<String> createdByList) {
-        setCreatedBy_MatchPhrasePrefix(createdByList, null);
+        setCreatedBy_Terms(createdByList, null);
     }
 
-    public void setCreatedBy_MatchPhrasePrefix(Collection<String> createdByList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("createdBy", createdByList);
+    public void setCreatedBy_Terms(Collection<String> createdByList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("createdBy", createdByList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setCreatedBy_InScope(Collection<String> createdByList) {
-        setCreatedBy_MatchPhrasePrefix(createdByList, null);
+        setCreatedBy_Terms(createdByList, null);
     }
 
     public void setCreatedBy_InScope(Collection<String> createdByList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setCreatedBy_MatchPhrasePrefix(createdByList, opLambda);
+        setCreatedBy_Terms(createdByList, opLambda);
     }
 
     public void setCreatedBy_Match(String createdBy) {
@@ -235,7 +237,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedBy_Match(String createdBy, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("createdBy", createdBy);
+        MatchQueryBuilder builder = regMatchQ("createdBy", createdBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -246,7 +248,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedBy_MatchPhrase(String createdBy, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("createdBy", createdBy);
+        MatchQueryBuilder builder = regMatchPhraseQ("createdBy", createdBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -257,7 +259,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedBy_MatchPhrasePrefix(String createdBy, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("createdBy", createdBy);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("createdBy", createdBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -268,7 +270,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedBy_Fuzzy(String createdBy, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("createdBy", createdBy);
+        FuzzyQueryBuilder builder = regFuzzyQ("createdBy", createdBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -279,7 +281,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedBy_Prefix(String createdBy, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("createdBy", createdBy);
+        PrefixQueryBuilder builder = regPrefixQ("createdBy", createdBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -290,7 +292,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedBy_GreaterThan(String createdBy, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_GREATER_THAN, createdBy);
+        RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_GREATER_THAN, createdBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -301,7 +303,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedBy_LessThan(String createdBy, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_LESS_THAN, createdBy);
+        RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_LESS_THAN, createdBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -312,7 +314,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedBy_GreaterEqual(String createdBy, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy);
+        RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -323,7 +325,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedBy_LessEqual(String createdBy, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy);
+        RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -344,29 +346,29 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_Term(Long createdTime, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("createdTime", createdTime);
+        TermQueryBuilder builder = regTermQ("createdTime", createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setCreatedTime_Terms(Collection<Long> createdTimeList) {
-        setCreatedTime_MatchPhrasePrefix(createdTimeList, null);
+        setCreatedTime_Terms(createdTimeList, null);
     }
 
-    public void setCreatedTime_MatchPhrasePrefix(Collection<Long> createdTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("createdTime", createdTimeList);
+    public void setCreatedTime_Terms(Collection<Long> createdTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("createdTime", createdTimeList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setCreatedTime_InScope(Collection<Long> createdTimeList) {
-        setCreatedTime_MatchPhrasePrefix(createdTimeList, null);
+        setCreatedTime_Terms(createdTimeList, null);
     }
 
     public void setCreatedTime_InScope(Collection<Long> createdTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setCreatedTime_MatchPhrasePrefix(createdTimeList, opLambda);
+        setCreatedTime_Terms(createdTimeList, opLambda);
     }
 
     public void setCreatedTime_Match(Long createdTime) {
@@ -374,7 +376,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_Match(Long createdTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("createdTime", createdTime);
+        MatchQueryBuilder builder = regMatchQ("createdTime", createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -385,7 +387,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_MatchPhrase(Long createdTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("createdTime", createdTime);
+        MatchQueryBuilder builder = regMatchPhraseQ("createdTime", createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -396,7 +398,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_MatchPhrasePrefix(Long createdTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("createdTime", createdTime);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("createdTime", createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -407,7 +409,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_Fuzzy(Long createdTime, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("createdTime", createdTime);
+        FuzzyQueryBuilder builder = regFuzzyQ("createdTime", createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -418,7 +420,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_GreaterThan(Long createdTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_GREATER_THAN, createdTime);
+        RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_GREATER_THAN, createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -429,7 +431,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_LessThan(Long createdTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_LESS_THAN, createdTime);
+        RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_LESS_THAN, createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -440,7 +442,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_GreaterEqual(Long createdTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime);
+        RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -451,7 +453,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_LessEqual(Long createdTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime);
+        RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -472,29 +474,29 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setId_Term(String id, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("id", id);
+        TermQueryBuilder builder = regTermQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setId_Terms(Collection<String> idList) {
-        setId_MatchPhrasePrefix(idList, null);
+        setId_Terms(idList, null);
     }
 
-    public void setId_MatchPhrasePrefix(Collection<String> idList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("id", idList);
+    public void setId_Terms(Collection<String> idList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("id", idList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setId_InScope(Collection<String> idList) {
-        setId_MatchPhrasePrefix(idList, null);
+        setId_Terms(idList, null);
     }
 
     public void setId_InScope(Collection<String> idList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setId_MatchPhrasePrefix(idList, opLambda);
+        setId_Terms(idList, opLambda);
     }
 
     public void setId_Match(String id) {
@@ -502,7 +504,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setId_Match(String id, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("id", id);
+        MatchQueryBuilder builder = regMatchQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -513,7 +515,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setId_MatchPhrase(String id, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("id", id);
+        MatchQueryBuilder builder = regMatchPhraseQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -524,7 +526,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setId_MatchPhrasePrefix(String id, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("id", id);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -535,7 +537,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setId_Fuzzy(String id, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("id", id);
+        FuzzyQueryBuilder builder = regFuzzyQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -546,7 +548,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setId_Prefix(String id, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("id", id);
+        PrefixQueryBuilder builder = regPrefixQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -557,7 +559,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setId_GreaterThan(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_THAN, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_THAN, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -568,7 +570,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setId_LessThan(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_THAN, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_THAN, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -579,7 +581,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setId_GreaterEqual(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -590,7 +592,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setId_LessEqual(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_EQUAL, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_EQUAL, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -611,29 +613,29 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setSortOrder_Term(Integer sortOrder, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("sortOrder", sortOrder);
+        TermQueryBuilder builder = regTermQ("sortOrder", sortOrder);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setSortOrder_Terms(Collection<Integer> sortOrderList) {
-        setSortOrder_MatchPhrasePrefix(sortOrderList, null);
+        setSortOrder_Terms(sortOrderList, null);
     }
 
-    public void setSortOrder_MatchPhrasePrefix(Collection<Integer> sortOrderList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("sortOrder", sortOrderList);
+    public void setSortOrder_Terms(Collection<Integer> sortOrderList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("sortOrder", sortOrderList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setSortOrder_InScope(Collection<Integer> sortOrderList) {
-        setSortOrder_MatchPhrasePrefix(sortOrderList, null);
+        setSortOrder_Terms(sortOrderList, null);
     }
 
     public void setSortOrder_InScope(Collection<Integer> sortOrderList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setSortOrder_MatchPhrasePrefix(sortOrderList, opLambda);
+        setSortOrder_Terms(sortOrderList, opLambda);
     }
 
     public void setSortOrder_Match(Integer sortOrder) {
@@ -641,7 +643,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setSortOrder_Match(Integer sortOrder, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("sortOrder", sortOrder);
+        MatchQueryBuilder builder = regMatchQ("sortOrder", sortOrder);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -652,7 +654,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setSortOrder_MatchPhrase(Integer sortOrder, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("sortOrder", sortOrder);
+        MatchQueryBuilder builder = regMatchPhraseQ("sortOrder", sortOrder);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -663,7 +665,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setSortOrder_MatchPhrasePrefix(Integer sortOrder, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("sortOrder", sortOrder);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("sortOrder", sortOrder);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -674,7 +676,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setSortOrder_Fuzzy(Integer sortOrder, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("sortOrder", sortOrder);
+        FuzzyQueryBuilder builder = regFuzzyQ("sortOrder", sortOrder);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -685,7 +687,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setSortOrder_GreaterThan(Integer sortOrder, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("sortOrder", ConditionKey.CK_GREATER_THAN, sortOrder);
+        RangeQueryBuilder builder = regRangeQ("sortOrder", ConditionKey.CK_GREATER_THAN, sortOrder);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -696,7 +698,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setSortOrder_LessThan(Integer sortOrder, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("sortOrder", ConditionKey.CK_LESS_THAN, sortOrder);
+        RangeQueryBuilder builder = regRangeQ("sortOrder", ConditionKey.CK_LESS_THAN, sortOrder);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -707,7 +709,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setSortOrder_GreaterEqual(Integer sortOrder, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("sortOrder", ConditionKey.CK_GREATER_EQUAL, sortOrder);
+        RangeQueryBuilder builder = regRangeQ("sortOrder", ConditionKey.CK_GREATER_EQUAL, sortOrder);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -718,7 +720,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setSortOrder_LessEqual(Integer sortOrder, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("sortOrder", ConditionKey.CK_LESS_EQUAL, sortOrder);
+        RangeQueryBuilder builder = regRangeQ("sortOrder", ConditionKey.CK_LESS_EQUAL, sortOrder);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -739,29 +741,29 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedBy_Term(String updatedBy, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("updatedBy", updatedBy);
+        TermQueryBuilder builder = regTermQ("updatedBy", updatedBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setUpdatedBy_Terms(Collection<String> updatedByList) {
-        setUpdatedBy_MatchPhrasePrefix(updatedByList, null);
+        setUpdatedBy_Terms(updatedByList, null);
     }
 
-    public void setUpdatedBy_MatchPhrasePrefix(Collection<String> updatedByList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("updatedBy", updatedByList);
+    public void setUpdatedBy_Terms(Collection<String> updatedByList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("updatedBy", updatedByList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setUpdatedBy_InScope(Collection<String> updatedByList) {
-        setUpdatedBy_MatchPhrasePrefix(updatedByList, null);
+        setUpdatedBy_Terms(updatedByList, null);
     }
 
     public void setUpdatedBy_InScope(Collection<String> updatedByList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setUpdatedBy_MatchPhrasePrefix(updatedByList, opLambda);
+        setUpdatedBy_Terms(updatedByList, opLambda);
     }
 
     public void setUpdatedBy_Match(String updatedBy) {
@@ -769,7 +771,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedBy_Match(String updatedBy, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("updatedBy", updatedBy);
+        MatchQueryBuilder builder = regMatchQ("updatedBy", updatedBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -780,7 +782,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedBy_MatchPhrase(String updatedBy, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("updatedBy", updatedBy);
+        MatchQueryBuilder builder = regMatchPhraseQ("updatedBy", updatedBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -791,7 +793,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedBy_MatchPhrasePrefix(String updatedBy, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("updatedBy", updatedBy);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("updatedBy", updatedBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -802,7 +804,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedBy_Fuzzy(String updatedBy, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("updatedBy", updatedBy);
+        FuzzyQueryBuilder builder = regFuzzyQ("updatedBy", updatedBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -813,7 +815,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedBy_Prefix(String updatedBy, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("updatedBy", updatedBy);
+        PrefixQueryBuilder builder = regPrefixQ("updatedBy", updatedBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -824,7 +826,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedBy_GreaterThan(String updatedBy, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy);
+        RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -835,7 +837,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedBy_LessThan(String updatedBy, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy);
+        RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -846,7 +848,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedBy_GreaterEqual(String updatedBy, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy);
+        RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -857,7 +859,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedBy_LessEqual(String updatedBy, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy);
+        RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -878,29 +880,29 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedTime_Term(Long updatedTime, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("updatedTime", updatedTime);
+        TermQueryBuilder builder = regTermQ("updatedTime", updatedTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setUpdatedTime_Terms(Collection<Long> updatedTimeList) {
-        setUpdatedTime_MatchPhrasePrefix(updatedTimeList, null);
+        setUpdatedTime_Terms(updatedTimeList, null);
     }
 
-    public void setUpdatedTime_MatchPhrasePrefix(Collection<Long> updatedTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("updatedTime", updatedTimeList);
+    public void setUpdatedTime_Terms(Collection<Long> updatedTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("updatedTime", updatedTimeList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setUpdatedTime_InScope(Collection<Long> updatedTimeList) {
-        setUpdatedTime_MatchPhrasePrefix(updatedTimeList, null);
+        setUpdatedTime_Terms(updatedTimeList, null);
     }
 
     public void setUpdatedTime_InScope(Collection<Long> updatedTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setUpdatedTime_MatchPhrasePrefix(updatedTimeList, opLambda);
+        setUpdatedTime_Terms(updatedTimeList, opLambda);
     }
 
     public void setUpdatedTime_Match(Long updatedTime) {
@@ -908,7 +910,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedTime_Match(Long updatedTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("updatedTime", updatedTime);
+        MatchQueryBuilder builder = regMatchQ("updatedTime", updatedTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -919,7 +921,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedTime_MatchPhrase(Long updatedTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("updatedTime", updatedTime);
+        MatchQueryBuilder builder = regMatchPhraseQ("updatedTime", updatedTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -930,7 +932,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedTime_MatchPhrasePrefix(Long updatedTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("updatedTime", updatedTime);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("updatedTime", updatedTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -941,7 +943,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedTime_Fuzzy(Long updatedTime, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("updatedTime", updatedTime);
+        FuzzyQueryBuilder builder = regFuzzyQ("updatedTime", updatedTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -952,7 +954,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedTime_GreaterThan(Long updatedTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime);
+        RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -963,7 +965,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedTime_LessThan(Long updatedTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime);
+        RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -974,7 +976,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedTime_GreaterEqual(Long updatedTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime);
+        RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -985,7 +987,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedTime_LessEqual(Long updatedTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime);
+        RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1006,29 +1008,29 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setUrlExpr_Term(String urlExpr, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("urlExpr", urlExpr);
+        TermQueryBuilder builder = regTermQ("urlExpr", urlExpr);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setUrlExpr_Terms(Collection<String> urlExprList) {
-        setUrlExpr_MatchPhrasePrefix(urlExprList, null);
+        setUrlExpr_Terms(urlExprList, null);
     }
 
-    public void setUrlExpr_MatchPhrasePrefix(Collection<String> urlExprList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("urlExpr", urlExprList);
+    public void setUrlExpr_Terms(Collection<String> urlExprList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("urlExpr", urlExprList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setUrlExpr_InScope(Collection<String> urlExprList) {
-        setUrlExpr_MatchPhrasePrefix(urlExprList, null);
+        setUrlExpr_Terms(urlExprList, null);
     }
 
     public void setUrlExpr_InScope(Collection<String> urlExprList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setUrlExpr_MatchPhrasePrefix(urlExprList, opLambda);
+        setUrlExpr_Terms(urlExprList, opLambda);
     }
 
     public void setUrlExpr_Match(String urlExpr) {
@@ -1036,7 +1038,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setUrlExpr_Match(String urlExpr, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("urlExpr", urlExpr);
+        MatchQueryBuilder builder = regMatchQ("urlExpr", urlExpr);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1047,7 +1049,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setUrlExpr_MatchPhrase(String urlExpr, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("urlExpr", urlExpr);
+        MatchQueryBuilder builder = regMatchPhraseQ("urlExpr", urlExpr);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1058,7 +1060,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setUrlExpr_MatchPhrasePrefix(String urlExpr, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("urlExpr", urlExpr);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("urlExpr", urlExpr);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1069,7 +1071,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setUrlExpr_Fuzzy(String urlExpr, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("urlExpr", urlExpr);
+        FuzzyQueryBuilder builder = regFuzzyQ("urlExpr", urlExpr);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1080,7 +1082,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setUrlExpr_Prefix(String urlExpr, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("urlExpr", urlExpr);
+        PrefixQueryBuilder builder = regPrefixQ("urlExpr", urlExpr);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1091,7 +1093,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setUrlExpr_GreaterThan(String urlExpr, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("urlExpr", ConditionKey.CK_GREATER_THAN, urlExpr);
+        RangeQueryBuilder builder = regRangeQ("urlExpr", ConditionKey.CK_GREATER_THAN, urlExpr);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1102,7 +1104,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setUrlExpr_LessThan(String urlExpr, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("urlExpr", ConditionKey.CK_LESS_THAN, urlExpr);
+        RangeQueryBuilder builder = regRangeQ("urlExpr", ConditionKey.CK_LESS_THAN, urlExpr);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1113,7 +1115,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setUrlExpr_GreaterEqual(String urlExpr, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("urlExpr", ConditionKey.CK_GREATER_EQUAL, urlExpr);
+        RangeQueryBuilder builder = regRangeQ("urlExpr", ConditionKey.CK_GREATER_EQUAL, urlExpr);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1124,7 +1126,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery {
     }
 
     public void setUrlExpr_LessEqual(String urlExpr, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("urlExpr", ConditionKey.CK_LESS_EQUAL, urlExpr);
+        RangeQueryBuilder builder = regRangeQ("urlExpr", ConditionKey.CK_LESS_EQUAL, urlExpr);
         if (opLambda != null) {
             opLambda.callback(builder);
         }

src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsClickLogCQ.java

@@ -3,6 +3,7 @@ package org.codelibs.fess.es.cbean.cq.bs;
 import java.util.Collection;
 
 import org.codelibs.fess.es.cbean.cq.ClickLogCQ;
+import org.codelibs.fess.es.cbean.cf.ClickLogCF;
 import org.dbflute.cbean.ckey.ConditionKey;
 import org.elasticsearch.index.query.BoolQueryBuilder;
 import org.elasticsearch.index.query.FilteredQueryBuilder;
@@ -28,16 +29,16 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery {
         return "click_log";
     }
 
-    public void filtered(FilteredCall<ClickLogCQ> filteredLambda) {
+    public void filtered(FilteredCall<ClickLogCQ, ClickLogCF> filteredLambda) {
         filtered(filteredLambda, null);
     }
 
-    public void filtered(FilteredCall<ClickLogCQ> filteredLambda, ConditionOptionCall<FilteredQueryBuilder> opLambda) {
+    public void filtered(FilteredCall<ClickLogCQ, ClickLogCF> filteredLambda, ConditionOptionCall<FilteredQueryBuilder> opLambda) {
         ClickLogCQ query = new ClickLogCQ();
-        filteredLambda.callback(query);
-        if (!query.queryBuilderList.isEmpty()) {
-            // TODO filter
-            FilteredQueryBuilder builder = reqFilteredQ(query.getQuery(), null);
+        ClickLogCF filter = new ClickLogCF();
+        filteredLambda.callback(query, filter);
+        if (query.hasQueries()) {
+            FilteredQueryBuilder builder = regFilteredQ(query.getQuery(), filter.getFilter());
             if (opLambda != null) {
                 opLambda.callback(builder);
             }
@@ -53,8 +54,8 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery {
         ClickLogCQ shouldQuery = new ClickLogCQ();
         ClickLogCQ mustNotQuery = new ClickLogCQ();
         boolLambda.callback(mustQuery, shouldQuery, mustNotQuery);
-        if (!mustQuery.queryBuilderList.isEmpty() || !shouldQuery.queryBuilderList.isEmpty() || !mustNotQuery.queryBuilderList.isEmpty()) {
-            BoolQueryBuilder builder = reqBoolCQ(mustQuery.queryBuilderList, shouldQuery.queryBuilderList, mustNotQuery.queryBuilderList);
+        if (mustQuery.hasQueries() || shouldQuery.hasQueries() || mustNotQuery.hasQueries()) {
+            BoolQueryBuilder builder = regBoolCQ(mustQuery.queryBuilderList, shouldQuery.queryBuilderList, mustNotQuery.queryBuilderList);
             if (opLambda != null) {
                 opLambda.callback(builder);
             }
@@ -66,29 +67,29 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery {
     }
 
     public void setId_Term(String id, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("id", id);
+        TermQueryBuilder builder = regTermQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setId_Terms(Collection<String> idList) {
-        setId_MatchPhrasePrefix(idList, null);
+        setId_Terms(idList, null);
     }
 
-    public void setId_MatchPhrasePrefix(Collection<String> idList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("id", idList);
+    public void setId_Terms(Collection<String> idList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("id", idList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setId_InScope(Collection<String> idList) {
-        setId_MatchPhrasePrefix(idList, null);
+        setId_Terms(idList, null);
     }
 
     public void setId_InScope(Collection<String> idList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setId_MatchPhrasePrefix(idList, opLambda);
+        setId_Terms(idList, opLambda);
     }
 
     public void setId_Match(String id) {
@@ -96,7 +97,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery {
     }
 
     public void setId_Match(String id, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("id", id);
+        MatchQueryBuilder builder = regMatchQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -107,7 +108,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery {
     }
 
     public void setId_MatchPhrase(String id, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("id", id);
+        MatchQueryBuilder builder = regMatchPhraseQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -118,7 +119,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery {
     }
 
     public void setId_MatchPhrasePrefix(String id, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("id", id);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -129,7 +130,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery {
     }
 
     public void setId_Fuzzy(String id, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("id", id);
+        FuzzyQueryBuilder builder = regFuzzyQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -140,7 +141,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery {
     }
 
     public void setId_Prefix(String id, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("id", id);
+        PrefixQueryBuilder builder = regPrefixQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -151,7 +152,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery {
     }
 
     public void setId_GreaterThan(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_THAN, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_THAN, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -162,7 +163,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery {
     }
 
     public void setId_LessThan(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_THAN, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_THAN, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -173,7 +174,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery {
     }
 
     public void setId_GreaterEqual(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -184,7 +185,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery {
     }
 
     public void setId_LessEqual(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_EQUAL, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_EQUAL, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -205,29 +206,29 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery {
     }
 
     public void setRequestedTime_Term(Long requestedTime, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("requestedTime", requestedTime);
+        TermQueryBuilder builder = regTermQ("requestedTime", requestedTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setRequestedTime_Terms(Collection<Long> requestedTimeList) {
-        setRequestedTime_MatchPhrasePrefix(requestedTimeList, null);
+        setRequestedTime_Terms(requestedTimeList, null);
     }
 
-    public void setRequestedTime_MatchPhrasePrefix(Collection<Long> requestedTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("requestedTime", requestedTimeList);
+    public void setRequestedTime_Terms(Collection<Long> requestedTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("requestedTime", requestedTimeList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setRequestedTime_InScope(Collection<Long> requestedTimeList) {
-        setRequestedTime_MatchPhrasePrefix(requestedTimeList, null);
+        setRequestedTime_Terms(requestedTimeList, null);
     }
 
     public void setRequestedTime_InScope(Collection<Long> requestedTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setRequestedTime_MatchPhrasePrefix(requestedTimeList, opLambda);
+        setRequestedTime_Terms(requestedTimeList, opLambda);
     }
 
     public void setRequestedTime_Match(Long requestedTime) {
@@ -235,7 +236,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery {
     }
 
     public void setRequestedTime_Match(Long requestedTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("requestedTime", requestedTime);
+        MatchQueryBuilder builder = regMatchQ("requestedTime", requestedTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -246,7 +247,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery {
     }
 
     public void setRequestedTime_MatchPhrase(Long requestedTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("requestedTime", requestedTime);
+        MatchQueryBuilder builder = regMatchPhraseQ("requestedTime", requestedTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -257,7 +258,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery {
     }
 
     public void setRequestedTime_MatchPhrasePrefix(Long requestedTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("requestedTime", requestedTime);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("requestedTime", requestedTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -268,7 +269,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery {
     }
 
     public void setRequestedTime_Fuzzy(Long requestedTime, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("requestedTime", requestedTime);
+        FuzzyQueryBuilder builder = regFuzzyQ("requestedTime", requestedTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -279,7 +280,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery {
     }
 
     public void setRequestedTime_GreaterThan(Long requestedTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("requestedTime", ConditionKey.CK_GREATER_THAN, requestedTime);
+        RangeQueryBuilder builder = regRangeQ("requestedTime", ConditionKey.CK_GREATER_THAN, requestedTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -290,7 +291,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery {
     }
 
     public void setRequestedTime_LessThan(Long requestedTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("requestedTime", ConditionKey.CK_LESS_THAN, requestedTime);
+        RangeQueryBuilder builder = regRangeQ("requestedTime", ConditionKey.CK_LESS_THAN, requestedTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -301,7 +302,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery {
     }
 
     public void setRequestedTime_GreaterEqual(Long requestedTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("requestedTime", ConditionKey.CK_GREATER_EQUAL, requestedTime);
+        RangeQueryBuilder builder = regRangeQ("requestedTime", ConditionKey.CK_GREATER_EQUAL, requestedTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -312,7 +313,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery {
     }
 
     public void setRequestedTime_LessEqual(Long requestedTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("requestedTime", ConditionKey.CK_LESS_EQUAL, requestedTime);
+        RangeQueryBuilder builder = regRangeQ("requestedTime", ConditionKey.CK_LESS_EQUAL, requestedTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -333,29 +334,29 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery {
     }
 
     public void setSearchLogId_Term(String searchLogId, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("searchLogId", searchLogId);
+        TermQueryBuilder builder = regTermQ("searchLogId", searchLogId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setSearchLogId_Terms(Collection<String> searchLogIdList) {
-        setSearchLogId_MatchPhrasePrefix(searchLogIdList, null);
+        setSearchLogId_Terms(searchLogIdList, null);
     }
 
-    public void setSearchLogId_MatchPhrasePrefix(Collection<String> searchLogIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("searchLogId", searchLogIdList);
+    public void setSearchLogId_Terms(Collection<String> searchLogIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("searchLogId", searchLogIdList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setSearchLogId_InScope(Collection<String> searchLogIdList) {
-        setSearchLogId_MatchPhrasePrefix(searchLogIdList, null);
+        setSearchLogId_Terms(searchLogIdList, null);
     }
 
     public void setSearchLogId_InScope(Collection<String> searchLogIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setSearchLogId_MatchPhrasePrefix(searchLogIdList, opLambda);
+        setSearchLogId_Terms(searchLogIdList, opLambda);
     }
 
     public void setSearchLogId_Match(String searchLogId) {
@@ -363,7 +364,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery {
     }
 
     public void setSearchLogId_Match(String searchLogId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("searchLogId", searchLogId);
+        MatchQueryBuilder builder = regMatchQ("searchLogId", searchLogId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -374,7 +375,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery {
     }
 
     public void setSearchLogId_MatchPhrase(String searchLogId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("searchLogId", searchLogId);
+        MatchQueryBuilder builder = regMatchPhraseQ("searchLogId", searchLogId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -385,7 +386,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery {
     }
 
     public void setSearchLogId_MatchPhrasePrefix(String searchLogId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("searchLogId", searchLogId);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("searchLogId", searchLogId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -396,7 +397,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery {
     }
 
     public void setSearchLogId_Fuzzy(String searchLogId, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("searchLogId", searchLogId);
+        FuzzyQueryBuilder builder = regFuzzyQ("searchLogId", searchLogId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -407,7 +408,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery {
     }
 
     public void setSearchLogId_Prefix(String searchLogId, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("searchLogId", searchLogId);
+        PrefixQueryBuilder builder = regPrefixQ("searchLogId", searchLogId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -418,7 +419,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery {
     }
 
     public void setSearchLogId_GreaterThan(String searchLogId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("searchLogId", ConditionKey.CK_GREATER_THAN, searchLogId);
+        RangeQueryBuilder builder = regRangeQ("searchLogId", ConditionKey.CK_GREATER_THAN, searchLogId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -429,7 +430,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery {
     }
 
     public void setSearchLogId_LessThan(String searchLogId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("searchLogId", ConditionKey.CK_LESS_THAN, searchLogId);
+        RangeQueryBuilder builder = regRangeQ("searchLogId", ConditionKey.CK_LESS_THAN, searchLogId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -440,7 +441,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery {
     }
 
     public void setSearchLogId_GreaterEqual(String searchLogId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("searchLogId", ConditionKey.CK_GREATER_EQUAL, searchLogId);
+        RangeQueryBuilder builder = regRangeQ("searchLogId", ConditionKey.CK_GREATER_EQUAL, searchLogId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -451,7 +452,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery {
     }
 
     public void setSearchLogId_LessEqual(String searchLogId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("searchLogId", ConditionKey.CK_LESS_EQUAL, searchLogId);
+        RangeQueryBuilder builder = regRangeQ("searchLogId", ConditionKey.CK_LESS_EQUAL, searchLogId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -472,29 +473,29 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery {
     }
 
     public void setUrl_Term(String url, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("url", url);
+        TermQueryBuilder builder = regTermQ("url", url);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setUrl_Terms(Collection<String> urlList) {
-        setUrl_MatchPhrasePrefix(urlList, null);
+        setUrl_Terms(urlList, null);
     }
 
-    public void setUrl_MatchPhrasePrefix(Collection<String> urlList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("url", urlList);
+    public void setUrl_Terms(Collection<String> urlList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("url", urlList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setUrl_InScope(Collection<String> urlList) {
-        setUrl_MatchPhrasePrefix(urlList, null);
+        setUrl_Terms(urlList, null);
     }
 
     public void setUrl_InScope(Collection<String> urlList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setUrl_MatchPhrasePrefix(urlList, opLambda);
+        setUrl_Terms(urlList, opLambda);
     }
 
     public void setUrl_Match(String url) {
@@ -502,7 +503,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery {
     }
 
     public void setUrl_Match(String url, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("url", url);
+        MatchQueryBuilder builder = regMatchQ("url", url);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -513,7 +514,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery {
     }
 
     public void setUrl_MatchPhrase(String url, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("url", url);
+        MatchQueryBuilder builder = regMatchPhraseQ("url", url);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -524,7 +525,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery {
     }
 
     public void setUrl_MatchPhrasePrefix(String url, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("url", url);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("url", url);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -535,7 +536,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery {
     }
 
     public void setUrl_Fuzzy(String url, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("url", url);
+        FuzzyQueryBuilder builder = regFuzzyQ("url", url);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -546,7 +547,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery {
     }
 
     public void setUrl_Prefix(String url, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("url", url);
+        PrefixQueryBuilder builder = regPrefixQ("url", url);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -557,7 +558,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery {
     }
 
     public void setUrl_GreaterThan(String url, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("url", ConditionKey.CK_GREATER_THAN, url);
+        RangeQueryBuilder builder = regRangeQ("url", ConditionKey.CK_GREATER_THAN, url);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -568,7 +569,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery {
     }
 
     public void setUrl_LessThan(String url, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("url", ConditionKey.CK_LESS_THAN, url);
+        RangeQueryBuilder builder = regRangeQ("url", ConditionKey.CK_LESS_THAN, url);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -579,7 +580,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery {
     }
 
     public void setUrl_GreaterEqual(String url, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("url", ConditionKey.CK_GREATER_EQUAL, url);
+        RangeQueryBuilder builder = regRangeQ("url", ConditionKey.CK_GREATER_EQUAL, url);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -590,7 +591,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery {
     }
 
     public void setUrl_LessEqual(String url, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("url", ConditionKey.CK_LESS_EQUAL, url);
+        RangeQueryBuilder builder = regRangeQ("url", ConditionKey.CK_LESS_EQUAL, url);
         if (opLambda != null) {
             opLambda.callback(builder);
         }

src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsCrawlingSessionCQ.java

@@ -3,6 +3,7 @@ package org.codelibs.fess.es.cbean.cq.bs;
 import java.util.Collection;
 
 import org.codelibs.fess.es.cbean.cq.CrawlingSessionCQ;
+import org.codelibs.fess.es.cbean.cf.CrawlingSessionCF;
 import org.dbflute.cbean.ckey.ConditionKey;
 import org.elasticsearch.index.query.BoolQueryBuilder;
 import org.elasticsearch.index.query.FilteredQueryBuilder;
@@ -28,16 +29,17 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery {
         return "crawling_session";
     }
 
-    public void filtered(FilteredCall<CrawlingSessionCQ> filteredLambda) {
+    public void filtered(FilteredCall<CrawlingSessionCQ, CrawlingSessionCF> filteredLambda) {
         filtered(filteredLambda, null);
     }
 
-    public void filtered(FilteredCall<CrawlingSessionCQ> filteredLambda, ConditionOptionCall<FilteredQueryBuilder> opLambda) {
+    public void filtered(FilteredCall<CrawlingSessionCQ, CrawlingSessionCF> filteredLambda,
+            ConditionOptionCall<FilteredQueryBuilder> opLambda) {
         CrawlingSessionCQ query = new CrawlingSessionCQ();
-        filteredLambda.callback(query);
-        if (!query.queryBuilderList.isEmpty()) {
-            // TODO filter
-            FilteredQueryBuilder builder = reqFilteredQ(query.getQuery(), null);
+        CrawlingSessionCF filter = new CrawlingSessionCF();
+        filteredLambda.callback(query, filter);
+        if (query.hasQueries()) {
+            FilteredQueryBuilder builder = regFilteredQ(query.getQuery(), filter.getFilter());
             if (opLambda != null) {
                 opLambda.callback(builder);
             }
@@ -53,8 +55,8 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery {
         CrawlingSessionCQ shouldQuery = new CrawlingSessionCQ();
         CrawlingSessionCQ mustNotQuery = new CrawlingSessionCQ();
         boolLambda.callback(mustQuery, shouldQuery, mustNotQuery);
-        if (!mustQuery.queryBuilderList.isEmpty() || !shouldQuery.queryBuilderList.isEmpty() || !mustNotQuery.queryBuilderList.isEmpty()) {
-            BoolQueryBuilder builder = reqBoolCQ(mustQuery.queryBuilderList, shouldQuery.queryBuilderList, mustNotQuery.queryBuilderList);
+        if (mustQuery.hasQueries() || shouldQuery.hasQueries() || mustNotQuery.hasQueries()) {
+            BoolQueryBuilder builder = regBoolCQ(mustQuery.queryBuilderList, shouldQuery.queryBuilderList, mustNotQuery.queryBuilderList);
             if (opLambda != null) {
                 opLambda.callback(builder);
             }
@@ -66,29 +68,29 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_Term(Long createdTime, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("createdTime", createdTime);
+        TermQueryBuilder builder = regTermQ("createdTime", createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setCreatedTime_Terms(Collection<Long> createdTimeList) {
-        setCreatedTime_MatchPhrasePrefix(createdTimeList, null);
+        setCreatedTime_Terms(createdTimeList, null);
     }
 
-    public void setCreatedTime_MatchPhrasePrefix(Collection<Long> createdTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("createdTime", createdTimeList);
+    public void setCreatedTime_Terms(Collection<Long> createdTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("createdTime", createdTimeList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setCreatedTime_InScope(Collection<Long> createdTimeList) {
-        setCreatedTime_MatchPhrasePrefix(createdTimeList, null);
+        setCreatedTime_Terms(createdTimeList, null);
     }
 
     public void setCreatedTime_InScope(Collection<Long> createdTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setCreatedTime_MatchPhrasePrefix(createdTimeList, opLambda);
+        setCreatedTime_Terms(createdTimeList, opLambda);
     }
 
     public void setCreatedTime_Match(Long createdTime) {
@@ -96,7 +98,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_Match(Long createdTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("createdTime", createdTime);
+        MatchQueryBuilder builder = regMatchQ("createdTime", createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -107,7 +109,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_MatchPhrase(Long createdTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("createdTime", createdTime);
+        MatchQueryBuilder builder = regMatchPhraseQ("createdTime", createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -118,7 +120,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_MatchPhrasePrefix(Long createdTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("createdTime", createdTime);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("createdTime", createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -129,7 +131,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_Fuzzy(Long createdTime, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("createdTime", createdTime);
+        FuzzyQueryBuilder builder = regFuzzyQ("createdTime", createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -140,7 +142,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_GreaterThan(Long createdTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_GREATER_THAN, createdTime);
+        RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_GREATER_THAN, createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -151,7 +153,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_LessThan(Long createdTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_LESS_THAN, createdTime);
+        RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_LESS_THAN, createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -162,7 +164,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_GreaterEqual(Long createdTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime);
+        RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -173,7 +175,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_LessEqual(Long createdTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime);
+        RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -194,29 +196,29 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery {
     }
 
     public void setExpiredTime_Term(Long expiredTime, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("expiredTime", expiredTime);
+        TermQueryBuilder builder = regTermQ("expiredTime", expiredTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setExpiredTime_Terms(Collection<Long> expiredTimeList) {
-        setExpiredTime_MatchPhrasePrefix(expiredTimeList, null);
+        setExpiredTime_Terms(expiredTimeList, null);
     }
 
-    public void setExpiredTime_MatchPhrasePrefix(Collection<Long> expiredTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("expiredTime", expiredTimeList);
+    public void setExpiredTime_Terms(Collection<Long> expiredTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("expiredTime", expiredTimeList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setExpiredTime_InScope(Collection<Long> expiredTimeList) {
-        setExpiredTime_MatchPhrasePrefix(expiredTimeList, null);
+        setExpiredTime_Terms(expiredTimeList, null);
     }
 
     public void setExpiredTime_InScope(Collection<Long> expiredTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setExpiredTime_MatchPhrasePrefix(expiredTimeList, opLambda);
+        setExpiredTime_Terms(expiredTimeList, opLambda);
     }
 
     public void setExpiredTime_Match(Long expiredTime) {
@@ -224,7 +226,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery {
     }
 
     public void setExpiredTime_Match(Long expiredTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("expiredTime", expiredTime);
+        MatchQueryBuilder builder = regMatchQ("expiredTime", expiredTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -235,7 +237,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery {
     }
 
     public void setExpiredTime_MatchPhrase(Long expiredTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("expiredTime", expiredTime);
+        MatchQueryBuilder builder = regMatchPhraseQ("expiredTime", expiredTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -246,7 +248,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery {
     }
 
     public void setExpiredTime_MatchPhrasePrefix(Long expiredTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("expiredTime", expiredTime);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("expiredTime", expiredTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -257,7 +259,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery {
     }
 
     public void setExpiredTime_Fuzzy(Long expiredTime, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("expiredTime", expiredTime);
+        FuzzyQueryBuilder builder = regFuzzyQ("expiredTime", expiredTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -268,7 +270,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery {
     }
 
     public void setExpiredTime_GreaterThan(Long expiredTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("expiredTime", ConditionKey.CK_GREATER_THAN, expiredTime);
+        RangeQueryBuilder builder = regRangeQ("expiredTime", ConditionKey.CK_GREATER_THAN, expiredTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -279,7 +281,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery {
     }
 
     public void setExpiredTime_LessThan(Long expiredTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("expiredTime", ConditionKey.CK_LESS_THAN, expiredTime);
+        RangeQueryBuilder builder = regRangeQ("expiredTime", ConditionKey.CK_LESS_THAN, expiredTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -290,7 +292,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery {
     }
 
     public void setExpiredTime_GreaterEqual(Long expiredTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("expiredTime", ConditionKey.CK_GREATER_EQUAL, expiredTime);
+        RangeQueryBuilder builder = regRangeQ("expiredTime", ConditionKey.CK_GREATER_EQUAL, expiredTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -301,7 +303,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery {
     }
 
     public void setExpiredTime_LessEqual(Long expiredTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("expiredTime", ConditionKey.CK_LESS_EQUAL, expiredTime);
+        RangeQueryBuilder builder = regRangeQ("expiredTime", ConditionKey.CK_LESS_EQUAL, expiredTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -322,29 +324,29 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery {
     }
 
     public void setId_Term(String id, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("id", id);
+        TermQueryBuilder builder = regTermQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setId_Terms(Collection<String> idList) {
-        setId_MatchPhrasePrefix(idList, null);
+        setId_Terms(idList, null);
     }
 
-    public void setId_MatchPhrasePrefix(Collection<String> idList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("id", idList);
+    public void setId_Terms(Collection<String> idList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("id", idList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setId_InScope(Collection<String> idList) {
-        setId_MatchPhrasePrefix(idList, null);
+        setId_Terms(idList, null);
     }
 
     public void setId_InScope(Collection<String> idList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setId_MatchPhrasePrefix(idList, opLambda);
+        setId_Terms(idList, opLambda);
     }
 
     public void setId_Match(String id) {
@@ -352,7 +354,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery {
     }
 
     public void setId_Match(String id, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("id", id);
+        MatchQueryBuilder builder = regMatchQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -363,7 +365,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery {
     }
 
     public void setId_MatchPhrase(String id, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("id", id);
+        MatchQueryBuilder builder = regMatchPhraseQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -374,7 +376,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery {
     }
 
     public void setId_MatchPhrasePrefix(String id, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("id", id);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -385,7 +387,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery {
     }
 
     public void setId_Fuzzy(String id, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("id", id);
+        FuzzyQueryBuilder builder = regFuzzyQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -396,7 +398,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery {
     }
 
     public void setId_Prefix(String id, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("id", id);
+        PrefixQueryBuilder builder = regPrefixQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -407,7 +409,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery {
     }
 
     public void setId_GreaterThan(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_THAN, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_THAN, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -418,7 +420,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery {
     }
 
     public void setId_LessThan(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_THAN, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_THAN, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -429,7 +431,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery {
     }
 
     public void setId_GreaterEqual(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -440,7 +442,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery {
     }
 
     public void setId_LessEqual(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_EQUAL, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_EQUAL, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -461,29 +463,29 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery {
     }
 
     public void setName_Term(String name, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("name", name);
+        TermQueryBuilder builder = regTermQ("name", name);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setName_Terms(Collection<String> nameList) {
-        setName_MatchPhrasePrefix(nameList, null);
+        setName_Terms(nameList, null);
     }
 
-    public void setName_MatchPhrasePrefix(Collection<String> nameList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("name", nameList);
+    public void setName_Terms(Collection<String> nameList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("name", nameList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setName_InScope(Collection<String> nameList) {
-        setName_MatchPhrasePrefix(nameList, null);
+        setName_Terms(nameList, null);
     }
 
     public void setName_InScope(Collection<String> nameList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setName_MatchPhrasePrefix(nameList, opLambda);
+        setName_Terms(nameList, opLambda);
     }
 
     public void setName_Match(String name) {
@@ -491,7 +493,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery {
     }
 
     public void setName_Match(String name, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("name", name);
+        MatchQueryBuilder builder = regMatchQ("name", name);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -502,7 +504,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery {
     }
 
     public void setName_MatchPhrase(String name, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("name", name);
+        MatchQueryBuilder builder = regMatchPhraseQ("name", name);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -513,7 +515,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery {
     }
 
     public void setName_MatchPhrasePrefix(String name, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("name", name);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("name", name);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -524,7 +526,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery {
     }
 
     public void setName_Fuzzy(String name, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("name", name);
+        FuzzyQueryBuilder builder = regFuzzyQ("name", name);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -535,7 +537,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery {
     }
 
     public void setName_Prefix(String name, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("name", name);
+        PrefixQueryBuilder builder = regPrefixQ("name", name);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -546,7 +548,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery {
     }
 
     public void setName_GreaterThan(String name, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("name", ConditionKey.CK_GREATER_THAN, name);
+        RangeQueryBuilder builder = regRangeQ("name", ConditionKey.CK_GREATER_THAN, name);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -557,7 +559,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery {
     }
 
     public void setName_LessThan(String name, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("name", ConditionKey.CK_LESS_THAN, name);
+        RangeQueryBuilder builder = regRangeQ("name", ConditionKey.CK_LESS_THAN, name);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -568,7 +570,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery {
     }
 
     public void setName_GreaterEqual(String name, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("name", ConditionKey.CK_GREATER_EQUAL, name);
+        RangeQueryBuilder builder = regRangeQ("name", ConditionKey.CK_GREATER_EQUAL, name);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -579,7 +581,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery {
     }
 
     public void setName_LessEqual(String name, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("name", ConditionKey.CK_LESS_EQUAL, name);
+        RangeQueryBuilder builder = regRangeQ("name", ConditionKey.CK_LESS_EQUAL, name);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -600,29 +602,29 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery {
     }
 
     public void setSessionId_Term(String sessionId, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("sessionId", sessionId);
+        TermQueryBuilder builder = regTermQ("sessionId", sessionId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setSessionId_Terms(Collection<String> sessionIdList) {
-        setSessionId_MatchPhrasePrefix(sessionIdList, null);
+        setSessionId_Terms(sessionIdList, null);
     }
 
-    public void setSessionId_MatchPhrasePrefix(Collection<String> sessionIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("sessionId", sessionIdList);
+    public void setSessionId_Terms(Collection<String> sessionIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("sessionId", sessionIdList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setSessionId_InScope(Collection<String> sessionIdList) {
-        setSessionId_MatchPhrasePrefix(sessionIdList, null);
+        setSessionId_Terms(sessionIdList, null);
     }
 
     public void setSessionId_InScope(Collection<String> sessionIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setSessionId_MatchPhrasePrefix(sessionIdList, opLambda);
+        setSessionId_Terms(sessionIdList, opLambda);
     }
 
     public void setSessionId_Match(String sessionId) {
@@ -630,7 +632,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery {
     }
 
     public void setSessionId_Match(String sessionId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("sessionId", sessionId);
+        MatchQueryBuilder builder = regMatchQ("sessionId", sessionId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -641,7 +643,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery {
     }
 
     public void setSessionId_MatchPhrase(String sessionId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("sessionId", sessionId);
+        MatchQueryBuilder builder = regMatchPhraseQ("sessionId", sessionId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -652,7 +654,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery {
     }
 
     public void setSessionId_MatchPhrasePrefix(String sessionId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("sessionId", sessionId);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("sessionId", sessionId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -663,7 +665,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery {
     }
 
     public void setSessionId_Fuzzy(String sessionId, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("sessionId", sessionId);
+        FuzzyQueryBuilder builder = regFuzzyQ("sessionId", sessionId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -674,7 +676,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery {
     }
 
     public void setSessionId_Prefix(String sessionId, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("sessionId", sessionId);
+        PrefixQueryBuilder builder = regPrefixQ("sessionId", sessionId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -685,7 +687,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery {
     }
 
     public void setSessionId_GreaterThan(String sessionId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("sessionId", ConditionKey.CK_GREATER_THAN, sessionId);
+        RangeQueryBuilder builder = regRangeQ("sessionId", ConditionKey.CK_GREATER_THAN, sessionId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -696,7 +698,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery {
     }
 
     public void setSessionId_LessThan(String sessionId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("sessionId", ConditionKey.CK_LESS_THAN, sessionId);
+        RangeQueryBuilder builder = regRangeQ("sessionId", ConditionKey.CK_LESS_THAN, sessionId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -707,7 +709,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery {
     }
 
     public void setSessionId_GreaterEqual(String sessionId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("sessionId", ConditionKey.CK_GREATER_EQUAL, sessionId);
+        RangeQueryBuilder builder = regRangeQ("sessionId", ConditionKey.CK_GREATER_EQUAL, sessionId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -718,7 +720,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery {
     }
 
     public void setSessionId_LessEqual(String sessionId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("sessionId", ConditionKey.CK_LESS_EQUAL, sessionId);
+        RangeQueryBuilder builder = regRangeQ("sessionId", ConditionKey.CK_LESS_EQUAL, sessionId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }

src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsCrawlingSessionInfoCQ.java

@@ -3,6 +3,7 @@ package org.codelibs.fess.es.cbean.cq.bs;
 import java.util.Collection;
 
 import org.codelibs.fess.es.cbean.cq.CrawlingSessionInfoCQ;
+import org.codelibs.fess.es.cbean.cf.CrawlingSessionInfoCF;
 import org.dbflute.cbean.ckey.ConditionKey;
 import org.elasticsearch.index.query.BoolQueryBuilder;
 import org.elasticsearch.index.query.FilteredQueryBuilder;
@@ -28,16 +29,17 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery {
         return "crawling_session_info";
     }
 
-    public void filtered(FilteredCall<CrawlingSessionInfoCQ> filteredLambda) {
+    public void filtered(FilteredCall<CrawlingSessionInfoCQ, CrawlingSessionInfoCF> filteredLambda) {
         filtered(filteredLambda, null);
     }
 
-    public void filtered(FilteredCall<CrawlingSessionInfoCQ> filteredLambda, ConditionOptionCall<FilteredQueryBuilder> opLambda) {
+    public void filtered(FilteredCall<CrawlingSessionInfoCQ, CrawlingSessionInfoCF> filteredLambda,
+            ConditionOptionCall<FilteredQueryBuilder> opLambda) {
         CrawlingSessionInfoCQ query = new CrawlingSessionInfoCQ();
-        filteredLambda.callback(query);
-        if (!query.queryBuilderList.isEmpty()) {
-            // TODO filter
-            FilteredQueryBuilder builder = reqFilteredQ(query.getQuery(), null);
+        CrawlingSessionInfoCF filter = new CrawlingSessionInfoCF();
+        filteredLambda.callback(query, filter);
+        if (query.hasQueries()) {
+            FilteredQueryBuilder builder = regFilteredQ(query.getQuery(), filter.getFilter());
             if (opLambda != null) {
                 opLambda.callback(builder);
             }
@@ -53,8 +55,8 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery {
         CrawlingSessionInfoCQ shouldQuery = new CrawlingSessionInfoCQ();
         CrawlingSessionInfoCQ mustNotQuery = new CrawlingSessionInfoCQ();
         boolLambda.callback(mustQuery, shouldQuery, mustNotQuery);
-        if (!mustQuery.queryBuilderList.isEmpty() || !shouldQuery.queryBuilderList.isEmpty() || !mustNotQuery.queryBuilderList.isEmpty()) {
-            BoolQueryBuilder builder = reqBoolCQ(mustQuery.queryBuilderList, shouldQuery.queryBuilderList, mustNotQuery.queryBuilderList);
+        if (mustQuery.hasQueries() || shouldQuery.hasQueries() || mustNotQuery.hasQueries()) {
+            BoolQueryBuilder builder = regBoolCQ(mustQuery.queryBuilderList, shouldQuery.queryBuilderList, mustNotQuery.queryBuilderList);
             if (opLambda != null) {
                 opLambda.callback(builder);
             }
@@ -66,30 +68,29 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery {
     }
 
     public void setCrawlingSessionId_Term(String crawlingSessionId, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("crawlingSessionId", crawlingSessionId);
+        TermQueryBuilder builder = regTermQ("crawlingSessionId", crawlingSessionId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setCrawlingSessionId_Terms(Collection<String> crawlingSessionIdList) {
-        setCrawlingSessionId_MatchPhrasePrefix(crawlingSessionIdList, null);
+        setCrawlingSessionId_Terms(crawlingSessionIdList, null);
     }
 
-    public void setCrawlingSessionId_MatchPhrasePrefix(Collection<String> crawlingSessionIdList,
-            ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("crawlingSessionId", crawlingSessionIdList);
+    public void setCrawlingSessionId_Terms(Collection<String> crawlingSessionIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("crawlingSessionId", crawlingSessionIdList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setCrawlingSessionId_InScope(Collection<String> crawlingSessionIdList) {
-        setCrawlingSessionId_MatchPhrasePrefix(crawlingSessionIdList, null);
+        setCrawlingSessionId_Terms(crawlingSessionIdList, null);
     }
 
     public void setCrawlingSessionId_InScope(Collection<String> crawlingSessionIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setCrawlingSessionId_MatchPhrasePrefix(crawlingSessionIdList, opLambda);
+        setCrawlingSessionId_Terms(crawlingSessionIdList, opLambda);
     }
 
     public void setCrawlingSessionId_Match(String crawlingSessionId) {
@@ -97,7 +98,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery {
     }
 
     public void setCrawlingSessionId_Match(String crawlingSessionId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("crawlingSessionId", crawlingSessionId);
+        MatchQueryBuilder builder = regMatchQ("crawlingSessionId", crawlingSessionId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -108,7 +109,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery {
     }
 
     public void setCrawlingSessionId_MatchPhrase(String crawlingSessionId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("crawlingSessionId", crawlingSessionId);
+        MatchQueryBuilder builder = regMatchPhraseQ("crawlingSessionId", crawlingSessionId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -119,7 +120,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery {
     }
 
     public void setCrawlingSessionId_MatchPhrasePrefix(String crawlingSessionId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("crawlingSessionId", crawlingSessionId);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("crawlingSessionId", crawlingSessionId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -130,7 +131,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery {
     }
 
     public void setCrawlingSessionId_Fuzzy(String crawlingSessionId, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("crawlingSessionId", crawlingSessionId);
+        FuzzyQueryBuilder builder = regFuzzyQ("crawlingSessionId", crawlingSessionId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -141,7 +142,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery {
     }
 
     public void setCrawlingSessionId_Prefix(String crawlingSessionId, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("crawlingSessionId", crawlingSessionId);
+        PrefixQueryBuilder builder = regPrefixQ("crawlingSessionId", crawlingSessionId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -152,7 +153,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery {
     }
 
     public void setCrawlingSessionId_GreaterThan(String crawlingSessionId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("crawlingSessionId", ConditionKey.CK_GREATER_THAN, crawlingSessionId);
+        RangeQueryBuilder builder = regRangeQ("crawlingSessionId", ConditionKey.CK_GREATER_THAN, crawlingSessionId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -163,7 +164,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery {
     }
 
     public void setCrawlingSessionId_LessThan(String crawlingSessionId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("crawlingSessionId", ConditionKey.CK_LESS_THAN, crawlingSessionId);
+        RangeQueryBuilder builder = regRangeQ("crawlingSessionId", ConditionKey.CK_LESS_THAN, crawlingSessionId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -174,7 +175,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery {
     }
 
     public void setCrawlingSessionId_GreaterEqual(String crawlingSessionId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("crawlingSessionId", ConditionKey.CK_GREATER_EQUAL, crawlingSessionId);
+        RangeQueryBuilder builder = regRangeQ("crawlingSessionId", ConditionKey.CK_GREATER_EQUAL, crawlingSessionId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -185,7 +186,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery {
     }
 
     public void setCrawlingSessionId_LessEqual(String crawlingSessionId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("crawlingSessionId", ConditionKey.CK_LESS_EQUAL, crawlingSessionId);
+        RangeQueryBuilder builder = regRangeQ("crawlingSessionId", ConditionKey.CK_LESS_EQUAL, crawlingSessionId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -206,29 +207,29 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_Term(Long createdTime, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("createdTime", createdTime);
+        TermQueryBuilder builder = regTermQ("createdTime", createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setCreatedTime_Terms(Collection<Long> createdTimeList) {
-        setCreatedTime_MatchPhrasePrefix(createdTimeList, null);
+        setCreatedTime_Terms(createdTimeList, null);
     }
 
-    public void setCreatedTime_MatchPhrasePrefix(Collection<Long> createdTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("createdTime", createdTimeList);
+    public void setCreatedTime_Terms(Collection<Long> createdTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("createdTime", createdTimeList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setCreatedTime_InScope(Collection<Long> createdTimeList) {
-        setCreatedTime_MatchPhrasePrefix(createdTimeList, null);
+        setCreatedTime_Terms(createdTimeList, null);
     }
 
     public void setCreatedTime_InScope(Collection<Long> createdTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setCreatedTime_MatchPhrasePrefix(createdTimeList, opLambda);
+        setCreatedTime_Terms(createdTimeList, opLambda);
     }
 
     public void setCreatedTime_Match(Long createdTime) {
@@ -236,7 +237,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_Match(Long createdTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("createdTime", createdTime);
+        MatchQueryBuilder builder = regMatchQ("createdTime", createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -247,7 +248,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_MatchPhrase(Long createdTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("createdTime", createdTime);
+        MatchQueryBuilder builder = regMatchPhraseQ("createdTime", createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -258,7 +259,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_MatchPhrasePrefix(Long createdTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("createdTime", createdTime);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("createdTime", createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -269,7 +270,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_Fuzzy(Long createdTime, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("createdTime", createdTime);
+        FuzzyQueryBuilder builder = regFuzzyQ("createdTime", createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -280,7 +281,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_GreaterThan(Long createdTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_GREATER_THAN, createdTime);
+        RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_GREATER_THAN, createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -291,7 +292,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_LessThan(Long createdTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_LESS_THAN, createdTime);
+        RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_LESS_THAN, createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -302,7 +303,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_GreaterEqual(Long createdTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime);
+        RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -313,7 +314,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_LessEqual(Long createdTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime);
+        RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -334,29 +335,29 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery {
     }
 
     public void setId_Term(String id, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("id", id);
+        TermQueryBuilder builder = regTermQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setId_Terms(Collection<String> idList) {
-        setId_MatchPhrasePrefix(idList, null);
+        setId_Terms(idList, null);
     }
 
-    public void setId_MatchPhrasePrefix(Collection<String> idList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("id", idList);
+    public void setId_Terms(Collection<String> idList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("id", idList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setId_InScope(Collection<String> idList) {
-        setId_MatchPhrasePrefix(idList, null);
+        setId_Terms(idList, null);
     }
 
     public void setId_InScope(Collection<String> idList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setId_MatchPhrasePrefix(idList, opLambda);
+        setId_Terms(idList, opLambda);
     }
 
     public void setId_Match(String id) {
@@ -364,7 +365,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery {
     }
 
     public void setId_Match(String id, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("id", id);
+        MatchQueryBuilder builder = regMatchQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -375,7 +376,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery {
     }
 
     public void setId_MatchPhrase(String id, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("id", id);
+        MatchQueryBuilder builder = regMatchPhraseQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -386,7 +387,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery {
     }
 
     public void setId_MatchPhrasePrefix(String id, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("id", id);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -397,7 +398,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery {
     }
 
     public void setId_Fuzzy(String id, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("id", id);
+        FuzzyQueryBuilder builder = regFuzzyQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -408,7 +409,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery {
     }
 
     public void setId_Prefix(String id, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("id", id);
+        PrefixQueryBuilder builder = regPrefixQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -419,7 +420,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery {
     }
 
     public void setId_GreaterThan(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_THAN, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_THAN, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -430,7 +431,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery {
     }
 
     public void setId_LessThan(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_THAN, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_THAN, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -441,7 +442,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery {
     }
 
     public void setId_GreaterEqual(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -452,7 +453,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery {
     }
 
     public void setId_LessEqual(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_EQUAL, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_EQUAL, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -473,29 +474,29 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery {
     }
 
     public void setKey_Term(String key, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("key", key);
+        TermQueryBuilder builder = regTermQ("key", key);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setKey_Terms(Collection<String> keyList) {
-        setKey_MatchPhrasePrefix(keyList, null);
+        setKey_Terms(keyList, null);
     }
 
-    public void setKey_MatchPhrasePrefix(Collection<String> keyList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("key", keyList);
+    public void setKey_Terms(Collection<String> keyList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("key", keyList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setKey_InScope(Collection<String> keyList) {
-        setKey_MatchPhrasePrefix(keyList, null);
+        setKey_Terms(keyList, null);
     }
 
     public void setKey_InScope(Collection<String> keyList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setKey_MatchPhrasePrefix(keyList, opLambda);
+        setKey_Terms(keyList, opLambda);
     }
 
     public void setKey_Match(String key) {
@@ -503,7 +504,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery {
     }
 
     public void setKey_Match(String key, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("key", key);
+        MatchQueryBuilder builder = regMatchQ("key", key);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -514,7 +515,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery {
     }
 
     public void setKey_MatchPhrase(String key, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("key", key);
+        MatchQueryBuilder builder = regMatchPhraseQ("key", key);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -525,7 +526,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery {
     }
 
     public void setKey_MatchPhrasePrefix(String key, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("key", key);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("key", key);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -536,7 +537,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery {
     }
 
     public void setKey_Fuzzy(String key, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("key", key);
+        FuzzyQueryBuilder builder = regFuzzyQ("key", key);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -547,7 +548,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery {
     }
 
     public void setKey_Prefix(String key, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("key", key);
+        PrefixQueryBuilder builder = regPrefixQ("key", key);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -558,7 +559,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery {
     }
 
     public void setKey_GreaterThan(String key, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("key", ConditionKey.CK_GREATER_THAN, key);
+        RangeQueryBuilder builder = regRangeQ("key", ConditionKey.CK_GREATER_THAN, key);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -569,7 +570,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery {
     }
 
     public void setKey_LessThan(String key, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("key", ConditionKey.CK_LESS_THAN, key);
+        RangeQueryBuilder builder = regRangeQ("key", ConditionKey.CK_LESS_THAN, key);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -580,7 +581,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery {
     }
 
     public void setKey_GreaterEqual(String key, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("key", ConditionKey.CK_GREATER_EQUAL, key);
+        RangeQueryBuilder builder = regRangeQ("key", ConditionKey.CK_GREATER_EQUAL, key);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -591,7 +592,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery {
     }
 
     public void setKey_LessEqual(String key, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("key", ConditionKey.CK_LESS_EQUAL, key);
+        RangeQueryBuilder builder = regRangeQ("key", ConditionKey.CK_LESS_EQUAL, key);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -612,29 +613,29 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery {
     }
 
     public void setValue_Term(String value, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("value", value);
+        TermQueryBuilder builder = regTermQ("value", value);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setValue_Terms(Collection<String> valueList) {
-        setValue_MatchPhrasePrefix(valueList, null);
+        setValue_Terms(valueList, null);
     }
 
-    public void setValue_MatchPhrasePrefix(Collection<String> valueList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("value", valueList);
+    public void setValue_Terms(Collection<String> valueList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("value", valueList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setValue_InScope(Collection<String> valueList) {
-        setValue_MatchPhrasePrefix(valueList, null);
+        setValue_Terms(valueList, null);
     }
 
     public void setValue_InScope(Collection<String> valueList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setValue_MatchPhrasePrefix(valueList, opLambda);
+        setValue_Terms(valueList, opLambda);
     }
 
     public void setValue_Match(String value) {
@@ -642,7 +643,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery {
     }
 
     public void setValue_Match(String value, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("value", value);
+        MatchQueryBuilder builder = regMatchQ("value", value);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -653,7 +654,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery {
     }
 
     public void setValue_MatchPhrase(String value, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("value", value);
+        MatchQueryBuilder builder = regMatchPhraseQ("value", value);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -664,7 +665,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery {
     }
 
     public void setValue_MatchPhrasePrefix(String value, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("value", value);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("value", value);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -675,7 +676,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery {
     }
 
     public void setValue_Fuzzy(String value, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("value", value);
+        FuzzyQueryBuilder builder = regFuzzyQ("value", value);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -686,7 +687,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery {
     }
 
     public void setValue_Prefix(String value, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("value", value);
+        PrefixQueryBuilder builder = regPrefixQ("value", value);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -697,7 +698,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery {
     }
 
     public void setValue_GreaterThan(String value, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("value", ConditionKey.CK_GREATER_THAN, value);
+        RangeQueryBuilder builder = regRangeQ("value", ConditionKey.CK_GREATER_THAN, value);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -708,7 +709,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery {
     }
 
     public void setValue_LessThan(String value, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("value", ConditionKey.CK_LESS_THAN, value);
+        RangeQueryBuilder builder = regRangeQ("value", ConditionKey.CK_LESS_THAN, value);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -719,7 +720,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery {
     }
 
     public void setValue_GreaterEqual(String value, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("value", ConditionKey.CK_GREATER_EQUAL, value);
+        RangeQueryBuilder builder = regRangeQ("value", ConditionKey.CK_GREATER_EQUAL, value);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -730,7 +731,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery {
     }
 
     public void setValue_LessEqual(String value, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("value", ConditionKey.CK_LESS_EQUAL, value);
+        RangeQueryBuilder builder = regRangeQ("value", ConditionKey.CK_LESS_EQUAL, value);
         if (opLambda != null) {
             opLambda.callback(builder);
         }

src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsDataConfigToLabelCQ.java

@@ -3,6 +3,7 @@ package org.codelibs.fess.es.cbean.cq.bs;
 import java.util.Collection;
 
 import org.codelibs.fess.es.cbean.cq.DataConfigToLabelCQ;
+import org.codelibs.fess.es.cbean.cf.DataConfigToLabelCF;
 import org.dbflute.cbean.ckey.ConditionKey;
 import org.elasticsearch.index.query.BoolQueryBuilder;
 import org.elasticsearch.index.query.FilteredQueryBuilder;
@@ -28,16 +29,17 @@ public abstract class BsDataConfigToLabelCQ extends AbstractConditionQuery {
         return "data_config_to_label";
     }
 
-    public void filtered(FilteredCall<DataConfigToLabelCQ> filteredLambda) {
+    public void filtered(FilteredCall<DataConfigToLabelCQ, DataConfigToLabelCF> filteredLambda) {
         filtered(filteredLambda, null);
     }
 
-    public void filtered(FilteredCall<DataConfigToLabelCQ> filteredLambda, ConditionOptionCall<FilteredQueryBuilder> opLambda) {
+    public void filtered(FilteredCall<DataConfigToLabelCQ, DataConfigToLabelCF> filteredLambda,
+            ConditionOptionCall<FilteredQueryBuilder> opLambda) {
         DataConfigToLabelCQ query = new DataConfigToLabelCQ();
-        filteredLambda.callback(query);
-        if (!query.queryBuilderList.isEmpty()) {
-            // TODO filter
-            FilteredQueryBuilder builder = reqFilteredQ(query.getQuery(), null);
+        DataConfigToLabelCF filter = new DataConfigToLabelCF();
+        filteredLambda.callback(query, filter);
+        if (query.hasQueries()) {
+            FilteredQueryBuilder builder = regFilteredQ(query.getQuery(), filter.getFilter());
             if (opLambda != null) {
                 opLambda.callback(builder);
             }
@@ -53,8 +55,8 @@ public abstract class BsDataConfigToLabelCQ extends AbstractConditionQuery {
         DataConfigToLabelCQ shouldQuery = new DataConfigToLabelCQ();
         DataConfigToLabelCQ mustNotQuery = new DataConfigToLabelCQ();
         boolLambda.callback(mustQuery, shouldQuery, mustNotQuery);
-        if (!mustQuery.queryBuilderList.isEmpty() || !shouldQuery.queryBuilderList.isEmpty() || !mustNotQuery.queryBuilderList.isEmpty()) {
-            BoolQueryBuilder builder = reqBoolCQ(mustQuery.queryBuilderList, shouldQuery.queryBuilderList, mustNotQuery.queryBuilderList);
+        if (mustQuery.hasQueries() || shouldQuery.hasQueries() || mustNotQuery.hasQueries()) {
+            BoolQueryBuilder builder = regBoolCQ(mustQuery.queryBuilderList, shouldQuery.queryBuilderList, mustNotQuery.queryBuilderList);
             if (opLambda != null) {
                 opLambda.callback(builder);
             }
@@ -66,29 +68,29 @@ public abstract class BsDataConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setDataConfigId_Term(String dataConfigId, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("dataConfigId", dataConfigId);
+        TermQueryBuilder builder = regTermQ("dataConfigId", dataConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setDataConfigId_Terms(Collection<String> dataConfigIdList) {
-        setDataConfigId_MatchPhrasePrefix(dataConfigIdList, null);
+        setDataConfigId_Terms(dataConfigIdList, null);
     }
 
-    public void setDataConfigId_MatchPhrasePrefix(Collection<String> dataConfigIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("dataConfigId", dataConfigIdList);
+    public void setDataConfigId_Terms(Collection<String> dataConfigIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("dataConfigId", dataConfigIdList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setDataConfigId_InScope(Collection<String> dataConfigIdList) {
-        setDataConfigId_MatchPhrasePrefix(dataConfigIdList, null);
+        setDataConfigId_Terms(dataConfigIdList, null);
     }
 
     public void setDataConfigId_InScope(Collection<String> dataConfigIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setDataConfigId_MatchPhrasePrefix(dataConfigIdList, opLambda);
+        setDataConfigId_Terms(dataConfigIdList, opLambda);
     }
 
     public void setDataConfigId_Match(String dataConfigId) {
@@ -96,7 +98,7 @@ public abstract class BsDataConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setDataConfigId_Match(String dataConfigId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("dataConfigId", dataConfigId);
+        MatchQueryBuilder builder = regMatchQ("dataConfigId", dataConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -107,7 +109,7 @@ public abstract class BsDataConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setDataConfigId_MatchPhrase(String dataConfigId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("dataConfigId", dataConfigId);
+        MatchQueryBuilder builder = regMatchPhraseQ("dataConfigId", dataConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -118,7 +120,7 @@ public abstract class BsDataConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setDataConfigId_MatchPhrasePrefix(String dataConfigId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("dataConfigId", dataConfigId);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("dataConfigId", dataConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -129,7 +131,7 @@ public abstract class BsDataConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setDataConfigId_Fuzzy(String dataConfigId, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("dataConfigId", dataConfigId);
+        FuzzyQueryBuilder builder = regFuzzyQ("dataConfigId", dataConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -140,7 +142,7 @@ public abstract class BsDataConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setDataConfigId_Prefix(String dataConfigId, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("dataConfigId", dataConfigId);
+        PrefixQueryBuilder builder = regPrefixQ("dataConfigId", dataConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -151,7 +153,7 @@ public abstract class BsDataConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setDataConfigId_GreaterThan(String dataConfigId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("dataConfigId", ConditionKey.CK_GREATER_THAN, dataConfigId);
+        RangeQueryBuilder builder = regRangeQ("dataConfigId", ConditionKey.CK_GREATER_THAN, dataConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -162,7 +164,7 @@ public abstract class BsDataConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setDataConfigId_LessThan(String dataConfigId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("dataConfigId", ConditionKey.CK_LESS_THAN, dataConfigId);
+        RangeQueryBuilder builder = regRangeQ("dataConfigId", ConditionKey.CK_LESS_THAN, dataConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -173,7 +175,7 @@ public abstract class BsDataConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setDataConfigId_GreaterEqual(String dataConfigId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("dataConfigId", ConditionKey.CK_GREATER_EQUAL, dataConfigId);
+        RangeQueryBuilder builder = regRangeQ("dataConfigId", ConditionKey.CK_GREATER_EQUAL, dataConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -184,7 +186,7 @@ public abstract class BsDataConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setDataConfigId_LessEqual(String dataConfigId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("dataConfigId", ConditionKey.CK_LESS_EQUAL, dataConfigId);
+        RangeQueryBuilder builder = regRangeQ("dataConfigId", ConditionKey.CK_LESS_EQUAL, dataConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -205,29 +207,29 @@ public abstract class BsDataConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setId_Term(String id, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("id", id);
+        TermQueryBuilder builder = regTermQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setId_Terms(Collection<String> idList) {
-        setId_MatchPhrasePrefix(idList, null);
+        setId_Terms(idList, null);
     }
 
-    public void setId_MatchPhrasePrefix(Collection<String> idList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("id", idList);
+    public void setId_Terms(Collection<String> idList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("id", idList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setId_InScope(Collection<String> idList) {
-        setId_MatchPhrasePrefix(idList, null);
+        setId_Terms(idList, null);
     }
 
     public void setId_InScope(Collection<String> idList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setId_MatchPhrasePrefix(idList, opLambda);
+        setId_Terms(idList, opLambda);
     }
 
     public void setId_Match(String id) {
@@ -235,7 +237,7 @@ public abstract class BsDataConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setId_Match(String id, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("id", id);
+        MatchQueryBuilder builder = regMatchQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -246,7 +248,7 @@ public abstract class BsDataConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setId_MatchPhrase(String id, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("id", id);
+        MatchQueryBuilder builder = regMatchPhraseQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -257,7 +259,7 @@ public abstract class BsDataConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setId_MatchPhrasePrefix(String id, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("id", id);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -268,7 +270,7 @@ public abstract class BsDataConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setId_Fuzzy(String id, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("id", id);
+        FuzzyQueryBuilder builder = regFuzzyQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -279,7 +281,7 @@ public abstract class BsDataConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setId_Prefix(String id, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("id", id);
+        PrefixQueryBuilder builder = regPrefixQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -290,7 +292,7 @@ public abstract class BsDataConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setId_GreaterThan(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_THAN, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_THAN, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -301,7 +303,7 @@ public abstract class BsDataConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setId_LessThan(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_THAN, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_THAN, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -312,7 +314,7 @@ public abstract class BsDataConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setId_GreaterEqual(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -323,7 +325,7 @@ public abstract class BsDataConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setId_LessEqual(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_EQUAL, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_EQUAL, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -344,29 +346,29 @@ public abstract class BsDataConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setLabelTypeId_Term(String labelTypeId, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("labelTypeId", labelTypeId);
+        TermQueryBuilder builder = regTermQ("labelTypeId", labelTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setLabelTypeId_Terms(Collection<String> labelTypeIdList) {
-        setLabelTypeId_MatchPhrasePrefix(labelTypeIdList, null);
+        setLabelTypeId_Terms(labelTypeIdList, null);
     }
 
-    public void setLabelTypeId_MatchPhrasePrefix(Collection<String> labelTypeIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("labelTypeId", labelTypeIdList);
+    public void setLabelTypeId_Terms(Collection<String> labelTypeIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("labelTypeId", labelTypeIdList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setLabelTypeId_InScope(Collection<String> labelTypeIdList) {
-        setLabelTypeId_MatchPhrasePrefix(labelTypeIdList, null);
+        setLabelTypeId_Terms(labelTypeIdList, null);
     }
 
     public void setLabelTypeId_InScope(Collection<String> labelTypeIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setLabelTypeId_MatchPhrasePrefix(labelTypeIdList, opLambda);
+        setLabelTypeId_Terms(labelTypeIdList, opLambda);
     }
 
     public void setLabelTypeId_Match(String labelTypeId) {
@@ -374,7 +376,7 @@ public abstract class BsDataConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setLabelTypeId_Match(String labelTypeId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("labelTypeId", labelTypeId);
+        MatchQueryBuilder builder = regMatchQ("labelTypeId", labelTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -385,7 +387,7 @@ public abstract class BsDataConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setLabelTypeId_MatchPhrase(String labelTypeId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("labelTypeId", labelTypeId);
+        MatchQueryBuilder builder = regMatchPhraseQ("labelTypeId", labelTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -396,7 +398,7 @@ public abstract class BsDataConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setLabelTypeId_MatchPhrasePrefix(String labelTypeId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("labelTypeId", labelTypeId);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("labelTypeId", labelTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -407,7 +409,7 @@ public abstract class BsDataConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setLabelTypeId_Fuzzy(String labelTypeId, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("labelTypeId", labelTypeId);
+        FuzzyQueryBuilder builder = regFuzzyQ("labelTypeId", labelTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -418,7 +420,7 @@ public abstract class BsDataConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setLabelTypeId_Prefix(String labelTypeId, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("labelTypeId", labelTypeId);
+        PrefixQueryBuilder builder = regPrefixQ("labelTypeId", labelTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -429,7 +431,7 @@ public abstract class BsDataConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setLabelTypeId_GreaterThan(String labelTypeId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("labelTypeId", ConditionKey.CK_GREATER_THAN, labelTypeId);
+        RangeQueryBuilder builder = regRangeQ("labelTypeId", ConditionKey.CK_GREATER_THAN, labelTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -440,7 +442,7 @@ public abstract class BsDataConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setLabelTypeId_LessThan(String labelTypeId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("labelTypeId", ConditionKey.CK_LESS_THAN, labelTypeId);
+        RangeQueryBuilder builder = regRangeQ("labelTypeId", ConditionKey.CK_LESS_THAN, labelTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -451,7 +453,7 @@ public abstract class BsDataConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setLabelTypeId_GreaterEqual(String labelTypeId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("labelTypeId", ConditionKey.CK_GREATER_EQUAL, labelTypeId);
+        RangeQueryBuilder builder = regRangeQ("labelTypeId", ConditionKey.CK_GREATER_EQUAL, labelTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -462,7 +464,7 @@ public abstract class BsDataConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setLabelTypeId_LessEqual(String labelTypeId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("labelTypeId", ConditionKey.CK_LESS_EQUAL, labelTypeId);
+        RangeQueryBuilder builder = regRangeQ("labelTypeId", ConditionKey.CK_LESS_EQUAL, labelTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }

src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsDataConfigToRoleCQ.java

@@ -3,6 +3,7 @@ package org.codelibs.fess.es.cbean.cq.bs;
 import java.util.Collection;
 
 import org.codelibs.fess.es.cbean.cq.DataConfigToRoleCQ;
+import org.codelibs.fess.es.cbean.cf.DataConfigToRoleCF;
 import org.dbflute.cbean.ckey.ConditionKey;
 import org.elasticsearch.index.query.BoolQueryBuilder;
 import org.elasticsearch.index.query.FilteredQueryBuilder;
@@ -28,16 +29,17 @@ public abstract class BsDataConfigToRoleCQ extends AbstractConditionQuery {
         return "data_config_to_role";
     }
 
-    public void filtered(FilteredCall<DataConfigToRoleCQ> filteredLambda) {
+    public void filtered(FilteredCall<DataConfigToRoleCQ, DataConfigToRoleCF> filteredLambda) {
         filtered(filteredLambda, null);
     }
 
-    public void filtered(FilteredCall<DataConfigToRoleCQ> filteredLambda, ConditionOptionCall<FilteredQueryBuilder> opLambda) {
+    public void filtered(FilteredCall<DataConfigToRoleCQ, DataConfigToRoleCF> filteredLambda,
+            ConditionOptionCall<FilteredQueryBuilder> opLambda) {
         DataConfigToRoleCQ query = new DataConfigToRoleCQ();
-        filteredLambda.callback(query);
-        if (!query.queryBuilderList.isEmpty()) {
-            // TODO filter
-            FilteredQueryBuilder builder = reqFilteredQ(query.getQuery(), null);
+        DataConfigToRoleCF filter = new DataConfigToRoleCF();
+        filteredLambda.callback(query, filter);
+        if (query.hasQueries()) {
+            FilteredQueryBuilder builder = regFilteredQ(query.getQuery(), filter.getFilter());
             if (opLambda != null) {
                 opLambda.callback(builder);
             }
@@ -53,8 +55,8 @@ public abstract class BsDataConfigToRoleCQ extends AbstractConditionQuery {
         DataConfigToRoleCQ shouldQuery = new DataConfigToRoleCQ();
         DataConfigToRoleCQ mustNotQuery = new DataConfigToRoleCQ();
         boolLambda.callback(mustQuery, shouldQuery, mustNotQuery);
-        if (!mustQuery.queryBuilderList.isEmpty() || !shouldQuery.queryBuilderList.isEmpty() || !mustNotQuery.queryBuilderList.isEmpty()) {
-            BoolQueryBuilder builder = reqBoolCQ(mustQuery.queryBuilderList, shouldQuery.queryBuilderList, mustNotQuery.queryBuilderList);
+        if (mustQuery.hasQueries() || shouldQuery.hasQueries() || mustNotQuery.hasQueries()) {
+            BoolQueryBuilder builder = regBoolCQ(mustQuery.queryBuilderList, shouldQuery.queryBuilderList, mustNotQuery.queryBuilderList);
             if (opLambda != null) {
                 opLambda.callback(builder);
             }
@@ -66,29 +68,29 @@ public abstract class BsDataConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setDataConfigId_Term(String dataConfigId, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("dataConfigId", dataConfigId);
+        TermQueryBuilder builder = regTermQ("dataConfigId", dataConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setDataConfigId_Terms(Collection<String> dataConfigIdList) {
-        setDataConfigId_MatchPhrasePrefix(dataConfigIdList, null);
+        setDataConfigId_Terms(dataConfigIdList, null);
     }
 
-    public void setDataConfigId_MatchPhrasePrefix(Collection<String> dataConfigIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("dataConfigId", dataConfigIdList);
+    public void setDataConfigId_Terms(Collection<String> dataConfigIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("dataConfigId", dataConfigIdList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setDataConfigId_InScope(Collection<String> dataConfigIdList) {
-        setDataConfigId_MatchPhrasePrefix(dataConfigIdList, null);
+        setDataConfigId_Terms(dataConfigIdList, null);
     }
 
     public void setDataConfigId_InScope(Collection<String> dataConfigIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setDataConfigId_MatchPhrasePrefix(dataConfigIdList, opLambda);
+        setDataConfigId_Terms(dataConfigIdList, opLambda);
     }
 
     public void setDataConfigId_Match(String dataConfigId) {
@@ -96,7 +98,7 @@ public abstract class BsDataConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setDataConfigId_Match(String dataConfigId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("dataConfigId", dataConfigId);
+        MatchQueryBuilder builder = regMatchQ("dataConfigId", dataConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -107,7 +109,7 @@ public abstract class BsDataConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setDataConfigId_MatchPhrase(String dataConfigId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("dataConfigId", dataConfigId);
+        MatchQueryBuilder builder = regMatchPhraseQ("dataConfigId", dataConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -118,7 +120,7 @@ public abstract class BsDataConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setDataConfigId_MatchPhrasePrefix(String dataConfigId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("dataConfigId", dataConfigId);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("dataConfigId", dataConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -129,7 +131,7 @@ public abstract class BsDataConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setDataConfigId_Fuzzy(String dataConfigId, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("dataConfigId", dataConfigId);
+        FuzzyQueryBuilder builder = regFuzzyQ("dataConfigId", dataConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -140,7 +142,7 @@ public abstract class BsDataConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setDataConfigId_Prefix(String dataConfigId, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("dataConfigId", dataConfigId);
+        PrefixQueryBuilder builder = regPrefixQ("dataConfigId", dataConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -151,7 +153,7 @@ public abstract class BsDataConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setDataConfigId_GreaterThan(String dataConfigId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("dataConfigId", ConditionKey.CK_GREATER_THAN, dataConfigId);
+        RangeQueryBuilder builder = regRangeQ("dataConfigId", ConditionKey.CK_GREATER_THAN, dataConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -162,7 +164,7 @@ public abstract class BsDataConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setDataConfigId_LessThan(String dataConfigId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("dataConfigId", ConditionKey.CK_LESS_THAN, dataConfigId);
+        RangeQueryBuilder builder = regRangeQ("dataConfigId", ConditionKey.CK_LESS_THAN, dataConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -173,7 +175,7 @@ public abstract class BsDataConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setDataConfigId_GreaterEqual(String dataConfigId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("dataConfigId", ConditionKey.CK_GREATER_EQUAL, dataConfigId);
+        RangeQueryBuilder builder = regRangeQ("dataConfigId", ConditionKey.CK_GREATER_EQUAL, dataConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -184,7 +186,7 @@ public abstract class BsDataConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setDataConfigId_LessEqual(String dataConfigId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("dataConfigId", ConditionKey.CK_LESS_EQUAL, dataConfigId);
+        RangeQueryBuilder builder = regRangeQ("dataConfigId", ConditionKey.CK_LESS_EQUAL, dataConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -205,29 +207,29 @@ public abstract class BsDataConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setId_Term(String id, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("id", id);
+        TermQueryBuilder builder = regTermQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setId_Terms(Collection<String> idList) {
-        setId_MatchPhrasePrefix(idList, null);
+        setId_Terms(idList, null);
     }
 
-    public void setId_MatchPhrasePrefix(Collection<String> idList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("id", idList);
+    public void setId_Terms(Collection<String> idList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("id", idList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setId_InScope(Collection<String> idList) {
-        setId_MatchPhrasePrefix(idList, null);
+        setId_Terms(idList, null);
     }
 
     public void setId_InScope(Collection<String> idList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setId_MatchPhrasePrefix(idList, opLambda);
+        setId_Terms(idList, opLambda);
     }
 
     public void setId_Match(String id) {
@@ -235,7 +237,7 @@ public abstract class BsDataConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setId_Match(String id, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("id", id);
+        MatchQueryBuilder builder = regMatchQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -246,7 +248,7 @@ public abstract class BsDataConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setId_MatchPhrase(String id, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("id", id);
+        MatchQueryBuilder builder = regMatchPhraseQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -257,7 +259,7 @@ public abstract class BsDataConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setId_MatchPhrasePrefix(String id, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("id", id);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -268,7 +270,7 @@ public abstract class BsDataConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setId_Fuzzy(String id, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("id", id);
+        FuzzyQueryBuilder builder = regFuzzyQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -279,7 +281,7 @@ public abstract class BsDataConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setId_Prefix(String id, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("id", id);
+        PrefixQueryBuilder builder = regPrefixQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -290,7 +292,7 @@ public abstract class BsDataConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setId_GreaterThan(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_THAN, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_THAN, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -301,7 +303,7 @@ public abstract class BsDataConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setId_LessThan(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_THAN, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_THAN, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -312,7 +314,7 @@ public abstract class BsDataConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setId_GreaterEqual(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -323,7 +325,7 @@ public abstract class BsDataConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setId_LessEqual(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_EQUAL, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_EQUAL, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -344,29 +346,29 @@ public abstract class BsDataConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setRoleTypeId_Term(String roleTypeId, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("roleTypeId", roleTypeId);
+        TermQueryBuilder builder = regTermQ("roleTypeId", roleTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setRoleTypeId_Terms(Collection<String> roleTypeIdList) {
-        setRoleTypeId_MatchPhrasePrefix(roleTypeIdList, null);
+        setRoleTypeId_Terms(roleTypeIdList, null);
     }
 
-    public void setRoleTypeId_MatchPhrasePrefix(Collection<String> roleTypeIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("roleTypeId", roleTypeIdList);
+    public void setRoleTypeId_Terms(Collection<String> roleTypeIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("roleTypeId", roleTypeIdList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setRoleTypeId_InScope(Collection<String> roleTypeIdList) {
-        setRoleTypeId_MatchPhrasePrefix(roleTypeIdList, null);
+        setRoleTypeId_Terms(roleTypeIdList, null);
     }
 
     public void setRoleTypeId_InScope(Collection<String> roleTypeIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setRoleTypeId_MatchPhrasePrefix(roleTypeIdList, opLambda);
+        setRoleTypeId_Terms(roleTypeIdList, opLambda);
     }
 
     public void setRoleTypeId_Match(String roleTypeId) {
@@ -374,7 +376,7 @@ public abstract class BsDataConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setRoleTypeId_Match(String roleTypeId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("roleTypeId", roleTypeId);
+        MatchQueryBuilder builder = regMatchQ("roleTypeId", roleTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -385,7 +387,7 @@ public abstract class BsDataConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setRoleTypeId_MatchPhrase(String roleTypeId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("roleTypeId", roleTypeId);
+        MatchQueryBuilder builder = regMatchPhraseQ("roleTypeId", roleTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -396,7 +398,7 @@ public abstract class BsDataConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setRoleTypeId_MatchPhrasePrefix(String roleTypeId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("roleTypeId", roleTypeId);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("roleTypeId", roleTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -407,7 +409,7 @@ public abstract class BsDataConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setRoleTypeId_Fuzzy(String roleTypeId, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("roleTypeId", roleTypeId);
+        FuzzyQueryBuilder builder = regFuzzyQ("roleTypeId", roleTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -418,7 +420,7 @@ public abstract class BsDataConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setRoleTypeId_Prefix(String roleTypeId, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("roleTypeId", roleTypeId);
+        PrefixQueryBuilder builder = regPrefixQ("roleTypeId", roleTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -429,7 +431,7 @@ public abstract class BsDataConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setRoleTypeId_GreaterThan(String roleTypeId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("roleTypeId", ConditionKey.CK_GREATER_THAN, roleTypeId);
+        RangeQueryBuilder builder = regRangeQ("roleTypeId", ConditionKey.CK_GREATER_THAN, roleTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -440,7 +442,7 @@ public abstract class BsDataConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setRoleTypeId_LessThan(String roleTypeId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("roleTypeId", ConditionKey.CK_LESS_THAN, roleTypeId);
+        RangeQueryBuilder builder = regRangeQ("roleTypeId", ConditionKey.CK_LESS_THAN, roleTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -451,7 +453,7 @@ public abstract class BsDataConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setRoleTypeId_GreaterEqual(String roleTypeId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("roleTypeId", ConditionKey.CK_GREATER_EQUAL, roleTypeId);
+        RangeQueryBuilder builder = regRangeQ("roleTypeId", ConditionKey.CK_GREATER_EQUAL, roleTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -462,7 +464,7 @@ public abstract class BsDataConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setRoleTypeId_LessEqual(String roleTypeId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("roleTypeId", ConditionKey.CK_LESS_EQUAL, roleTypeId);
+        RangeQueryBuilder builder = regRangeQ("roleTypeId", ConditionKey.CK_LESS_EQUAL, roleTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }

src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsFailureUrlCQ.java

@@ -3,6 +3,7 @@ package org.codelibs.fess.es.cbean.cq.bs;
 import java.util.Collection;
 
 import org.codelibs.fess.es.cbean.cq.FailureUrlCQ;
+import org.codelibs.fess.es.cbean.cf.FailureUrlCF;
 import org.dbflute.cbean.ckey.ConditionKey;
 import org.elasticsearch.index.query.BoolQueryBuilder;
 import org.elasticsearch.index.query.FilteredQueryBuilder;
@@ -28,16 +29,16 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
         return "failure_url";
     }
 
-    public void filtered(FilteredCall<FailureUrlCQ> filteredLambda) {
+    public void filtered(FilteredCall<FailureUrlCQ, FailureUrlCF> filteredLambda) {
         filtered(filteredLambda, null);
     }
 
-    public void filtered(FilteredCall<FailureUrlCQ> filteredLambda, ConditionOptionCall<FilteredQueryBuilder> opLambda) {
+    public void filtered(FilteredCall<FailureUrlCQ, FailureUrlCF> filteredLambda, ConditionOptionCall<FilteredQueryBuilder> opLambda) {
         FailureUrlCQ query = new FailureUrlCQ();
-        filteredLambda.callback(query);
-        if (!query.queryBuilderList.isEmpty()) {
-            // TODO filter
-            FilteredQueryBuilder builder = reqFilteredQ(query.getQuery(), null);
+        FailureUrlCF filter = new FailureUrlCF();
+        filteredLambda.callback(query, filter);
+        if (query.hasQueries()) {
+            FilteredQueryBuilder builder = regFilteredQ(query.getQuery(), filter.getFilter());
             if (opLambda != null) {
                 opLambda.callback(builder);
             }
@@ -53,8 +54,8 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
         FailureUrlCQ shouldQuery = new FailureUrlCQ();
         FailureUrlCQ mustNotQuery = new FailureUrlCQ();
         boolLambda.callback(mustQuery, shouldQuery, mustNotQuery);
-        if (!mustQuery.queryBuilderList.isEmpty() || !shouldQuery.queryBuilderList.isEmpty() || !mustNotQuery.queryBuilderList.isEmpty()) {
-            BoolQueryBuilder builder = reqBoolCQ(mustQuery.queryBuilderList, shouldQuery.queryBuilderList, mustNotQuery.queryBuilderList);
+        if (mustQuery.hasQueries() || shouldQuery.hasQueries() || mustNotQuery.hasQueries()) {
+            BoolQueryBuilder builder = regBoolCQ(mustQuery.queryBuilderList, shouldQuery.queryBuilderList, mustNotQuery.queryBuilderList);
             if (opLambda != null) {
                 opLambda.callback(builder);
             }
@@ -66,29 +67,29 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setConfigId_Term(String configId, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("configId", configId);
+        TermQueryBuilder builder = regTermQ("configId", configId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setConfigId_Terms(Collection<String> configIdList) {
-        setConfigId_MatchPhrasePrefix(configIdList, null);
+        setConfigId_Terms(configIdList, null);
     }
 
-    public void setConfigId_MatchPhrasePrefix(Collection<String> configIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("configId", configIdList);
+    public void setConfigId_Terms(Collection<String> configIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("configId", configIdList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setConfigId_InScope(Collection<String> configIdList) {
-        setConfigId_MatchPhrasePrefix(configIdList, null);
+        setConfigId_Terms(configIdList, null);
     }
 
     public void setConfigId_InScope(Collection<String> configIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setConfigId_MatchPhrasePrefix(configIdList, opLambda);
+        setConfigId_Terms(configIdList, opLambda);
     }
 
     public void setConfigId_Match(String configId) {
@@ -96,7 +97,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setConfigId_Match(String configId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("configId", configId);
+        MatchQueryBuilder builder = regMatchQ("configId", configId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -107,7 +108,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setConfigId_MatchPhrase(String configId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("configId", configId);
+        MatchQueryBuilder builder = regMatchPhraseQ("configId", configId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -118,7 +119,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setConfigId_MatchPhrasePrefix(String configId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("configId", configId);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("configId", configId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -129,7 +130,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setConfigId_Fuzzy(String configId, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("configId", configId);
+        FuzzyQueryBuilder builder = regFuzzyQ("configId", configId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -140,7 +141,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setConfigId_Prefix(String configId, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("configId", configId);
+        PrefixQueryBuilder builder = regPrefixQ("configId", configId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -151,7 +152,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setConfigId_GreaterThan(String configId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("configId", ConditionKey.CK_GREATER_THAN, configId);
+        RangeQueryBuilder builder = regRangeQ("configId", ConditionKey.CK_GREATER_THAN, configId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -162,7 +163,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setConfigId_LessThan(String configId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("configId", ConditionKey.CK_LESS_THAN, configId);
+        RangeQueryBuilder builder = regRangeQ("configId", ConditionKey.CK_LESS_THAN, configId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -173,7 +174,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setConfigId_GreaterEqual(String configId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("configId", ConditionKey.CK_GREATER_EQUAL, configId);
+        RangeQueryBuilder builder = regRangeQ("configId", ConditionKey.CK_GREATER_EQUAL, configId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -184,7 +185,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setConfigId_LessEqual(String configId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("configId", ConditionKey.CK_LESS_EQUAL, configId);
+        RangeQueryBuilder builder = regRangeQ("configId", ConditionKey.CK_LESS_EQUAL, configId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -205,29 +206,29 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setErrorCount_Term(Integer errorCount, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("errorCount", errorCount);
+        TermQueryBuilder builder = regTermQ("errorCount", errorCount);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setErrorCount_Terms(Collection<Integer> errorCountList) {
-        setErrorCount_MatchPhrasePrefix(errorCountList, null);
+        setErrorCount_Terms(errorCountList, null);
     }
 
-    public void setErrorCount_MatchPhrasePrefix(Collection<Integer> errorCountList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("errorCount", errorCountList);
+    public void setErrorCount_Terms(Collection<Integer> errorCountList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("errorCount", errorCountList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setErrorCount_InScope(Collection<Integer> errorCountList) {
-        setErrorCount_MatchPhrasePrefix(errorCountList, null);
+        setErrorCount_Terms(errorCountList, null);
     }
 
     public void setErrorCount_InScope(Collection<Integer> errorCountList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setErrorCount_MatchPhrasePrefix(errorCountList, opLambda);
+        setErrorCount_Terms(errorCountList, opLambda);
     }
 
     public void setErrorCount_Match(Integer errorCount) {
@@ -235,7 +236,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setErrorCount_Match(Integer errorCount, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("errorCount", errorCount);
+        MatchQueryBuilder builder = regMatchQ("errorCount", errorCount);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -246,7 +247,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setErrorCount_MatchPhrase(Integer errorCount, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("errorCount", errorCount);
+        MatchQueryBuilder builder = regMatchPhraseQ("errorCount", errorCount);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -257,7 +258,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setErrorCount_MatchPhrasePrefix(Integer errorCount, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("errorCount", errorCount);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("errorCount", errorCount);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -268,7 +269,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setErrorCount_Fuzzy(Integer errorCount, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("errorCount", errorCount);
+        FuzzyQueryBuilder builder = regFuzzyQ("errorCount", errorCount);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -279,7 +280,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setErrorCount_GreaterThan(Integer errorCount, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("errorCount", ConditionKey.CK_GREATER_THAN, errorCount);
+        RangeQueryBuilder builder = regRangeQ("errorCount", ConditionKey.CK_GREATER_THAN, errorCount);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -290,7 +291,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setErrorCount_LessThan(Integer errorCount, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("errorCount", ConditionKey.CK_LESS_THAN, errorCount);
+        RangeQueryBuilder builder = regRangeQ("errorCount", ConditionKey.CK_LESS_THAN, errorCount);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -301,7 +302,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setErrorCount_GreaterEqual(Integer errorCount, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("errorCount", ConditionKey.CK_GREATER_EQUAL, errorCount);
+        RangeQueryBuilder builder = regRangeQ("errorCount", ConditionKey.CK_GREATER_EQUAL, errorCount);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -312,7 +313,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setErrorCount_LessEqual(Integer errorCount, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("errorCount", ConditionKey.CK_LESS_EQUAL, errorCount);
+        RangeQueryBuilder builder = regRangeQ("errorCount", ConditionKey.CK_LESS_EQUAL, errorCount);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -333,29 +334,29 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setErrorLog_Term(String errorLog, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("errorLog", errorLog);
+        TermQueryBuilder builder = regTermQ("errorLog", errorLog);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setErrorLog_Terms(Collection<String> errorLogList) {
-        setErrorLog_MatchPhrasePrefix(errorLogList, null);
+        setErrorLog_Terms(errorLogList, null);
     }
 
-    public void setErrorLog_MatchPhrasePrefix(Collection<String> errorLogList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("errorLog", errorLogList);
+    public void setErrorLog_Terms(Collection<String> errorLogList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("errorLog", errorLogList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setErrorLog_InScope(Collection<String> errorLogList) {
-        setErrorLog_MatchPhrasePrefix(errorLogList, null);
+        setErrorLog_Terms(errorLogList, null);
     }
 
     public void setErrorLog_InScope(Collection<String> errorLogList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setErrorLog_MatchPhrasePrefix(errorLogList, opLambda);
+        setErrorLog_Terms(errorLogList, opLambda);
     }
 
     public void setErrorLog_Match(String errorLog) {
@@ -363,7 +364,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setErrorLog_Match(String errorLog, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("errorLog", errorLog);
+        MatchQueryBuilder builder = regMatchQ("errorLog", errorLog);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -374,7 +375,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setErrorLog_MatchPhrase(String errorLog, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("errorLog", errorLog);
+        MatchQueryBuilder builder = regMatchPhraseQ("errorLog", errorLog);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -385,7 +386,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setErrorLog_MatchPhrasePrefix(String errorLog, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("errorLog", errorLog);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("errorLog", errorLog);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -396,7 +397,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setErrorLog_Fuzzy(String errorLog, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("errorLog", errorLog);
+        FuzzyQueryBuilder builder = regFuzzyQ("errorLog", errorLog);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -407,7 +408,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setErrorLog_Prefix(String errorLog, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("errorLog", errorLog);
+        PrefixQueryBuilder builder = regPrefixQ("errorLog", errorLog);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -418,7 +419,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setErrorLog_GreaterThan(String errorLog, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("errorLog", ConditionKey.CK_GREATER_THAN, errorLog);
+        RangeQueryBuilder builder = regRangeQ("errorLog", ConditionKey.CK_GREATER_THAN, errorLog);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -429,7 +430,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setErrorLog_LessThan(String errorLog, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("errorLog", ConditionKey.CK_LESS_THAN, errorLog);
+        RangeQueryBuilder builder = regRangeQ("errorLog", ConditionKey.CK_LESS_THAN, errorLog);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -440,7 +441,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setErrorLog_GreaterEqual(String errorLog, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("errorLog", ConditionKey.CK_GREATER_EQUAL, errorLog);
+        RangeQueryBuilder builder = regRangeQ("errorLog", ConditionKey.CK_GREATER_EQUAL, errorLog);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -451,7 +452,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setErrorLog_LessEqual(String errorLog, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("errorLog", ConditionKey.CK_LESS_EQUAL, errorLog);
+        RangeQueryBuilder builder = regRangeQ("errorLog", ConditionKey.CK_LESS_EQUAL, errorLog);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -472,29 +473,29 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setErrorName_Term(String errorName, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("errorName", errorName);
+        TermQueryBuilder builder = regTermQ("errorName", errorName);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setErrorName_Terms(Collection<String> errorNameList) {
-        setErrorName_MatchPhrasePrefix(errorNameList, null);
+        setErrorName_Terms(errorNameList, null);
     }
 
-    public void setErrorName_MatchPhrasePrefix(Collection<String> errorNameList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("errorName", errorNameList);
+    public void setErrorName_Terms(Collection<String> errorNameList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("errorName", errorNameList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setErrorName_InScope(Collection<String> errorNameList) {
-        setErrorName_MatchPhrasePrefix(errorNameList, null);
+        setErrorName_Terms(errorNameList, null);
     }
 
     public void setErrorName_InScope(Collection<String> errorNameList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setErrorName_MatchPhrasePrefix(errorNameList, opLambda);
+        setErrorName_Terms(errorNameList, opLambda);
     }
 
     public void setErrorName_Match(String errorName) {
@@ -502,7 +503,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setErrorName_Match(String errorName, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("errorName", errorName);
+        MatchQueryBuilder builder = regMatchQ("errorName", errorName);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -513,7 +514,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setErrorName_MatchPhrase(String errorName, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("errorName", errorName);
+        MatchQueryBuilder builder = regMatchPhraseQ("errorName", errorName);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -524,7 +525,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setErrorName_MatchPhrasePrefix(String errorName, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("errorName", errorName);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("errorName", errorName);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -535,7 +536,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setErrorName_Fuzzy(String errorName, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("errorName", errorName);
+        FuzzyQueryBuilder builder = regFuzzyQ("errorName", errorName);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -546,7 +547,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setErrorName_Prefix(String errorName, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("errorName", errorName);
+        PrefixQueryBuilder builder = regPrefixQ("errorName", errorName);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -557,7 +558,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setErrorName_GreaterThan(String errorName, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("errorName", ConditionKey.CK_GREATER_THAN, errorName);
+        RangeQueryBuilder builder = regRangeQ("errorName", ConditionKey.CK_GREATER_THAN, errorName);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -568,7 +569,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setErrorName_LessThan(String errorName, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("errorName", ConditionKey.CK_LESS_THAN, errorName);
+        RangeQueryBuilder builder = regRangeQ("errorName", ConditionKey.CK_LESS_THAN, errorName);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -579,7 +580,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setErrorName_GreaterEqual(String errorName, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("errorName", ConditionKey.CK_GREATER_EQUAL, errorName);
+        RangeQueryBuilder builder = regRangeQ("errorName", ConditionKey.CK_GREATER_EQUAL, errorName);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -590,7 +591,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setErrorName_LessEqual(String errorName, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("errorName", ConditionKey.CK_LESS_EQUAL, errorName);
+        RangeQueryBuilder builder = regRangeQ("errorName", ConditionKey.CK_LESS_EQUAL, errorName);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -611,29 +612,29 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setId_Term(String id, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("id", id);
+        TermQueryBuilder builder = regTermQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setId_Terms(Collection<String> idList) {
-        setId_MatchPhrasePrefix(idList, null);
+        setId_Terms(idList, null);
     }
 
-    public void setId_MatchPhrasePrefix(Collection<String> idList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("id", idList);
+    public void setId_Terms(Collection<String> idList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("id", idList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setId_InScope(Collection<String> idList) {
-        setId_MatchPhrasePrefix(idList, null);
+        setId_Terms(idList, null);
     }
 
     public void setId_InScope(Collection<String> idList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setId_MatchPhrasePrefix(idList, opLambda);
+        setId_Terms(idList, opLambda);
     }
 
     public void setId_Match(String id) {
@@ -641,7 +642,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setId_Match(String id, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("id", id);
+        MatchQueryBuilder builder = regMatchQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -652,7 +653,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setId_MatchPhrase(String id, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("id", id);
+        MatchQueryBuilder builder = regMatchPhraseQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -663,7 +664,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setId_MatchPhrasePrefix(String id, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("id", id);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -674,7 +675,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setId_Fuzzy(String id, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("id", id);
+        FuzzyQueryBuilder builder = regFuzzyQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -685,7 +686,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setId_Prefix(String id, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("id", id);
+        PrefixQueryBuilder builder = regPrefixQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -696,7 +697,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setId_GreaterThan(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_THAN, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_THAN, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -707,7 +708,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setId_LessThan(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_THAN, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_THAN, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -718,7 +719,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setId_GreaterEqual(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -729,7 +730,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setId_LessEqual(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_EQUAL, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_EQUAL, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -750,29 +751,29 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setLastAccessTime_Term(Long lastAccessTime, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("lastAccessTime", lastAccessTime);
+        TermQueryBuilder builder = regTermQ("lastAccessTime", lastAccessTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setLastAccessTime_Terms(Collection<Long> lastAccessTimeList) {
-        setLastAccessTime_MatchPhrasePrefix(lastAccessTimeList, null);
+        setLastAccessTime_Terms(lastAccessTimeList, null);
     }
 
-    public void setLastAccessTime_MatchPhrasePrefix(Collection<Long> lastAccessTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("lastAccessTime", lastAccessTimeList);
+    public void setLastAccessTime_Terms(Collection<Long> lastAccessTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("lastAccessTime", lastAccessTimeList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setLastAccessTime_InScope(Collection<Long> lastAccessTimeList) {
-        setLastAccessTime_MatchPhrasePrefix(lastAccessTimeList, null);
+        setLastAccessTime_Terms(lastAccessTimeList, null);
     }
 
     public void setLastAccessTime_InScope(Collection<Long> lastAccessTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setLastAccessTime_MatchPhrasePrefix(lastAccessTimeList, opLambda);
+        setLastAccessTime_Terms(lastAccessTimeList, opLambda);
     }
 
     public void setLastAccessTime_Match(Long lastAccessTime) {
@@ -780,7 +781,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setLastAccessTime_Match(Long lastAccessTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("lastAccessTime", lastAccessTime);
+        MatchQueryBuilder builder = regMatchQ("lastAccessTime", lastAccessTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -791,7 +792,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setLastAccessTime_MatchPhrase(Long lastAccessTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("lastAccessTime", lastAccessTime);
+        MatchQueryBuilder builder = regMatchPhraseQ("lastAccessTime", lastAccessTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -802,7 +803,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setLastAccessTime_MatchPhrasePrefix(Long lastAccessTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("lastAccessTime", lastAccessTime);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("lastAccessTime", lastAccessTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -813,7 +814,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setLastAccessTime_Fuzzy(Long lastAccessTime, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("lastAccessTime", lastAccessTime);
+        FuzzyQueryBuilder builder = regFuzzyQ("lastAccessTime", lastAccessTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -824,7 +825,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setLastAccessTime_GreaterThan(Long lastAccessTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("lastAccessTime", ConditionKey.CK_GREATER_THAN, lastAccessTime);
+        RangeQueryBuilder builder = regRangeQ("lastAccessTime", ConditionKey.CK_GREATER_THAN, lastAccessTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -835,7 +836,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setLastAccessTime_LessThan(Long lastAccessTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("lastAccessTime", ConditionKey.CK_LESS_THAN, lastAccessTime);
+        RangeQueryBuilder builder = regRangeQ("lastAccessTime", ConditionKey.CK_LESS_THAN, lastAccessTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -846,7 +847,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setLastAccessTime_GreaterEqual(Long lastAccessTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("lastAccessTime", ConditionKey.CK_GREATER_EQUAL, lastAccessTime);
+        RangeQueryBuilder builder = regRangeQ("lastAccessTime", ConditionKey.CK_GREATER_EQUAL, lastAccessTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -857,7 +858,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setLastAccessTime_LessEqual(Long lastAccessTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("lastAccessTime", ConditionKey.CK_LESS_EQUAL, lastAccessTime);
+        RangeQueryBuilder builder = regRangeQ("lastAccessTime", ConditionKey.CK_LESS_EQUAL, lastAccessTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -878,29 +879,29 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setThreadName_Term(String threadName, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("threadName", threadName);
+        TermQueryBuilder builder = regTermQ("threadName", threadName);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setThreadName_Terms(Collection<String> threadNameList) {
-        setThreadName_MatchPhrasePrefix(threadNameList, null);
+        setThreadName_Terms(threadNameList, null);
     }
 
-    public void setThreadName_MatchPhrasePrefix(Collection<String> threadNameList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("threadName", threadNameList);
+    public void setThreadName_Terms(Collection<String> threadNameList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("threadName", threadNameList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setThreadName_InScope(Collection<String> threadNameList) {
-        setThreadName_MatchPhrasePrefix(threadNameList, null);
+        setThreadName_Terms(threadNameList, null);
     }
 
     public void setThreadName_InScope(Collection<String> threadNameList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setThreadName_MatchPhrasePrefix(threadNameList, opLambda);
+        setThreadName_Terms(threadNameList, opLambda);
     }
 
     public void setThreadName_Match(String threadName) {
@@ -908,7 +909,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setThreadName_Match(String threadName, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("threadName", threadName);
+        MatchQueryBuilder builder = regMatchQ("threadName", threadName);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -919,7 +920,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setThreadName_MatchPhrase(String threadName, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("threadName", threadName);
+        MatchQueryBuilder builder = regMatchPhraseQ("threadName", threadName);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -930,7 +931,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setThreadName_MatchPhrasePrefix(String threadName, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("threadName", threadName);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("threadName", threadName);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -941,7 +942,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setThreadName_Fuzzy(String threadName, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("threadName", threadName);
+        FuzzyQueryBuilder builder = regFuzzyQ("threadName", threadName);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -952,7 +953,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setThreadName_Prefix(String threadName, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("threadName", threadName);
+        PrefixQueryBuilder builder = regPrefixQ("threadName", threadName);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -963,7 +964,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setThreadName_GreaterThan(String threadName, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("threadName", ConditionKey.CK_GREATER_THAN, threadName);
+        RangeQueryBuilder builder = regRangeQ("threadName", ConditionKey.CK_GREATER_THAN, threadName);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -974,7 +975,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setThreadName_LessThan(String threadName, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("threadName", ConditionKey.CK_LESS_THAN, threadName);
+        RangeQueryBuilder builder = regRangeQ("threadName", ConditionKey.CK_LESS_THAN, threadName);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -985,7 +986,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setThreadName_GreaterEqual(String threadName, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("threadName", ConditionKey.CK_GREATER_EQUAL, threadName);
+        RangeQueryBuilder builder = regRangeQ("threadName", ConditionKey.CK_GREATER_EQUAL, threadName);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -996,7 +997,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setThreadName_LessEqual(String threadName, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("threadName", ConditionKey.CK_LESS_EQUAL, threadName);
+        RangeQueryBuilder builder = regRangeQ("threadName", ConditionKey.CK_LESS_EQUAL, threadName);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1017,29 +1018,29 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setUrl_Term(String url, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("url", url);
+        TermQueryBuilder builder = regTermQ("url", url);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setUrl_Terms(Collection<String> urlList) {
-        setUrl_MatchPhrasePrefix(urlList, null);
+        setUrl_Terms(urlList, null);
     }
 
-    public void setUrl_MatchPhrasePrefix(Collection<String> urlList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("url", urlList);
+    public void setUrl_Terms(Collection<String> urlList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("url", urlList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setUrl_InScope(Collection<String> urlList) {
-        setUrl_MatchPhrasePrefix(urlList, null);
+        setUrl_Terms(urlList, null);
     }
 
     public void setUrl_InScope(Collection<String> urlList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setUrl_MatchPhrasePrefix(urlList, opLambda);
+        setUrl_Terms(urlList, opLambda);
     }
 
     public void setUrl_Match(String url) {
@@ -1047,7 +1048,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setUrl_Match(String url, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("url", url);
+        MatchQueryBuilder builder = regMatchQ("url", url);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1058,7 +1059,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setUrl_MatchPhrase(String url, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("url", url);
+        MatchQueryBuilder builder = regMatchPhraseQ("url", url);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1069,7 +1070,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setUrl_MatchPhrasePrefix(String url, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("url", url);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("url", url);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1080,7 +1081,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setUrl_Fuzzy(String url, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("url", url);
+        FuzzyQueryBuilder builder = regFuzzyQ("url", url);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1091,7 +1092,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setUrl_Prefix(String url, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("url", url);
+        PrefixQueryBuilder builder = regPrefixQ("url", url);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1102,7 +1103,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setUrl_GreaterThan(String url, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("url", ConditionKey.CK_GREATER_THAN, url);
+        RangeQueryBuilder builder = regRangeQ("url", ConditionKey.CK_GREATER_THAN, url);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1113,7 +1114,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setUrl_LessThan(String url, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("url", ConditionKey.CK_LESS_THAN, url);
+        RangeQueryBuilder builder = regRangeQ("url", ConditionKey.CK_LESS_THAN, url);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1124,7 +1125,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setUrl_GreaterEqual(String url, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("url", ConditionKey.CK_GREATER_EQUAL, url);
+        RangeQueryBuilder builder = regRangeQ("url", ConditionKey.CK_GREATER_EQUAL, url);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1135,7 +1136,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery {
     }
 
     public void setUrl_LessEqual(String url, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("url", ConditionKey.CK_LESS_EQUAL, url);
+        RangeQueryBuilder builder = regRangeQ("url", ConditionKey.CK_LESS_EQUAL, url);
         if (opLambda != null) {
             opLambda.callback(builder);
         }

src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsFavoriteLogCQ.java

@@ -3,6 +3,7 @@ package org.codelibs.fess.es.cbean.cq.bs;
 import java.util.Collection;
 
 import org.codelibs.fess.es.cbean.cq.FavoriteLogCQ;
+import org.codelibs.fess.es.cbean.cf.FavoriteLogCF;
 import org.dbflute.cbean.ckey.ConditionKey;
 import org.elasticsearch.index.query.BoolQueryBuilder;
 import org.elasticsearch.index.query.FilteredQueryBuilder;
@@ -28,16 +29,16 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery {
         return "favorite_log";
     }
 
-    public void filtered(FilteredCall<FavoriteLogCQ> filteredLambda) {
+    public void filtered(FilteredCall<FavoriteLogCQ, FavoriteLogCF> filteredLambda) {
         filtered(filteredLambda, null);
     }
 
-    public void filtered(FilteredCall<FavoriteLogCQ> filteredLambda, ConditionOptionCall<FilteredQueryBuilder> opLambda) {
+    public void filtered(FilteredCall<FavoriteLogCQ, FavoriteLogCF> filteredLambda, ConditionOptionCall<FilteredQueryBuilder> opLambda) {
         FavoriteLogCQ query = new FavoriteLogCQ();
-        filteredLambda.callback(query);
-        if (!query.queryBuilderList.isEmpty()) {
-            // TODO filter
-            FilteredQueryBuilder builder = reqFilteredQ(query.getQuery(), null);
+        FavoriteLogCF filter = new FavoriteLogCF();
+        filteredLambda.callback(query, filter);
+        if (query.hasQueries()) {
+            FilteredQueryBuilder builder = regFilteredQ(query.getQuery(), filter.getFilter());
             if (opLambda != null) {
                 opLambda.callback(builder);
             }
@@ -53,8 +54,8 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery {
         FavoriteLogCQ shouldQuery = new FavoriteLogCQ();
         FavoriteLogCQ mustNotQuery = new FavoriteLogCQ();
         boolLambda.callback(mustQuery, shouldQuery, mustNotQuery);
-        if (!mustQuery.queryBuilderList.isEmpty() || !shouldQuery.queryBuilderList.isEmpty() || !mustNotQuery.queryBuilderList.isEmpty()) {
-            BoolQueryBuilder builder = reqBoolCQ(mustQuery.queryBuilderList, shouldQuery.queryBuilderList, mustNotQuery.queryBuilderList);
+        if (mustQuery.hasQueries() || shouldQuery.hasQueries() || mustNotQuery.hasQueries()) {
+            BoolQueryBuilder builder = regBoolCQ(mustQuery.queryBuilderList, shouldQuery.queryBuilderList, mustNotQuery.queryBuilderList);
             if (opLambda != null) {
                 opLambda.callback(builder);
             }
@@ -66,29 +67,29 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_Term(Long createdTime, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("createdTime", createdTime);
+        TermQueryBuilder builder = regTermQ("createdTime", createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setCreatedTime_Terms(Collection<Long> createdTimeList) {
-        setCreatedTime_MatchPhrasePrefix(createdTimeList, null);
+        setCreatedTime_Terms(createdTimeList, null);
     }
 
-    public void setCreatedTime_MatchPhrasePrefix(Collection<Long> createdTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("createdTime", createdTimeList);
+    public void setCreatedTime_Terms(Collection<Long> createdTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("createdTime", createdTimeList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setCreatedTime_InScope(Collection<Long> createdTimeList) {
-        setCreatedTime_MatchPhrasePrefix(createdTimeList, null);
+        setCreatedTime_Terms(createdTimeList, null);
     }
 
     public void setCreatedTime_InScope(Collection<Long> createdTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setCreatedTime_MatchPhrasePrefix(createdTimeList, opLambda);
+        setCreatedTime_Terms(createdTimeList, opLambda);
     }
 
     public void setCreatedTime_Match(Long createdTime) {
@@ -96,7 +97,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_Match(Long createdTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("createdTime", createdTime);
+        MatchQueryBuilder builder = regMatchQ("createdTime", createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -107,7 +108,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_MatchPhrase(Long createdTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("createdTime", createdTime);
+        MatchQueryBuilder builder = regMatchPhraseQ("createdTime", createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -118,7 +119,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_MatchPhrasePrefix(Long createdTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("createdTime", createdTime);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("createdTime", createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -129,7 +130,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_Fuzzy(Long createdTime, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("createdTime", createdTime);
+        FuzzyQueryBuilder builder = regFuzzyQ("createdTime", createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -140,7 +141,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_GreaterThan(Long createdTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_GREATER_THAN, createdTime);
+        RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_GREATER_THAN, createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -151,7 +152,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_LessThan(Long createdTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_LESS_THAN, createdTime);
+        RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_LESS_THAN, createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -162,7 +163,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_GreaterEqual(Long createdTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime);
+        RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -173,7 +174,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_LessEqual(Long createdTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime);
+        RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -194,29 +195,29 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery {
     }
 
     public void setId_Term(String id, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("id", id);
+        TermQueryBuilder builder = regTermQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setId_Terms(Collection<String> idList) {
-        setId_MatchPhrasePrefix(idList, null);
+        setId_Terms(idList, null);
     }
 
-    public void setId_MatchPhrasePrefix(Collection<String> idList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("id", idList);
+    public void setId_Terms(Collection<String> idList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("id", idList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setId_InScope(Collection<String> idList) {
-        setId_MatchPhrasePrefix(idList, null);
+        setId_Terms(idList, null);
     }
 
     public void setId_InScope(Collection<String> idList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setId_MatchPhrasePrefix(idList, opLambda);
+        setId_Terms(idList, opLambda);
     }
 
     public void setId_Match(String id) {
@@ -224,7 +225,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery {
     }
 
     public void setId_Match(String id, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("id", id);
+        MatchQueryBuilder builder = regMatchQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -235,7 +236,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery {
     }
 
     public void setId_MatchPhrase(String id, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("id", id);
+        MatchQueryBuilder builder = regMatchPhraseQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -246,7 +247,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery {
     }
 
     public void setId_MatchPhrasePrefix(String id, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("id", id);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -257,7 +258,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery {
     }
 
     public void setId_Fuzzy(String id, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("id", id);
+        FuzzyQueryBuilder builder = regFuzzyQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -268,7 +269,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery {
     }
 
     public void setId_Prefix(String id, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("id", id);
+        PrefixQueryBuilder builder = regPrefixQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -279,7 +280,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery {
     }
 
     public void setId_GreaterThan(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_THAN, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_THAN, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -290,7 +291,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery {
     }
 
     public void setId_LessThan(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_THAN, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_THAN, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -301,7 +302,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery {
     }
 
     public void setId_GreaterEqual(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -312,7 +313,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery {
     }
 
     public void setId_LessEqual(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_EQUAL, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_EQUAL, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -333,29 +334,29 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery {
     }
 
     public void setUrl_Term(String url, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("url", url);
+        TermQueryBuilder builder = regTermQ("url", url);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setUrl_Terms(Collection<String> urlList) {
-        setUrl_MatchPhrasePrefix(urlList, null);
+        setUrl_Terms(urlList, null);
     }
 
-    public void setUrl_MatchPhrasePrefix(Collection<String> urlList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("url", urlList);
+    public void setUrl_Terms(Collection<String> urlList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("url", urlList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setUrl_InScope(Collection<String> urlList) {
-        setUrl_MatchPhrasePrefix(urlList, null);
+        setUrl_Terms(urlList, null);
     }
 
     public void setUrl_InScope(Collection<String> urlList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setUrl_MatchPhrasePrefix(urlList, opLambda);
+        setUrl_Terms(urlList, opLambda);
     }
 
     public void setUrl_Match(String url) {
@@ -363,7 +364,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery {
     }
 
     public void setUrl_Match(String url, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("url", url);
+        MatchQueryBuilder builder = regMatchQ("url", url);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -374,7 +375,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery {
     }
 
     public void setUrl_MatchPhrase(String url, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("url", url);
+        MatchQueryBuilder builder = regMatchPhraseQ("url", url);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -385,7 +386,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery {
     }
 
     public void setUrl_MatchPhrasePrefix(String url, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("url", url);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("url", url);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -396,7 +397,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery {
     }
 
     public void setUrl_Fuzzy(String url, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("url", url);
+        FuzzyQueryBuilder builder = regFuzzyQ("url", url);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -407,7 +408,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery {
     }
 
     public void setUrl_Prefix(String url, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("url", url);
+        PrefixQueryBuilder builder = regPrefixQ("url", url);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -418,7 +419,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery {
     }
 
     public void setUrl_GreaterThan(String url, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("url", ConditionKey.CK_GREATER_THAN, url);
+        RangeQueryBuilder builder = regRangeQ("url", ConditionKey.CK_GREATER_THAN, url);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -429,7 +430,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery {
     }
 
     public void setUrl_LessThan(String url, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("url", ConditionKey.CK_LESS_THAN, url);
+        RangeQueryBuilder builder = regRangeQ("url", ConditionKey.CK_LESS_THAN, url);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -440,7 +441,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery {
     }
 
     public void setUrl_GreaterEqual(String url, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("url", ConditionKey.CK_GREATER_EQUAL, url);
+        RangeQueryBuilder builder = regRangeQ("url", ConditionKey.CK_GREATER_EQUAL, url);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -451,7 +452,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery {
     }
 
     public void setUrl_LessEqual(String url, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("url", ConditionKey.CK_LESS_EQUAL, url);
+        RangeQueryBuilder builder = regRangeQ("url", ConditionKey.CK_LESS_EQUAL, url);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -472,29 +473,29 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery {
     }
 
     public void setUserInfoId_Term(String userInfoId, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("userInfoId", userInfoId);
+        TermQueryBuilder builder = regTermQ("userInfoId", userInfoId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setUserInfoId_Terms(Collection<String> userInfoIdList) {
-        setUserInfoId_MatchPhrasePrefix(userInfoIdList, null);
+        setUserInfoId_Terms(userInfoIdList, null);
     }
 
-    public void setUserInfoId_MatchPhrasePrefix(Collection<String> userInfoIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("userInfoId", userInfoIdList);
+    public void setUserInfoId_Terms(Collection<String> userInfoIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("userInfoId", userInfoIdList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setUserInfoId_InScope(Collection<String> userInfoIdList) {
-        setUserInfoId_MatchPhrasePrefix(userInfoIdList, null);
+        setUserInfoId_Terms(userInfoIdList, null);
     }
 
     public void setUserInfoId_InScope(Collection<String> userInfoIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setUserInfoId_MatchPhrasePrefix(userInfoIdList, opLambda);
+        setUserInfoId_Terms(userInfoIdList, opLambda);
     }
 
     public void setUserInfoId_Match(String userInfoId) {
@@ -502,7 +503,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery {
     }
 
     public void setUserInfoId_Match(String userInfoId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("userInfoId", userInfoId);
+        MatchQueryBuilder builder = regMatchQ("userInfoId", userInfoId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -513,7 +514,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery {
     }
 
     public void setUserInfoId_MatchPhrase(String userInfoId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("userInfoId", userInfoId);
+        MatchQueryBuilder builder = regMatchPhraseQ("userInfoId", userInfoId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -524,7 +525,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery {
     }
 
     public void setUserInfoId_MatchPhrasePrefix(String userInfoId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("userInfoId", userInfoId);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("userInfoId", userInfoId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -535,7 +536,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery {
     }
 
     public void setUserInfoId_Fuzzy(String userInfoId, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("userInfoId", userInfoId);
+        FuzzyQueryBuilder builder = regFuzzyQ("userInfoId", userInfoId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -546,7 +547,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery {
     }
 
     public void setUserInfoId_Prefix(String userInfoId, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("userInfoId", userInfoId);
+        PrefixQueryBuilder builder = regPrefixQ("userInfoId", userInfoId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -557,7 +558,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery {
     }
 
     public void setUserInfoId_GreaterThan(String userInfoId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("userInfoId", ConditionKey.CK_GREATER_THAN, userInfoId);
+        RangeQueryBuilder builder = regRangeQ("userInfoId", ConditionKey.CK_GREATER_THAN, userInfoId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -568,7 +569,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery {
     }
 
     public void setUserInfoId_LessThan(String userInfoId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("userInfoId", ConditionKey.CK_LESS_THAN, userInfoId);
+        RangeQueryBuilder builder = regRangeQ("userInfoId", ConditionKey.CK_LESS_THAN, userInfoId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -579,7 +580,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery {
     }
 
     public void setUserInfoId_GreaterEqual(String userInfoId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("userInfoId", ConditionKey.CK_GREATER_EQUAL, userInfoId);
+        RangeQueryBuilder builder = regRangeQ("userInfoId", ConditionKey.CK_GREATER_EQUAL, userInfoId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -590,7 +591,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery {
     }
 
     public void setUserInfoId_LessEqual(String userInfoId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("userInfoId", ConditionKey.CK_LESS_EQUAL, userInfoId);
+        RangeQueryBuilder builder = regRangeQ("userInfoId", ConditionKey.CK_LESS_EQUAL, userInfoId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }

src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsFileConfigToLabelCQ.java

@@ -3,6 +3,7 @@ package org.codelibs.fess.es.cbean.cq.bs;
 import java.util.Collection;
 
 import org.codelibs.fess.es.cbean.cq.FileConfigToLabelCQ;
+import org.codelibs.fess.es.cbean.cf.FileConfigToLabelCF;
 import org.dbflute.cbean.ckey.ConditionKey;
 import org.elasticsearch.index.query.BoolQueryBuilder;
 import org.elasticsearch.index.query.FilteredQueryBuilder;
@@ -28,16 +29,17 @@ public abstract class BsFileConfigToLabelCQ extends AbstractConditionQuery {
         return "file_config_to_label";
     }
 
-    public void filtered(FilteredCall<FileConfigToLabelCQ> filteredLambda) {
+    public void filtered(FilteredCall<FileConfigToLabelCQ, FileConfigToLabelCF> filteredLambda) {
         filtered(filteredLambda, null);
     }
 
-    public void filtered(FilteredCall<FileConfigToLabelCQ> filteredLambda, ConditionOptionCall<FilteredQueryBuilder> opLambda) {
+    public void filtered(FilteredCall<FileConfigToLabelCQ, FileConfigToLabelCF> filteredLambda,
+            ConditionOptionCall<FilteredQueryBuilder> opLambda) {
         FileConfigToLabelCQ query = new FileConfigToLabelCQ();
-        filteredLambda.callback(query);
-        if (!query.queryBuilderList.isEmpty()) {
-            // TODO filter
-            FilteredQueryBuilder builder = reqFilteredQ(query.getQuery(), null);
+        FileConfigToLabelCF filter = new FileConfigToLabelCF();
+        filteredLambda.callback(query, filter);
+        if (query.hasQueries()) {
+            FilteredQueryBuilder builder = regFilteredQ(query.getQuery(), filter.getFilter());
             if (opLambda != null) {
                 opLambda.callback(builder);
             }
@@ -53,8 +55,8 @@ public abstract class BsFileConfigToLabelCQ extends AbstractConditionQuery {
         FileConfigToLabelCQ shouldQuery = new FileConfigToLabelCQ();
         FileConfigToLabelCQ mustNotQuery = new FileConfigToLabelCQ();
         boolLambda.callback(mustQuery, shouldQuery, mustNotQuery);
-        if (!mustQuery.queryBuilderList.isEmpty() || !shouldQuery.queryBuilderList.isEmpty() || !mustNotQuery.queryBuilderList.isEmpty()) {
-            BoolQueryBuilder builder = reqBoolCQ(mustQuery.queryBuilderList, shouldQuery.queryBuilderList, mustNotQuery.queryBuilderList);
+        if (mustQuery.hasQueries() || shouldQuery.hasQueries() || mustNotQuery.hasQueries()) {
+            BoolQueryBuilder builder = regBoolCQ(mustQuery.queryBuilderList, shouldQuery.queryBuilderList, mustNotQuery.queryBuilderList);
             if (opLambda != null) {
                 opLambda.callback(builder);
             }
@@ -66,29 +68,29 @@ public abstract class BsFileConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setFileConfigId_Term(String fileConfigId, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("fileConfigId", fileConfigId);
+        TermQueryBuilder builder = regTermQ("fileConfigId", fileConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setFileConfigId_Terms(Collection<String> fileConfigIdList) {
-        setFileConfigId_MatchPhrasePrefix(fileConfigIdList, null);
+        setFileConfigId_Terms(fileConfigIdList, null);
     }
 
-    public void setFileConfigId_MatchPhrasePrefix(Collection<String> fileConfigIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("fileConfigId", fileConfigIdList);
+    public void setFileConfigId_Terms(Collection<String> fileConfigIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("fileConfigId", fileConfigIdList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setFileConfigId_InScope(Collection<String> fileConfigIdList) {
-        setFileConfigId_MatchPhrasePrefix(fileConfigIdList, null);
+        setFileConfigId_Terms(fileConfigIdList, null);
     }
 
     public void setFileConfigId_InScope(Collection<String> fileConfigIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setFileConfigId_MatchPhrasePrefix(fileConfigIdList, opLambda);
+        setFileConfigId_Terms(fileConfigIdList, opLambda);
     }
 
     public void setFileConfigId_Match(String fileConfigId) {
@@ -96,7 +98,7 @@ public abstract class BsFileConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setFileConfigId_Match(String fileConfigId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("fileConfigId", fileConfigId);
+        MatchQueryBuilder builder = regMatchQ("fileConfigId", fileConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -107,7 +109,7 @@ public abstract class BsFileConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setFileConfigId_MatchPhrase(String fileConfigId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("fileConfigId", fileConfigId);
+        MatchQueryBuilder builder = regMatchPhraseQ("fileConfigId", fileConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -118,7 +120,7 @@ public abstract class BsFileConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setFileConfigId_MatchPhrasePrefix(String fileConfigId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("fileConfigId", fileConfigId);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("fileConfigId", fileConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -129,7 +131,7 @@ public abstract class BsFileConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setFileConfigId_Fuzzy(String fileConfigId, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("fileConfigId", fileConfigId);
+        FuzzyQueryBuilder builder = regFuzzyQ("fileConfigId", fileConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -140,7 +142,7 @@ public abstract class BsFileConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setFileConfigId_Prefix(String fileConfigId, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("fileConfigId", fileConfigId);
+        PrefixQueryBuilder builder = regPrefixQ("fileConfigId", fileConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -151,7 +153,7 @@ public abstract class BsFileConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setFileConfigId_GreaterThan(String fileConfigId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("fileConfigId", ConditionKey.CK_GREATER_THAN, fileConfigId);
+        RangeQueryBuilder builder = regRangeQ("fileConfigId", ConditionKey.CK_GREATER_THAN, fileConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -162,7 +164,7 @@ public abstract class BsFileConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setFileConfigId_LessThan(String fileConfigId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("fileConfigId", ConditionKey.CK_LESS_THAN, fileConfigId);
+        RangeQueryBuilder builder = regRangeQ("fileConfigId", ConditionKey.CK_LESS_THAN, fileConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -173,7 +175,7 @@ public abstract class BsFileConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setFileConfigId_GreaterEqual(String fileConfigId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("fileConfigId", ConditionKey.CK_GREATER_EQUAL, fileConfigId);
+        RangeQueryBuilder builder = regRangeQ("fileConfigId", ConditionKey.CK_GREATER_EQUAL, fileConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -184,7 +186,7 @@ public abstract class BsFileConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setFileConfigId_LessEqual(String fileConfigId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("fileConfigId", ConditionKey.CK_LESS_EQUAL, fileConfigId);
+        RangeQueryBuilder builder = regRangeQ("fileConfigId", ConditionKey.CK_LESS_EQUAL, fileConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -205,29 +207,29 @@ public abstract class BsFileConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setId_Term(String id, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("id", id);
+        TermQueryBuilder builder = regTermQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setId_Terms(Collection<String> idList) {
-        setId_MatchPhrasePrefix(idList, null);
+        setId_Terms(idList, null);
     }
 
-    public void setId_MatchPhrasePrefix(Collection<String> idList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("id", idList);
+    public void setId_Terms(Collection<String> idList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("id", idList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setId_InScope(Collection<String> idList) {
-        setId_MatchPhrasePrefix(idList, null);
+        setId_Terms(idList, null);
     }
 
     public void setId_InScope(Collection<String> idList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setId_MatchPhrasePrefix(idList, opLambda);
+        setId_Terms(idList, opLambda);
     }
 
     public void setId_Match(String id) {
@@ -235,7 +237,7 @@ public abstract class BsFileConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setId_Match(String id, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("id", id);
+        MatchQueryBuilder builder = regMatchQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -246,7 +248,7 @@ public abstract class BsFileConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setId_MatchPhrase(String id, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("id", id);
+        MatchQueryBuilder builder = regMatchPhraseQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -257,7 +259,7 @@ public abstract class BsFileConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setId_MatchPhrasePrefix(String id, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("id", id);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -268,7 +270,7 @@ public abstract class BsFileConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setId_Fuzzy(String id, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("id", id);
+        FuzzyQueryBuilder builder = regFuzzyQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -279,7 +281,7 @@ public abstract class BsFileConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setId_Prefix(String id, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("id", id);
+        PrefixQueryBuilder builder = regPrefixQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -290,7 +292,7 @@ public abstract class BsFileConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setId_GreaterThan(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_THAN, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_THAN, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -301,7 +303,7 @@ public abstract class BsFileConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setId_LessThan(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_THAN, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_THAN, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -312,7 +314,7 @@ public abstract class BsFileConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setId_GreaterEqual(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -323,7 +325,7 @@ public abstract class BsFileConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setId_LessEqual(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_EQUAL, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_EQUAL, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -344,29 +346,29 @@ public abstract class BsFileConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setLabelTypeId_Term(String labelTypeId, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("labelTypeId", labelTypeId);
+        TermQueryBuilder builder = regTermQ("labelTypeId", labelTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setLabelTypeId_Terms(Collection<String> labelTypeIdList) {
-        setLabelTypeId_MatchPhrasePrefix(labelTypeIdList, null);
+        setLabelTypeId_Terms(labelTypeIdList, null);
     }
 
-    public void setLabelTypeId_MatchPhrasePrefix(Collection<String> labelTypeIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("labelTypeId", labelTypeIdList);
+    public void setLabelTypeId_Terms(Collection<String> labelTypeIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("labelTypeId", labelTypeIdList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setLabelTypeId_InScope(Collection<String> labelTypeIdList) {
-        setLabelTypeId_MatchPhrasePrefix(labelTypeIdList, null);
+        setLabelTypeId_Terms(labelTypeIdList, null);
     }
 
     public void setLabelTypeId_InScope(Collection<String> labelTypeIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setLabelTypeId_MatchPhrasePrefix(labelTypeIdList, opLambda);
+        setLabelTypeId_Terms(labelTypeIdList, opLambda);
     }
 
     public void setLabelTypeId_Match(String labelTypeId) {
@@ -374,7 +376,7 @@ public abstract class BsFileConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setLabelTypeId_Match(String labelTypeId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("labelTypeId", labelTypeId);
+        MatchQueryBuilder builder = regMatchQ("labelTypeId", labelTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -385,7 +387,7 @@ public abstract class BsFileConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setLabelTypeId_MatchPhrase(String labelTypeId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("labelTypeId", labelTypeId);
+        MatchQueryBuilder builder = regMatchPhraseQ("labelTypeId", labelTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -396,7 +398,7 @@ public abstract class BsFileConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setLabelTypeId_MatchPhrasePrefix(String labelTypeId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("labelTypeId", labelTypeId);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("labelTypeId", labelTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -407,7 +409,7 @@ public abstract class BsFileConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setLabelTypeId_Fuzzy(String labelTypeId, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("labelTypeId", labelTypeId);
+        FuzzyQueryBuilder builder = regFuzzyQ("labelTypeId", labelTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -418,7 +420,7 @@ public abstract class BsFileConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setLabelTypeId_Prefix(String labelTypeId, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("labelTypeId", labelTypeId);
+        PrefixQueryBuilder builder = regPrefixQ("labelTypeId", labelTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -429,7 +431,7 @@ public abstract class BsFileConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setLabelTypeId_GreaterThan(String labelTypeId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("labelTypeId", ConditionKey.CK_GREATER_THAN, labelTypeId);
+        RangeQueryBuilder builder = regRangeQ("labelTypeId", ConditionKey.CK_GREATER_THAN, labelTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -440,7 +442,7 @@ public abstract class BsFileConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setLabelTypeId_LessThan(String labelTypeId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("labelTypeId", ConditionKey.CK_LESS_THAN, labelTypeId);
+        RangeQueryBuilder builder = regRangeQ("labelTypeId", ConditionKey.CK_LESS_THAN, labelTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -451,7 +453,7 @@ public abstract class BsFileConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setLabelTypeId_GreaterEqual(String labelTypeId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("labelTypeId", ConditionKey.CK_GREATER_EQUAL, labelTypeId);
+        RangeQueryBuilder builder = regRangeQ("labelTypeId", ConditionKey.CK_GREATER_EQUAL, labelTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -462,7 +464,7 @@ public abstract class BsFileConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setLabelTypeId_LessEqual(String labelTypeId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("labelTypeId", ConditionKey.CK_LESS_EQUAL, labelTypeId);
+        RangeQueryBuilder builder = regRangeQ("labelTypeId", ConditionKey.CK_LESS_EQUAL, labelTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }

src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsFileConfigToRoleCQ.java

@@ -3,6 +3,7 @@ package org.codelibs.fess.es.cbean.cq.bs;
 import java.util.Collection;
 
 import org.codelibs.fess.es.cbean.cq.FileConfigToRoleCQ;
+import org.codelibs.fess.es.cbean.cf.FileConfigToRoleCF;
 import org.dbflute.cbean.ckey.ConditionKey;
 import org.elasticsearch.index.query.BoolQueryBuilder;
 import org.elasticsearch.index.query.FilteredQueryBuilder;
@@ -28,16 +29,17 @@ public abstract class BsFileConfigToRoleCQ extends AbstractConditionQuery {
         return "file_config_to_role";
     }
 
-    public void filtered(FilteredCall<FileConfigToRoleCQ> filteredLambda) {
+    public void filtered(FilteredCall<FileConfigToRoleCQ, FileConfigToRoleCF> filteredLambda) {
         filtered(filteredLambda, null);
     }
 
-    public void filtered(FilteredCall<FileConfigToRoleCQ> filteredLambda, ConditionOptionCall<FilteredQueryBuilder> opLambda) {
+    public void filtered(FilteredCall<FileConfigToRoleCQ, FileConfigToRoleCF> filteredLambda,
+            ConditionOptionCall<FilteredQueryBuilder> opLambda) {
         FileConfigToRoleCQ query = new FileConfigToRoleCQ();
-        filteredLambda.callback(query);
-        if (!query.queryBuilderList.isEmpty()) {
-            // TODO filter
-            FilteredQueryBuilder builder = reqFilteredQ(query.getQuery(), null);
+        FileConfigToRoleCF filter = new FileConfigToRoleCF();
+        filteredLambda.callback(query, filter);
+        if (query.hasQueries()) {
+            FilteredQueryBuilder builder = regFilteredQ(query.getQuery(), filter.getFilter());
             if (opLambda != null) {
                 opLambda.callback(builder);
             }
@@ -53,8 +55,8 @@ public abstract class BsFileConfigToRoleCQ extends AbstractConditionQuery {
         FileConfigToRoleCQ shouldQuery = new FileConfigToRoleCQ();
         FileConfigToRoleCQ mustNotQuery = new FileConfigToRoleCQ();
         boolLambda.callback(mustQuery, shouldQuery, mustNotQuery);
-        if (!mustQuery.queryBuilderList.isEmpty() || !shouldQuery.queryBuilderList.isEmpty() || !mustNotQuery.queryBuilderList.isEmpty()) {
-            BoolQueryBuilder builder = reqBoolCQ(mustQuery.queryBuilderList, shouldQuery.queryBuilderList, mustNotQuery.queryBuilderList);
+        if (mustQuery.hasQueries() || shouldQuery.hasQueries() || mustNotQuery.hasQueries()) {
+            BoolQueryBuilder builder = regBoolCQ(mustQuery.queryBuilderList, shouldQuery.queryBuilderList, mustNotQuery.queryBuilderList);
             if (opLambda != null) {
                 opLambda.callback(builder);
             }
@@ -66,29 +68,29 @@ public abstract class BsFileConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setFileConfigId_Term(String fileConfigId, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("fileConfigId", fileConfigId);
+        TermQueryBuilder builder = regTermQ("fileConfigId", fileConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setFileConfigId_Terms(Collection<String> fileConfigIdList) {
-        setFileConfigId_MatchPhrasePrefix(fileConfigIdList, null);
+        setFileConfigId_Terms(fileConfigIdList, null);
     }
 
-    public void setFileConfigId_MatchPhrasePrefix(Collection<String> fileConfigIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("fileConfigId", fileConfigIdList);
+    public void setFileConfigId_Terms(Collection<String> fileConfigIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("fileConfigId", fileConfigIdList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setFileConfigId_InScope(Collection<String> fileConfigIdList) {
-        setFileConfigId_MatchPhrasePrefix(fileConfigIdList, null);
+        setFileConfigId_Terms(fileConfigIdList, null);
     }
 
     public void setFileConfigId_InScope(Collection<String> fileConfigIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setFileConfigId_MatchPhrasePrefix(fileConfigIdList, opLambda);
+        setFileConfigId_Terms(fileConfigIdList, opLambda);
     }
 
     public void setFileConfigId_Match(String fileConfigId) {
@@ -96,7 +98,7 @@ public abstract class BsFileConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setFileConfigId_Match(String fileConfigId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("fileConfigId", fileConfigId);
+        MatchQueryBuilder builder = regMatchQ("fileConfigId", fileConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -107,7 +109,7 @@ public abstract class BsFileConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setFileConfigId_MatchPhrase(String fileConfigId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("fileConfigId", fileConfigId);
+        MatchQueryBuilder builder = regMatchPhraseQ("fileConfigId", fileConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -118,7 +120,7 @@ public abstract class BsFileConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setFileConfigId_MatchPhrasePrefix(String fileConfigId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("fileConfigId", fileConfigId);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("fileConfigId", fileConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -129,7 +131,7 @@ public abstract class BsFileConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setFileConfigId_Fuzzy(String fileConfigId, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("fileConfigId", fileConfigId);
+        FuzzyQueryBuilder builder = regFuzzyQ("fileConfigId", fileConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -140,7 +142,7 @@ public abstract class BsFileConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setFileConfigId_Prefix(String fileConfigId, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("fileConfigId", fileConfigId);
+        PrefixQueryBuilder builder = regPrefixQ("fileConfigId", fileConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -151,7 +153,7 @@ public abstract class BsFileConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setFileConfigId_GreaterThan(String fileConfigId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("fileConfigId", ConditionKey.CK_GREATER_THAN, fileConfigId);
+        RangeQueryBuilder builder = regRangeQ("fileConfigId", ConditionKey.CK_GREATER_THAN, fileConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -162,7 +164,7 @@ public abstract class BsFileConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setFileConfigId_LessThan(String fileConfigId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("fileConfigId", ConditionKey.CK_LESS_THAN, fileConfigId);
+        RangeQueryBuilder builder = regRangeQ("fileConfigId", ConditionKey.CK_LESS_THAN, fileConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -173,7 +175,7 @@ public abstract class BsFileConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setFileConfigId_GreaterEqual(String fileConfigId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("fileConfigId", ConditionKey.CK_GREATER_EQUAL, fileConfigId);
+        RangeQueryBuilder builder = regRangeQ("fileConfigId", ConditionKey.CK_GREATER_EQUAL, fileConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -184,7 +186,7 @@ public abstract class BsFileConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setFileConfigId_LessEqual(String fileConfigId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("fileConfigId", ConditionKey.CK_LESS_EQUAL, fileConfigId);
+        RangeQueryBuilder builder = regRangeQ("fileConfigId", ConditionKey.CK_LESS_EQUAL, fileConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -205,29 +207,29 @@ public abstract class BsFileConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setId_Term(String id, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("id", id);
+        TermQueryBuilder builder = regTermQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setId_Terms(Collection<String> idList) {
-        setId_MatchPhrasePrefix(idList, null);
+        setId_Terms(idList, null);
     }
 
-    public void setId_MatchPhrasePrefix(Collection<String> idList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("id", idList);
+    public void setId_Terms(Collection<String> idList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("id", idList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setId_InScope(Collection<String> idList) {
-        setId_MatchPhrasePrefix(idList, null);
+        setId_Terms(idList, null);
     }
 
     public void setId_InScope(Collection<String> idList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setId_MatchPhrasePrefix(idList, opLambda);
+        setId_Terms(idList, opLambda);
     }
 
     public void setId_Match(String id) {
@@ -235,7 +237,7 @@ public abstract class BsFileConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setId_Match(String id, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("id", id);
+        MatchQueryBuilder builder = regMatchQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -246,7 +248,7 @@ public abstract class BsFileConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setId_MatchPhrase(String id, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("id", id);
+        MatchQueryBuilder builder = regMatchPhraseQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -257,7 +259,7 @@ public abstract class BsFileConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setId_MatchPhrasePrefix(String id, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("id", id);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -268,7 +270,7 @@ public abstract class BsFileConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setId_Fuzzy(String id, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("id", id);
+        FuzzyQueryBuilder builder = regFuzzyQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -279,7 +281,7 @@ public abstract class BsFileConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setId_Prefix(String id, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("id", id);
+        PrefixQueryBuilder builder = regPrefixQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -290,7 +292,7 @@ public abstract class BsFileConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setId_GreaterThan(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_THAN, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_THAN, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -301,7 +303,7 @@ public abstract class BsFileConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setId_LessThan(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_THAN, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_THAN, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -312,7 +314,7 @@ public abstract class BsFileConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setId_GreaterEqual(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -323,7 +325,7 @@ public abstract class BsFileConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setId_LessEqual(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_EQUAL, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_EQUAL, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -344,29 +346,29 @@ public abstract class BsFileConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setRoleTypeId_Term(String roleTypeId, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("roleTypeId", roleTypeId);
+        TermQueryBuilder builder = regTermQ("roleTypeId", roleTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setRoleTypeId_Terms(Collection<String> roleTypeIdList) {
-        setRoleTypeId_MatchPhrasePrefix(roleTypeIdList, null);
+        setRoleTypeId_Terms(roleTypeIdList, null);
     }
 
-    public void setRoleTypeId_MatchPhrasePrefix(Collection<String> roleTypeIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("roleTypeId", roleTypeIdList);
+    public void setRoleTypeId_Terms(Collection<String> roleTypeIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("roleTypeId", roleTypeIdList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setRoleTypeId_InScope(Collection<String> roleTypeIdList) {
-        setRoleTypeId_MatchPhrasePrefix(roleTypeIdList, null);
+        setRoleTypeId_Terms(roleTypeIdList, null);
     }
 
     public void setRoleTypeId_InScope(Collection<String> roleTypeIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setRoleTypeId_MatchPhrasePrefix(roleTypeIdList, opLambda);
+        setRoleTypeId_Terms(roleTypeIdList, opLambda);
     }
 
     public void setRoleTypeId_Match(String roleTypeId) {
@@ -374,7 +376,7 @@ public abstract class BsFileConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setRoleTypeId_Match(String roleTypeId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("roleTypeId", roleTypeId);
+        MatchQueryBuilder builder = regMatchQ("roleTypeId", roleTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -385,7 +387,7 @@ public abstract class BsFileConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setRoleTypeId_MatchPhrase(String roleTypeId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("roleTypeId", roleTypeId);
+        MatchQueryBuilder builder = regMatchPhraseQ("roleTypeId", roleTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -396,7 +398,7 @@ public abstract class BsFileConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setRoleTypeId_MatchPhrasePrefix(String roleTypeId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("roleTypeId", roleTypeId);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("roleTypeId", roleTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -407,7 +409,7 @@ public abstract class BsFileConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setRoleTypeId_Fuzzy(String roleTypeId, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("roleTypeId", roleTypeId);
+        FuzzyQueryBuilder builder = regFuzzyQ("roleTypeId", roleTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -418,7 +420,7 @@ public abstract class BsFileConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setRoleTypeId_Prefix(String roleTypeId, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("roleTypeId", roleTypeId);
+        PrefixQueryBuilder builder = regPrefixQ("roleTypeId", roleTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -429,7 +431,7 @@ public abstract class BsFileConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setRoleTypeId_GreaterThan(String roleTypeId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("roleTypeId", ConditionKey.CK_GREATER_THAN, roleTypeId);
+        RangeQueryBuilder builder = regRangeQ("roleTypeId", ConditionKey.CK_GREATER_THAN, roleTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -440,7 +442,7 @@ public abstract class BsFileConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setRoleTypeId_LessThan(String roleTypeId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("roleTypeId", ConditionKey.CK_LESS_THAN, roleTypeId);
+        RangeQueryBuilder builder = regRangeQ("roleTypeId", ConditionKey.CK_LESS_THAN, roleTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -451,7 +453,7 @@ public abstract class BsFileConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setRoleTypeId_GreaterEqual(String roleTypeId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("roleTypeId", ConditionKey.CK_GREATER_EQUAL, roleTypeId);
+        RangeQueryBuilder builder = regRangeQ("roleTypeId", ConditionKey.CK_GREATER_EQUAL, roleTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -462,7 +464,7 @@ public abstract class BsFileConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setRoleTypeId_LessEqual(String roleTypeId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("roleTypeId", ConditionKey.CK_LESS_EQUAL, roleTypeId);
+        RangeQueryBuilder builder = regRangeQ("roleTypeId", ConditionKey.CK_LESS_EQUAL, roleTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }

src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsLabelToRoleCQ.java

@@ -3,6 +3,7 @@ package org.codelibs.fess.es.cbean.cq.bs;
 import java.util.Collection;
 
 import org.codelibs.fess.es.cbean.cq.LabelToRoleCQ;
+import org.codelibs.fess.es.cbean.cf.LabelToRoleCF;
 import org.dbflute.cbean.ckey.ConditionKey;
 import org.elasticsearch.index.query.BoolQueryBuilder;
 import org.elasticsearch.index.query.FilteredQueryBuilder;
@@ -28,16 +29,16 @@ public abstract class BsLabelToRoleCQ extends AbstractConditionQuery {
         return "label_to_role";
     }
 
-    public void filtered(FilteredCall<LabelToRoleCQ> filteredLambda) {
+    public void filtered(FilteredCall<LabelToRoleCQ, LabelToRoleCF> filteredLambda) {
         filtered(filteredLambda, null);
     }
 
-    public void filtered(FilteredCall<LabelToRoleCQ> filteredLambda, ConditionOptionCall<FilteredQueryBuilder> opLambda) {
+    public void filtered(FilteredCall<LabelToRoleCQ, LabelToRoleCF> filteredLambda, ConditionOptionCall<FilteredQueryBuilder> opLambda) {
         LabelToRoleCQ query = new LabelToRoleCQ();
-        filteredLambda.callback(query);
-        if (!query.queryBuilderList.isEmpty()) {
-            // TODO filter
-            FilteredQueryBuilder builder = reqFilteredQ(query.getQuery(), null);
+        LabelToRoleCF filter = new LabelToRoleCF();
+        filteredLambda.callback(query, filter);
+        if (query.hasQueries()) {
+            FilteredQueryBuilder builder = regFilteredQ(query.getQuery(), filter.getFilter());
             if (opLambda != null) {
                 opLambda.callback(builder);
             }
@@ -53,8 +54,8 @@ public abstract class BsLabelToRoleCQ extends AbstractConditionQuery {
         LabelToRoleCQ shouldQuery = new LabelToRoleCQ();
         LabelToRoleCQ mustNotQuery = new LabelToRoleCQ();
         boolLambda.callback(mustQuery, shouldQuery, mustNotQuery);
-        if (!mustQuery.queryBuilderList.isEmpty() || !shouldQuery.queryBuilderList.isEmpty() || !mustNotQuery.queryBuilderList.isEmpty()) {
-            BoolQueryBuilder builder = reqBoolCQ(mustQuery.queryBuilderList, shouldQuery.queryBuilderList, mustNotQuery.queryBuilderList);
+        if (mustQuery.hasQueries() || shouldQuery.hasQueries() || mustNotQuery.hasQueries()) {
+            BoolQueryBuilder builder = regBoolCQ(mustQuery.queryBuilderList, shouldQuery.queryBuilderList, mustNotQuery.queryBuilderList);
             if (opLambda != null) {
                 opLambda.callback(builder);
             }
@@ -66,29 +67,29 @@ public abstract class BsLabelToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setId_Term(String id, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("id", id);
+        TermQueryBuilder builder = regTermQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setId_Terms(Collection<String> idList) {
-        setId_MatchPhrasePrefix(idList, null);
+        setId_Terms(idList, null);
     }
 
-    public void setId_MatchPhrasePrefix(Collection<String> idList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("id", idList);
+    public void setId_Terms(Collection<String> idList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("id", idList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setId_InScope(Collection<String> idList) {
-        setId_MatchPhrasePrefix(idList, null);
+        setId_Terms(idList, null);
     }
 
     public void setId_InScope(Collection<String> idList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setId_MatchPhrasePrefix(idList, opLambda);
+        setId_Terms(idList, opLambda);
     }
 
     public void setId_Match(String id) {
@@ -96,7 +97,7 @@ public abstract class BsLabelToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setId_Match(String id, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("id", id);
+        MatchQueryBuilder builder = regMatchQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -107,7 +108,7 @@ public abstract class BsLabelToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setId_MatchPhrase(String id, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("id", id);
+        MatchQueryBuilder builder = regMatchPhraseQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -118,7 +119,7 @@ public abstract class BsLabelToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setId_MatchPhrasePrefix(String id, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("id", id);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -129,7 +130,7 @@ public abstract class BsLabelToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setId_Fuzzy(String id, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("id", id);
+        FuzzyQueryBuilder builder = regFuzzyQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -140,7 +141,7 @@ public abstract class BsLabelToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setId_Prefix(String id, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("id", id);
+        PrefixQueryBuilder builder = regPrefixQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -151,7 +152,7 @@ public abstract class BsLabelToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setId_GreaterThan(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_THAN, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_THAN, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -162,7 +163,7 @@ public abstract class BsLabelToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setId_LessThan(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_THAN, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_THAN, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -173,7 +174,7 @@ public abstract class BsLabelToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setId_GreaterEqual(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -184,7 +185,7 @@ public abstract class BsLabelToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setId_LessEqual(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_EQUAL, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_EQUAL, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -205,29 +206,29 @@ public abstract class BsLabelToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setLabelTypeId_Term(String labelTypeId, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("labelTypeId", labelTypeId);
+        TermQueryBuilder builder = regTermQ("labelTypeId", labelTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setLabelTypeId_Terms(Collection<String> labelTypeIdList) {
-        setLabelTypeId_MatchPhrasePrefix(labelTypeIdList, null);
+        setLabelTypeId_Terms(labelTypeIdList, null);
     }
 
-    public void setLabelTypeId_MatchPhrasePrefix(Collection<String> labelTypeIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("labelTypeId", labelTypeIdList);
+    public void setLabelTypeId_Terms(Collection<String> labelTypeIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("labelTypeId", labelTypeIdList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setLabelTypeId_InScope(Collection<String> labelTypeIdList) {
-        setLabelTypeId_MatchPhrasePrefix(labelTypeIdList, null);
+        setLabelTypeId_Terms(labelTypeIdList, null);
     }
 
     public void setLabelTypeId_InScope(Collection<String> labelTypeIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setLabelTypeId_MatchPhrasePrefix(labelTypeIdList, opLambda);
+        setLabelTypeId_Terms(labelTypeIdList, opLambda);
     }
 
     public void setLabelTypeId_Match(String labelTypeId) {
@@ -235,7 +236,7 @@ public abstract class BsLabelToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setLabelTypeId_Match(String labelTypeId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("labelTypeId", labelTypeId);
+        MatchQueryBuilder builder = regMatchQ("labelTypeId", labelTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -246,7 +247,7 @@ public abstract class BsLabelToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setLabelTypeId_MatchPhrase(String labelTypeId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("labelTypeId", labelTypeId);
+        MatchQueryBuilder builder = regMatchPhraseQ("labelTypeId", labelTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -257,7 +258,7 @@ public abstract class BsLabelToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setLabelTypeId_MatchPhrasePrefix(String labelTypeId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("labelTypeId", labelTypeId);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("labelTypeId", labelTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -268,7 +269,7 @@ public abstract class BsLabelToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setLabelTypeId_Fuzzy(String labelTypeId, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("labelTypeId", labelTypeId);
+        FuzzyQueryBuilder builder = regFuzzyQ("labelTypeId", labelTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -279,7 +280,7 @@ public abstract class BsLabelToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setLabelTypeId_Prefix(String labelTypeId, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("labelTypeId", labelTypeId);
+        PrefixQueryBuilder builder = regPrefixQ("labelTypeId", labelTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -290,7 +291,7 @@ public abstract class BsLabelToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setLabelTypeId_GreaterThan(String labelTypeId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("labelTypeId", ConditionKey.CK_GREATER_THAN, labelTypeId);
+        RangeQueryBuilder builder = regRangeQ("labelTypeId", ConditionKey.CK_GREATER_THAN, labelTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -301,7 +302,7 @@ public abstract class BsLabelToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setLabelTypeId_LessThan(String labelTypeId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("labelTypeId", ConditionKey.CK_LESS_THAN, labelTypeId);
+        RangeQueryBuilder builder = regRangeQ("labelTypeId", ConditionKey.CK_LESS_THAN, labelTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -312,7 +313,7 @@ public abstract class BsLabelToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setLabelTypeId_GreaterEqual(String labelTypeId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("labelTypeId", ConditionKey.CK_GREATER_EQUAL, labelTypeId);
+        RangeQueryBuilder builder = regRangeQ("labelTypeId", ConditionKey.CK_GREATER_EQUAL, labelTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -323,7 +324,7 @@ public abstract class BsLabelToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setLabelTypeId_LessEqual(String labelTypeId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("labelTypeId", ConditionKey.CK_LESS_EQUAL, labelTypeId);
+        RangeQueryBuilder builder = regRangeQ("labelTypeId", ConditionKey.CK_LESS_EQUAL, labelTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -344,29 +345,29 @@ public abstract class BsLabelToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setRoleTypeId_Term(String roleTypeId, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("roleTypeId", roleTypeId);
+        TermQueryBuilder builder = regTermQ("roleTypeId", roleTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setRoleTypeId_Terms(Collection<String> roleTypeIdList) {
-        setRoleTypeId_MatchPhrasePrefix(roleTypeIdList, null);
+        setRoleTypeId_Terms(roleTypeIdList, null);
     }
 
-    public void setRoleTypeId_MatchPhrasePrefix(Collection<String> roleTypeIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("roleTypeId", roleTypeIdList);
+    public void setRoleTypeId_Terms(Collection<String> roleTypeIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("roleTypeId", roleTypeIdList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setRoleTypeId_InScope(Collection<String> roleTypeIdList) {
-        setRoleTypeId_MatchPhrasePrefix(roleTypeIdList, null);
+        setRoleTypeId_Terms(roleTypeIdList, null);
     }
 
     public void setRoleTypeId_InScope(Collection<String> roleTypeIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setRoleTypeId_MatchPhrasePrefix(roleTypeIdList, opLambda);
+        setRoleTypeId_Terms(roleTypeIdList, opLambda);
     }
 
     public void setRoleTypeId_Match(String roleTypeId) {
@@ -374,7 +375,7 @@ public abstract class BsLabelToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setRoleTypeId_Match(String roleTypeId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("roleTypeId", roleTypeId);
+        MatchQueryBuilder builder = regMatchQ("roleTypeId", roleTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -385,7 +386,7 @@ public abstract class BsLabelToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setRoleTypeId_MatchPhrase(String roleTypeId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("roleTypeId", roleTypeId);
+        MatchQueryBuilder builder = regMatchPhraseQ("roleTypeId", roleTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -396,7 +397,7 @@ public abstract class BsLabelToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setRoleTypeId_MatchPhrasePrefix(String roleTypeId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("roleTypeId", roleTypeId);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("roleTypeId", roleTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -407,7 +408,7 @@ public abstract class BsLabelToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setRoleTypeId_Fuzzy(String roleTypeId, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("roleTypeId", roleTypeId);
+        FuzzyQueryBuilder builder = regFuzzyQ("roleTypeId", roleTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -418,7 +419,7 @@ public abstract class BsLabelToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setRoleTypeId_Prefix(String roleTypeId, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("roleTypeId", roleTypeId);
+        PrefixQueryBuilder builder = regPrefixQ("roleTypeId", roleTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -429,7 +430,7 @@ public abstract class BsLabelToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setRoleTypeId_GreaterThan(String roleTypeId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("roleTypeId", ConditionKey.CK_GREATER_THAN, roleTypeId);
+        RangeQueryBuilder builder = regRangeQ("roleTypeId", ConditionKey.CK_GREATER_THAN, roleTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -440,7 +441,7 @@ public abstract class BsLabelToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setRoleTypeId_LessThan(String roleTypeId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("roleTypeId", ConditionKey.CK_LESS_THAN, roleTypeId);
+        RangeQueryBuilder builder = regRangeQ("roleTypeId", ConditionKey.CK_LESS_THAN, roleTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -451,7 +452,7 @@ public abstract class BsLabelToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setRoleTypeId_GreaterEqual(String roleTypeId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("roleTypeId", ConditionKey.CK_GREATER_EQUAL, roleTypeId);
+        RangeQueryBuilder builder = regRangeQ("roleTypeId", ConditionKey.CK_GREATER_EQUAL, roleTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -462,7 +463,7 @@ public abstract class BsLabelToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setRoleTypeId_LessEqual(String roleTypeId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("roleTypeId", ConditionKey.CK_LESS_EQUAL, roleTypeId);
+        RangeQueryBuilder builder = regRangeQ("roleTypeId", ConditionKey.CK_LESS_EQUAL, roleTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }

src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsOverlappingHostCQ.java

@@ -3,6 +3,7 @@ package org.codelibs.fess.es.cbean.cq.bs;
 import java.util.Collection;
 
 import org.codelibs.fess.es.cbean.cq.OverlappingHostCQ;
+import org.codelibs.fess.es.cbean.cf.OverlappingHostCF;
 import org.dbflute.cbean.ckey.ConditionKey;
 import org.elasticsearch.index.query.BoolQueryBuilder;
 import org.elasticsearch.index.query.FilteredQueryBuilder;
@@ -28,16 +29,17 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
         return "overlapping_host";
     }
 
-    public void filtered(FilteredCall<OverlappingHostCQ> filteredLambda) {
+    public void filtered(FilteredCall<OverlappingHostCQ, OverlappingHostCF> filteredLambda) {
         filtered(filteredLambda, null);
     }
 
-    public void filtered(FilteredCall<OverlappingHostCQ> filteredLambda, ConditionOptionCall<FilteredQueryBuilder> opLambda) {
+    public void filtered(FilteredCall<OverlappingHostCQ, OverlappingHostCF> filteredLambda,
+            ConditionOptionCall<FilteredQueryBuilder> opLambda) {
         OverlappingHostCQ query = new OverlappingHostCQ();
-        filteredLambda.callback(query);
-        if (!query.queryBuilderList.isEmpty()) {
-            // TODO filter
-            FilteredQueryBuilder builder = reqFilteredQ(query.getQuery(), null);
+        OverlappingHostCF filter = new OverlappingHostCF();
+        filteredLambda.callback(query, filter);
+        if (query.hasQueries()) {
+            FilteredQueryBuilder builder = regFilteredQ(query.getQuery(), filter.getFilter());
             if (opLambda != null) {
                 opLambda.callback(builder);
             }
@@ -53,8 +55,8 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
         OverlappingHostCQ shouldQuery = new OverlappingHostCQ();
         OverlappingHostCQ mustNotQuery = new OverlappingHostCQ();
         boolLambda.callback(mustQuery, shouldQuery, mustNotQuery);
-        if (!mustQuery.queryBuilderList.isEmpty() || !shouldQuery.queryBuilderList.isEmpty() || !mustNotQuery.queryBuilderList.isEmpty()) {
-            BoolQueryBuilder builder = reqBoolCQ(mustQuery.queryBuilderList, shouldQuery.queryBuilderList, mustNotQuery.queryBuilderList);
+        if (mustQuery.hasQueries() || shouldQuery.hasQueries() || mustNotQuery.hasQueries()) {
+            BoolQueryBuilder builder = regBoolCQ(mustQuery.queryBuilderList, shouldQuery.queryBuilderList, mustNotQuery.queryBuilderList);
             if (opLambda != null) {
                 opLambda.callback(builder);
             }
@@ -66,29 +68,29 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedBy_Term(String createdBy, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("createdBy", createdBy);
+        TermQueryBuilder builder = regTermQ("createdBy", createdBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setCreatedBy_Terms(Collection<String> createdByList) {
-        setCreatedBy_MatchPhrasePrefix(createdByList, null);
+        setCreatedBy_Terms(createdByList, null);
     }
 
-    public void setCreatedBy_MatchPhrasePrefix(Collection<String> createdByList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("createdBy", createdByList);
+    public void setCreatedBy_Terms(Collection<String> createdByList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("createdBy", createdByList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setCreatedBy_InScope(Collection<String> createdByList) {
-        setCreatedBy_MatchPhrasePrefix(createdByList, null);
+        setCreatedBy_Terms(createdByList, null);
     }
 
     public void setCreatedBy_InScope(Collection<String> createdByList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setCreatedBy_MatchPhrasePrefix(createdByList, opLambda);
+        setCreatedBy_Terms(createdByList, opLambda);
     }
 
     public void setCreatedBy_Match(String createdBy) {
@@ -96,7 +98,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedBy_Match(String createdBy, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("createdBy", createdBy);
+        MatchQueryBuilder builder = regMatchQ("createdBy", createdBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -107,7 +109,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedBy_MatchPhrase(String createdBy, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("createdBy", createdBy);
+        MatchQueryBuilder builder = regMatchPhraseQ("createdBy", createdBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -118,7 +120,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedBy_MatchPhrasePrefix(String createdBy, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("createdBy", createdBy);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("createdBy", createdBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -129,7 +131,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedBy_Fuzzy(String createdBy, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("createdBy", createdBy);
+        FuzzyQueryBuilder builder = regFuzzyQ("createdBy", createdBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -140,7 +142,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedBy_Prefix(String createdBy, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("createdBy", createdBy);
+        PrefixQueryBuilder builder = regPrefixQ("createdBy", createdBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -151,7 +153,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedBy_GreaterThan(String createdBy, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_GREATER_THAN, createdBy);
+        RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_GREATER_THAN, createdBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -162,7 +164,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedBy_LessThan(String createdBy, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_LESS_THAN, createdBy);
+        RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_LESS_THAN, createdBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -173,7 +175,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedBy_GreaterEqual(String createdBy, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy);
+        RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -184,7 +186,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedBy_LessEqual(String createdBy, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy);
+        RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -205,29 +207,29 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_Term(Long createdTime, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("createdTime", createdTime);
+        TermQueryBuilder builder = regTermQ("createdTime", createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setCreatedTime_Terms(Collection<Long> createdTimeList) {
-        setCreatedTime_MatchPhrasePrefix(createdTimeList, null);
+        setCreatedTime_Terms(createdTimeList, null);
     }
 
-    public void setCreatedTime_MatchPhrasePrefix(Collection<Long> createdTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("createdTime", createdTimeList);
+    public void setCreatedTime_Terms(Collection<Long> createdTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("createdTime", createdTimeList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setCreatedTime_InScope(Collection<Long> createdTimeList) {
-        setCreatedTime_MatchPhrasePrefix(createdTimeList, null);
+        setCreatedTime_Terms(createdTimeList, null);
     }
 
     public void setCreatedTime_InScope(Collection<Long> createdTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setCreatedTime_MatchPhrasePrefix(createdTimeList, opLambda);
+        setCreatedTime_Terms(createdTimeList, opLambda);
     }
 
     public void setCreatedTime_Match(Long createdTime) {
@@ -235,7 +237,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_Match(Long createdTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("createdTime", createdTime);
+        MatchQueryBuilder builder = regMatchQ("createdTime", createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -246,7 +248,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_MatchPhrase(Long createdTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("createdTime", createdTime);
+        MatchQueryBuilder builder = regMatchPhraseQ("createdTime", createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -257,7 +259,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_MatchPhrasePrefix(Long createdTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("createdTime", createdTime);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("createdTime", createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -268,7 +270,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_Fuzzy(Long createdTime, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("createdTime", createdTime);
+        FuzzyQueryBuilder builder = regFuzzyQ("createdTime", createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -279,7 +281,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_GreaterThan(Long createdTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_GREATER_THAN, createdTime);
+        RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_GREATER_THAN, createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -290,7 +292,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_LessThan(Long createdTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_LESS_THAN, createdTime);
+        RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_LESS_THAN, createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -301,7 +303,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_GreaterEqual(Long createdTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime);
+        RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -312,7 +314,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_LessEqual(Long createdTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime);
+        RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -333,29 +335,29 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setId_Term(String id, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("id", id);
+        TermQueryBuilder builder = regTermQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setId_Terms(Collection<String> idList) {
-        setId_MatchPhrasePrefix(idList, null);
+        setId_Terms(idList, null);
     }
 
-    public void setId_MatchPhrasePrefix(Collection<String> idList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("id", idList);
+    public void setId_Terms(Collection<String> idList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("id", idList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setId_InScope(Collection<String> idList) {
-        setId_MatchPhrasePrefix(idList, null);
+        setId_Terms(idList, null);
     }
 
     public void setId_InScope(Collection<String> idList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setId_MatchPhrasePrefix(idList, opLambda);
+        setId_Terms(idList, opLambda);
     }
 
     public void setId_Match(String id) {
@@ -363,7 +365,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setId_Match(String id, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("id", id);
+        MatchQueryBuilder builder = regMatchQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -374,7 +376,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setId_MatchPhrase(String id, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("id", id);
+        MatchQueryBuilder builder = regMatchPhraseQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -385,7 +387,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setId_MatchPhrasePrefix(String id, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("id", id);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -396,7 +398,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setId_Fuzzy(String id, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("id", id);
+        FuzzyQueryBuilder builder = regFuzzyQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -407,7 +409,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setId_Prefix(String id, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("id", id);
+        PrefixQueryBuilder builder = regPrefixQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -418,7 +420,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setId_GreaterThan(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_THAN, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_THAN, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -429,7 +431,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setId_LessThan(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_THAN, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_THAN, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -440,7 +442,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setId_GreaterEqual(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -451,7 +453,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setId_LessEqual(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_EQUAL, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_EQUAL, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -472,29 +474,29 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setOverlappingName_Term(String overlappingName, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("overlappingName", overlappingName);
+        TermQueryBuilder builder = regTermQ("overlappingName", overlappingName);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setOverlappingName_Terms(Collection<String> overlappingNameList) {
-        setOverlappingName_MatchPhrasePrefix(overlappingNameList, null);
+        setOverlappingName_Terms(overlappingNameList, null);
     }
 
-    public void setOverlappingName_MatchPhrasePrefix(Collection<String> overlappingNameList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("overlappingName", overlappingNameList);
+    public void setOverlappingName_Terms(Collection<String> overlappingNameList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("overlappingName", overlappingNameList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setOverlappingName_InScope(Collection<String> overlappingNameList) {
-        setOverlappingName_MatchPhrasePrefix(overlappingNameList, null);
+        setOverlappingName_Terms(overlappingNameList, null);
     }
 
     public void setOverlappingName_InScope(Collection<String> overlappingNameList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setOverlappingName_MatchPhrasePrefix(overlappingNameList, opLambda);
+        setOverlappingName_Terms(overlappingNameList, opLambda);
     }
 
     public void setOverlappingName_Match(String overlappingName) {
@@ -502,7 +504,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setOverlappingName_Match(String overlappingName, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("overlappingName", overlappingName);
+        MatchQueryBuilder builder = regMatchQ("overlappingName", overlappingName);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -513,7 +515,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setOverlappingName_MatchPhrase(String overlappingName, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("overlappingName", overlappingName);
+        MatchQueryBuilder builder = regMatchPhraseQ("overlappingName", overlappingName);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -524,7 +526,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setOverlappingName_MatchPhrasePrefix(String overlappingName, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("overlappingName", overlappingName);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("overlappingName", overlappingName);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -535,7 +537,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setOverlappingName_Fuzzy(String overlappingName, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("overlappingName", overlappingName);
+        FuzzyQueryBuilder builder = regFuzzyQ("overlappingName", overlappingName);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -546,7 +548,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setOverlappingName_Prefix(String overlappingName, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("overlappingName", overlappingName);
+        PrefixQueryBuilder builder = regPrefixQ("overlappingName", overlappingName);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -557,7 +559,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setOverlappingName_GreaterThan(String overlappingName, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("overlappingName", ConditionKey.CK_GREATER_THAN, overlappingName);
+        RangeQueryBuilder builder = regRangeQ("overlappingName", ConditionKey.CK_GREATER_THAN, overlappingName);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -568,7 +570,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setOverlappingName_LessThan(String overlappingName, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("overlappingName", ConditionKey.CK_LESS_THAN, overlappingName);
+        RangeQueryBuilder builder = regRangeQ("overlappingName", ConditionKey.CK_LESS_THAN, overlappingName);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -579,7 +581,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setOverlappingName_GreaterEqual(String overlappingName, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("overlappingName", ConditionKey.CK_GREATER_EQUAL, overlappingName);
+        RangeQueryBuilder builder = regRangeQ("overlappingName", ConditionKey.CK_GREATER_EQUAL, overlappingName);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -590,7 +592,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setOverlappingName_LessEqual(String overlappingName, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("overlappingName", ConditionKey.CK_LESS_EQUAL, overlappingName);
+        RangeQueryBuilder builder = regRangeQ("overlappingName", ConditionKey.CK_LESS_EQUAL, overlappingName);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -611,29 +613,29 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setRegularName_Term(String regularName, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("regularName", regularName);
+        TermQueryBuilder builder = regTermQ("regularName", regularName);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setRegularName_Terms(Collection<String> regularNameList) {
-        setRegularName_MatchPhrasePrefix(regularNameList, null);
+        setRegularName_Terms(regularNameList, null);
     }
 
-    public void setRegularName_MatchPhrasePrefix(Collection<String> regularNameList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("regularName", regularNameList);
+    public void setRegularName_Terms(Collection<String> regularNameList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("regularName", regularNameList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setRegularName_InScope(Collection<String> regularNameList) {
-        setRegularName_MatchPhrasePrefix(regularNameList, null);
+        setRegularName_Terms(regularNameList, null);
     }
 
     public void setRegularName_InScope(Collection<String> regularNameList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setRegularName_MatchPhrasePrefix(regularNameList, opLambda);
+        setRegularName_Terms(regularNameList, opLambda);
     }
 
     public void setRegularName_Match(String regularName) {
@@ -641,7 +643,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setRegularName_Match(String regularName, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("regularName", regularName);
+        MatchQueryBuilder builder = regMatchQ("regularName", regularName);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -652,7 +654,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setRegularName_MatchPhrase(String regularName, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("regularName", regularName);
+        MatchQueryBuilder builder = regMatchPhraseQ("regularName", regularName);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -663,7 +665,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setRegularName_MatchPhrasePrefix(String regularName, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("regularName", regularName);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("regularName", regularName);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -674,7 +676,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setRegularName_Fuzzy(String regularName, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("regularName", regularName);
+        FuzzyQueryBuilder builder = regFuzzyQ("regularName", regularName);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -685,7 +687,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setRegularName_Prefix(String regularName, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("regularName", regularName);
+        PrefixQueryBuilder builder = regPrefixQ("regularName", regularName);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -696,7 +698,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setRegularName_GreaterThan(String regularName, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("regularName", ConditionKey.CK_GREATER_THAN, regularName);
+        RangeQueryBuilder builder = regRangeQ("regularName", ConditionKey.CK_GREATER_THAN, regularName);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -707,7 +709,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setRegularName_LessThan(String regularName, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("regularName", ConditionKey.CK_LESS_THAN, regularName);
+        RangeQueryBuilder builder = regRangeQ("regularName", ConditionKey.CK_LESS_THAN, regularName);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -718,7 +720,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setRegularName_GreaterEqual(String regularName, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("regularName", ConditionKey.CK_GREATER_EQUAL, regularName);
+        RangeQueryBuilder builder = regRangeQ("regularName", ConditionKey.CK_GREATER_EQUAL, regularName);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -729,7 +731,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setRegularName_LessEqual(String regularName, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("regularName", ConditionKey.CK_LESS_EQUAL, regularName);
+        RangeQueryBuilder builder = regRangeQ("regularName", ConditionKey.CK_LESS_EQUAL, regularName);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -750,29 +752,29 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setSortOrder_Term(Integer sortOrder, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("sortOrder", sortOrder);
+        TermQueryBuilder builder = regTermQ("sortOrder", sortOrder);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setSortOrder_Terms(Collection<Integer> sortOrderList) {
-        setSortOrder_MatchPhrasePrefix(sortOrderList, null);
+        setSortOrder_Terms(sortOrderList, null);
     }
 
-    public void setSortOrder_MatchPhrasePrefix(Collection<Integer> sortOrderList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("sortOrder", sortOrderList);
+    public void setSortOrder_Terms(Collection<Integer> sortOrderList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("sortOrder", sortOrderList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setSortOrder_InScope(Collection<Integer> sortOrderList) {
-        setSortOrder_MatchPhrasePrefix(sortOrderList, null);
+        setSortOrder_Terms(sortOrderList, null);
     }
 
     public void setSortOrder_InScope(Collection<Integer> sortOrderList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setSortOrder_MatchPhrasePrefix(sortOrderList, opLambda);
+        setSortOrder_Terms(sortOrderList, opLambda);
     }
 
     public void setSortOrder_Match(Integer sortOrder) {
@@ -780,7 +782,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setSortOrder_Match(Integer sortOrder, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("sortOrder", sortOrder);
+        MatchQueryBuilder builder = regMatchQ("sortOrder", sortOrder);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -791,7 +793,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setSortOrder_MatchPhrase(Integer sortOrder, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("sortOrder", sortOrder);
+        MatchQueryBuilder builder = regMatchPhraseQ("sortOrder", sortOrder);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -802,7 +804,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setSortOrder_MatchPhrasePrefix(Integer sortOrder, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("sortOrder", sortOrder);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("sortOrder", sortOrder);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -813,7 +815,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setSortOrder_Fuzzy(Integer sortOrder, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("sortOrder", sortOrder);
+        FuzzyQueryBuilder builder = regFuzzyQ("sortOrder", sortOrder);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -824,7 +826,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setSortOrder_GreaterThan(Integer sortOrder, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("sortOrder", ConditionKey.CK_GREATER_THAN, sortOrder);
+        RangeQueryBuilder builder = regRangeQ("sortOrder", ConditionKey.CK_GREATER_THAN, sortOrder);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -835,7 +837,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setSortOrder_LessThan(Integer sortOrder, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("sortOrder", ConditionKey.CK_LESS_THAN, sortOrder);
+        RangeQueryBuilder builder = regRangeQ("sortOrder", ConditionKey.CK_LESS_THAN, sortOrder);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -846,7 +848,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setSortOrder_GreaterEqual(Integer sortOrder, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("sortOrder", ConditionKey.CK_GREATER_EQUAL, sortOrder);
+        RangeQueryBuilder builder = regRangeQ("sortOrder", ConditionKey.CK_GREATER_EQUAL, sortOrder);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -857,7 +859,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setSortOrder_LessEqual(Integer sortOrder, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("sortOrder", ConditionKey.CK_LESS_EQUAL, sortOrder);
+        RangeQueryBuilder builder = regRangeQ("sortOrder", ConditionKey.CK_LESS_EQUAL, sortOrder);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -878,29 +880,29 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedBy_Term(String updatedBy, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("updatedBy", updatedBy);
+        TermQueryBuilder builder = regTermQ("updatedBy", updatedBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setUpdatedBy_Terms(Collection<String> updatedByList) {
-        setUpdatedBy_MatchPhrasePrefix(updatedByList, null);
+        setUpdatedBy_Terms(updatedByList, null);
     }
 
-    public void setUpdatedBy_MatchPhrasePrefix(Collection<String> updatedByList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("updatedBy", updatedByList);
+    public void setUpdatedBy_Terms(Collection<String> updatedByList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("updatedBy", updatedByList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setUpdatedBy_InScope(Collection<String> updatedByList) {
-        setUpdatedBy_MatchPhrasePrefix(updatedByList, null);
+        setUpdatedBy_Terms(updatedByList, null);
     }
 
     public void setUpdatedBy_InScope(Collection<String> updatedByList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setUpdatedBy_MatchPhrasePrefix(updatedByList, opLambda);
+        setUpdatedBy_Terms(updatedByList, opLambda);
     }
 
     public void setUpdatedBy_Match(String updatedBy) {
@@ -908,7 +910,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedBy_Match(String updatedBy, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("updatedBy", updatedBy);
+        MatchQueryBuilder builder = regMatchQ("updatedBy", updatedBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -919,7 +921,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedBy_MatchPhrase(String updatedBy, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("updatedBy", updatedBy);
+        MatchQueryBuilder builder = regMatchPhraseQ("updatedBy", updatedBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -930,7 +932,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedBy_MatchPhrasePrefix(String updatedBy, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("updatedBy", updatedBy);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("updatedBy", updatedBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -941,7 +943,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedBy_Fuzzy(String updatedBy, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("updatedBy", updatedBy);
+        FuzzyQueryBuilder builder = regFuzzyQ("updatedBy", updatedBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -952,7 +954,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedBy_Prefix(String updatedBy, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("updatedBy", updatedBy);
+        PrefixQueryBuilder builder = regPrefixQ("updatedBy", updatedBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -963,7 +965,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedBy_GreaterThan(String updatedBy, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy);
+        RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -974,7 +976,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedBy_LessThan(String updatedBy, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy);
+        RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -985,7 +987,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedBy_GreaterEqual(String updatedBy, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy);
+        RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -996,7 +998,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedBy_LessEqual(String updatedBy, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy);
+        RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1017,29 +1019,29 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedTime_Term(Long updatedTime, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("updatedTime", updatedTime);
+        TermQueryBuilder builder = regTermQ("updatedTime", updatedTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setUpdatedTime_Terms(Collection<Long> updatedTimeList) {
-        setUpdatedTime_MatchPhrasePrefix(updatedTimeList, null);
+        setUpdatedTime_Terms(updatedTimeList, null);
     }
 
-    public void setUpdatedTime_MatchPhrasePrefix(Collection<Long> updatedTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("updatedTime", updatedTimeList);
+    public void setUpdatedTime_Terms(Collection<Long> updatedTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("updatedTime", updatedTimeList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setUpdatedTime_InScope(Collection<Long> updatedTimeList) {
-        setUpdatedTime_MatchPhrasePrefix(updatedTimeList, null);
+        setUpdatedTime_Terms(updatedTimeList, null);
     }
 
     public void setUpdatedTime_InScope(Collection<Long> updatedTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setUpdatedTime_MatchPhrasePrefix(updatedTimeList, opLambda);
+        setUpdatedTime_Terms(updatedTimeList, opLambda);
     }
 
     public void setUpdatedTime_Match(Long updatedTime) {
@@ -1047,7 +1049,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedTime_Match(Long updatedTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("updatedTime", updatedTime);
+        MatchQueryBuilder builder = regMatchQ("updatedTime", updatedTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1058,7 +1060,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedTime_MatchPhrase(Long updatedTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("updatedTime", updatedTime);
+        MatchQueryBuilder builder = regMatchPhraseQ("updatedTime", updatedTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1069,7 +1071,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedTime_MatchPhrasePrefix(Long updatedTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("updatedTime", updatedTime);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("updatedTime", updatedTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1080,7 +1082,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedTime_Fuzzy(Long updatedTime, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("updatedTime", updatedTime);
+        FuzzyQueryBuilder builder = regFuzzyQ("updatedTime", updatedTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1091,7 +1093,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedTime_GreaterThan(Long updatedTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime);
+        RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1102,7 +1104,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedTime_LessThan(Long updatedTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime);
+        RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1113,7 +1115,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedTime_GreaterEqual(Long updatedTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime);
+        RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1124,7 +1126,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedTime_LessEqual(Long updatedTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime);
+        RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }

src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsRequestHeaderCQ.java

@@ -3,6 +3,7 @@ package org.codelibs.fess.es.cbean.cq.bs;
 import java.util.Collection;
 
 import org.codelibs.fess.es.cbean.cq.RequestHeaderCQ;
+import org.codelibs.fess.es.cbean.cf.RequestHeaderCF;
 import org.dbflute.cbean.ckey.ConditionKey;
 import org.elasticsearch.index.query.BoolQueryBuilder;
 import org.elasticsearch.index.query.FilteredQueryBuilder;
@@ -28,16 +29,16 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
         return "request_header";
     }
 
-    public void filtered(FilteredCall<RequestHeaderCQ> filteredLambda) {
+    public void filtered(FilteredCall<RequestHeaderCQ, RequestHeaderCF> filteredLambda) {
         filtered(filteredLambda, null);
     }
 
-    public void filtered(FilteredCall<RequestHeaderCQ> filteredLambda, ConditionOptionCall<FilteredQueryBuilder> opLambda) {
+    public void filtered(FilteredCall<RequestHeaderCQ, RequestHeaderCF> filteredLambda, ConditionOptionCall<FilteredQueryBuilder> opLambda) {
         RequestHeaderCQ query = new RequestHeaderCQ();
-        filteredLambda.callback(query);
-        if (!query.queryBuilderList.isEmpty()) {
-            // TODO filter
-            FilteredQueryBuilder builder = reqFilteredQ(query.getQuery(), null);
+        RequestHeaderCF filter = new RequestHeaderCF();
+        filteredLambda.callback(query, filter);
+        if (query.hasQueries()) {
+            FilteredQueryBuilder builder = regFilteredQ(query.getQuery(), filter.getFilter());
             if (opLambda != null) {
                 opLambda.callback(builder);
             }
@@ -53,8 +54,8 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
         RequestHeaderCQ shouldQuery = new RequestHeaderCQ();
         RequestHeaderCQ mustNotQuery = new RequestHeaderCQ();
         boolLambda.callback(mustQuery, shouldQuery, mustNotQuery);
-        if (!mustQuery.queryBuilderList.isEmpty() || !shouldQuery.queryBuilderList.isEmpty() || !mustNotQuery.queryBuilderList.isEmpty()) {
-            BoolQueryBuilder builder = reqBoolCQ(mustQuery.queryBuilderList, shouldQuery.queryBuilderList, mustNotQuery.queryBuilderList);
+        if (mustQuery.hasQueries() || shouldQuery.hasQueries() || mustNotQuery.hasQueries()) {
+            BoolQueryBuilder builder = regBoolCQ(mustQuery.queryBuilderList, shouldQuery.queryBuilderList, mustNotQuery.queryBuilderList);
             if (opLambda != null) {
                 opLambda.callback(builder);
             }
@@ -66,29 +67,29 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedBy_Term(String createdBy, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("createdBy", createdBy);
+        TermQueryBuilder builder = regTermQ("createdBy", createdBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setCreatedBy_Terms(Collection<String> createdByList) {
-        setCreatedBy_MatchPhrasePrefix(createdByList, null);
+        setCreatedBy_Terms(createdByList, null);
     }
 
-    public void setCreatedBy_MatchPhrasePrefix(Collection<String> createdByList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("createdBy", createdByList);
+    public void setCreatedBy_Terms(Collection<String> createdByList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("createdBy", createdByList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setCreatedBy_InScope(Collection<String> createdByList) {
-        setCreatedBy_MatchPhrasePrefix(createdByList, null);
+        setCreatedBy_Terms(createdByList, null);
     }
 
     public void setCreatedBy_InScope(Collection<String> createdByList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setCreatedBy_MatchPhrasePrefix(createdByList, opLambda);
+        setCreatedBy_Terms(createdByList, opLambda);
     }
 
     public void setCreatedBy_Match(String createdBy) {
@@ -96,7 +97,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedBy_Match(String createdBy, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("createdBy", createdBy);
+        MatchQueryBuilder builder = regMatchQ("createdBy", createdBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -107,7 +108,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedBy_MatchPhrase(String createdBy, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("createdBy", createdBy);
+        MatchQueryBuilder builder = regMatchPhraseQ("createdBy", createdBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -118,7 +119,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedBy_MatchPhrasePrefix(String createdBy, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("createdBy", createdBy);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("createdBy", createdBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -129,7 +130,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedBy_Fuzzy(String createdBy, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("createdBy", createdBy);
+        FuzzyQueryBuilder builder = regFuzzyQ("createdBy", createdBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -140,7 +141,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedBy_Prefix(String createdBy, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("createdBy", createdBy);
+        PrefixQueryBuilder builder = regPrefixQ("createdBy", createdBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -151,7 +152,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedBy_GreaterThan(String createdBy, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_GREATER_THAN, createdBy);
+        RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_GREATER_THAN, createdBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -162,7 +163,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedBy_LessThan(String createdBy, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_LESS_THAN, createdBy);
+        RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_LESS_THAN, createdBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -173,7 +174,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedBy_GreaterEqual(String createdBy, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy);
+        RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -184,7 +185,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedBy_LessEqual(String createdBy, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy);
+        RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -205,29 +206,29 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_Term(Long createdTime, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("createdTime", createdTime);
+        TermQueryBuilder builder = regTermQ("createdTime", createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setCreatedTime_Terms(Collection<Long> createdTimeList) {
-        setCreatedTime_MatchPhrasePrefix(createdTimeList, null);
+        setCreatedTime_Terms(createdTimeList, null);
     }
 
-    public void setCreatedTime_MatchPhrasePrefix(Collection<Long> createdTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("createdTime", createdTimeList);
+    public void setCreatedTime_Terms(Collection<Long> createdTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("createdTime", createdTimeList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setCreatedTime_InScope(Collection<Long> createdTimeList) {
-        setCreatedTime_MatchPhrasePrefix(createdTimeList, null);
+        setCreatedTime_Terms(createdTimeList, null);
     }
 
     public void setCreatedTime_InScope(Collection<Long> createdTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setCreatedTime_MatchPhrasePrefix(createdTimeList, opLambda);
+        setCreatedTime_Terms(createdTimeList, opLambda);
     }
 
     public void setCreatedTime_Match(Long createdTime) {
@@ -235,7 +236,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_Match(Long createdTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("createdTime", createdTime);
+        MatchQueryBuilder builder = regMatchQ("createdTime", createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -246,7 +247,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_MatchPhrase(Long createdTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("createdTime", createdTime);
+        MatchQueryBuilder builder = regMatchPhraseQ("createdTime", createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -257,7 +258,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_MatchPhrasePrefix(Long createdTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("createdTime", createdTime);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("createdTime", createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -268,7 +269,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_Fuzzy(Long createdTime, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("createdTime", createdTime);
+        FuzzyQueryBuilder builder = regFuzzyQ("createdTime", createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -279,7 +280,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_GreaterThan(Long createdTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_GREATER_THAN, createdTime);
+        RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_GREATER_THAN, createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -290,7 +291,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_LessThan(Long createdTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_LESS_THAN, createdTime);
+        RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_LESS_THAN, createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -301,7 +302,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_GreaterEqual(Long createdTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime);
+        RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -312,7 +313,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_LessEqual(Long createdTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime);
+        RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -333,29 +334,29 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setId_Term(String id, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("id", id);
+        TermQueryBuilder builder = regTermQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setId_Terms(Collection<String> idList) {
-        setId_MatchPhrasePrefix(idList, null);
+        setId_Terms(idList, null);
     }
 
-    public void setId_MatchPhrasePrefix(Collection<String> idList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("id", idList);
+    public void setId_Terms(Collection<String> idList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("id", idList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setId_InScope(Collection<String> idList) {
-        setId_MatchPhrasePrefix(idList, null);
+        setId_Terms(idList, null);
     }
 
     public void setId_InScope(Collection<String> idList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setId_MatchPhrasePrefix(idList, opLambda);
+        setId_Terms(idList, opLambda);
     }
 
     public void setId_Match(String id) {
@@ -363,7 +364,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setId_Match(String id, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("id", id);
+        MatchQueryBuilder builder = regMatchQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -374,7 +375,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setId_MatchPhrase(String id, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("id", id);
+        MatchQueryBuilder builder = regMatchPhraseQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -385,7 +386,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setId_MatchPhrasePrefix(String id, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("id", id);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -396,7 +397,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setId_Fuzzy(String id, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("id", id);
+        FuzzyQueryBuilder builder = regFuzzyQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -407,7 +408,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setId_Prefix(String id, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("id", id);
+        PrefixQueryBuilder builder = regPrefixQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -418,7 +419,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setId_GreaterThan(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_THAN, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_THAN, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -429,7 +430,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setId_LessThan(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_THAN, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_THAN, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -440,7 +441,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setId_GreaterEqual(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -451,7 +452,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setId_LessEqual(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_EQUAL, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_EQUAL, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -472,29 +473,29 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setName_Term(String name, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("name", name);
+        TermQueryBuilder builder = regTermQ("name", name);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setName_Terms(Collection<String> nameList) {
-        setName_MatchPhrasePrefix(nameList, null);
+        setName_Terms(nameList, null);
     }
 
-    public void setName_MatchPhrasePrefix(Collection<String> nameList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("name", nameList);
+    public void setName_Terms(Collection<String> nameList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("name", nameList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setName_InScope(Collection<String> nameList) {
-        setName_MatchPhrasePrefix(nameList, null);
+        setName_Terms(nameList, null);
     }
 
     public void setName_InScope(Collection<String> nameList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setName_MatchPhrasePrefix(nameList, opLambda);
+        setName_Terms(nameList, opLambda);
     }
 
     public void setName_Match(String name) {
@@ -502,7 +503,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setName_Match(String name, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("name", name);
+        MatchQueryBuilder builder = regMatchQ("name", name);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -513,7 +514,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setName_MatchPhrase(String name, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("name", name);
+        MatchQueryBuilder builder = regMatchPhraseQ("name", name);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -524,7 +525,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setName_MatchPhrasePrefix(String name, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("name", name);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("name", name);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -535,7 +536,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setName_Fuzzy(String name, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("name", name);
+        FuzzyQueryBuilder builder = regFuzzyQ("name", name);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -546,7 +547,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setName_Prefix(String name, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("name", name);
+        PrefixQueryBuilder builder = regPrefixQ("name", name);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -557,7 +558,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setName_GreaterThan(String name, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("name", ConditionKey.CK_GREATER_THAN, name);
+        RangeQueryBuilder builder = regRangeQ("name", ConditionKey.CK_GREATER_THAN, name);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -568,7 +569,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setName_LessThan(String name, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("name", ConditionKey.CK_LESS_THAN, name);
+        RangeQueryBuilder builder = regRangeQ("name", ConditionKey.CK_LESS_THAN, name);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -579,7 +580,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setName_GreaterEqual(String name, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("name", ConditionKey.CK_GREATER_EQUAL, name);
+        RangeQueryBuilder builder = regRangeQ("name", ConditionKey.CK_GREATER_EQUAL, name);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -590,7 +591,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setName_LessEqual(String name, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("name", ConditionKey.CK_LESS_EQUAL, name);
+        RangeQueryBuilder builder = regRangeQ("name", ConditionKey.CK_LESS_EQUAL, name);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -611,29 +612,29 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedBy_Term(String updatedBy, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("updatedBy", updatedBy);
+        TermQueryBuilder builder = regTermQ("updatedBy", updatedBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setUpdatedBy_Terms(Collection<String> updatedByList) {
-        setUpdatedBy_MatchPhrasePrefix(updatedByList, null);
+        setUpdatedBy_Terms(updatedByList, null);
     }
 
-    public void setUpdatedBy_MatchPhrasePrefix(Collection<String> updatedByList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("updatedBy", updatedByList);
+    public void setUpdatedBy_Terms(Collection<String> updatedByList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("updatedBy", updatedByList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setUpdatedBy_InScope(Collection<String> updatedByList) {
-        setUpdatedBy_MatchPhrasePrefix(updatedByList, null);
+        setUpdatedBy_Terms(updatedByList, null);
     }
 
     public void setUpdatedBy_InScope(Collection<String> updatedByList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setUpdatedBy_MatchPhrasePrefix(updatedByList, opLambda);
+        setUpdatedBy_Terms(updatedByList, opLambda);
     }
 
     public void setUpdatedBy_Match(String updatedBy) {
@@ -641,7 +642,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedBy_Match(String updatedBy, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("updatedBy", updatedBy);
+        MatchQueryBuilder builder = regMatchQ("updatedBy", updatedBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -652,7 +653,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedBy_MatchPhrase(String updatedBy, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("updatedBy", updatedBy);
+        MatchQueryBuilder builder = regMatchPhraseQ("updatedBy", updatedBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -663,7 +664,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedBy_MatchPhrasePrefix(String updatedBy, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("updatedBy", updatedBy);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("updatedBy", updatedBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -674,7 +675,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedBy_Fuzzy(String updatedBy, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("updatedBy", updatedBy);
+        FuzzyQueryBuilder builder = regFuzzyQ("updatedBy", updatedBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -685,7 +686,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedBy_Prefix(String updatedBy, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("updatedBy", updatedBy);
+        PrefixQueryBuilder builder = regPrefixQ("updatedBy", updatedBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -696,7 +697,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedBy_GreaterThan(String updatedBy, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy);
+        RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -707,7 +708,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedBy_LessThan(String updatedBy, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy);
+        RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -718,7 +719,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedBy_GreaterEqual(String updatedBy, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy);
+        RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -729,7 +730,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedBy_LessEqual(String updatedBy, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy);
+        RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -750,29 +751,29 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedTime_Term(Long updatedTime, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("updatedTime", updatedTime);
+        TermQueryBuilder builder = regTermQ("updatedTime", updatedTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setUpdatedTime_Terms(Collection<Long> updatedTimeList) {
-        setUpdatedTime_MatchPhrasePrefix(updatedTimeList, null);
+        setUpdatedTime_Terms(updatedTimeList, null);
     }
 
-    public void setUpdatedTime_MatchPhrasePrefix(Collection<Long> updatedTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("updatedTime", updatedTimeList);
+    public void setUpdatedTime_Terms(Collection<Long> updatedTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("updatedTime", updatedTimeList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setUpdatedTime_InScope(Collection<Long> updatedTimeList) {
-        setUpdatedTime_MatchPhrasePrefix(updatedTimeList, null);
+        setUpdatedTime_Terms(updatedTimeList, null);
     }
 
     public void setUpdatedTime_InScope(Collection<Long> updatedTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setUpdatedTime_MatchPhrasePrefix(updatedTimeList, opLambda);
+        setUpdatedTime_Terms(updatedTimeList, opLambda);
     }
 
     public void setUpdatedTime_Match(Long updatedTime) {
@@ -780,7 +781,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedTime_Match(Long updatedTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("updatedTime", updatedTime);
+        MatchQueryBuilder builder = regMatchQ("updatedTime", updatedTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -791,7 +792,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedTime_MatchPhrase(Long updatedTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("updatedTime", updatedTime);
+        MatchQueryBuilder builder = regMatchPhraseQ("updatedTime", updatedTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -802,7 +803,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedTime_MatchPhrasePrefix(Long updatedTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("updatedTime", updatedTime);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("updatedTime", updatedTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -813,7 +814,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedTime_Fuzzy(Long updatedTime, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("updatedTime", updatedTime);
+        FuzzyQueryBuilder builder = regFuzzyQ("updatedTime", updatedTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -824,7 +825,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedTime_GreaterThan(Long updatedTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime);
+        RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -835,7 +836,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedTime_LessThan(Long updatedTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime);
+        RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -846,7 +847,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedTime_GreaterEqual(Long updatedTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime);
+        RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -857,7 +858,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedTime_LessEqual(Long updatedTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime);
+        RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -878,29 +879,29 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setValue_Term(String value, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("value", value);
+        TermQueryBuilder builder = regTermQ("value", value);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setValue_Terms(Collection<String> valueList) {
-        setValue_MatchPhrasePrefix(valueList, null);
+        setValue_Terms(valueList, null);
     }
 
-    public void setValue_MatchPhrasePrefix(Collection<String> valueList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("value", valueList);
+    public void setValue_Terms(Collection<String> valueList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("value", valueList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setValue_InScope(Collection<String> valueList) {
-        setValue_MatchPhrasePrefix(valueList, null);
+        setValue_Terms(valueList, null);
     }
 
     public void setValue_InScope(Collection<String> valueList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setValue_MatchPhrasePrefix(valueList, opLambda);
+        setValue_Terms(valueList, opLambda);
     }
 
     public void setValue_Match(String value) {
@@ -908,7 +909,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setValue_Match(String value, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("value", value);
+        MatchQueryBuilder builder = regMatchQ("value", value);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -919,7 +920,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setValue_MatchPhrase(String value, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("value", value);
+        MatchQueryBuilder builder = regMatchPhraseQ("value", value);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -930,7 +931,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setValue_MatchPhrasePrefix(String value, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("value", value);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("value", value);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -941,7 +942,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setValue_Fuzzy(String value, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("value", value);
+        FuzzyQueryBuilder builder = regFuzzyQ("value", value);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -952,7 +953,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setValue_Prefix(String value, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("value", value);
+        PrefixQueryBuilder builder = regPrefixQ("value", value);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -963,7 +964,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setValue_GreaterThan(String value, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("value", ConditionKey.CK_GREATER_THAN, value);
+        RangeQueryBuilder builder = regRangeQ("value", ConditionKey.CK_GREATER_THAN, value);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -974,7 +975,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setValue_LessThan(String value, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("value", ConditionKey.CK_LESS_THAN, value);
+        RangeQueryBuilder builder = regRangeQ("value", ConditionKey.CK_LESS_THAN, value);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -985,7 +986,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setValue_GreaterEqual(String value, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("value", ConditionKey.CK_GREATER_EQUAL, value);
+        RangeQueryBuilder builder = regRangeQ("value", ConditionKey.CK_GREATER_EQUAL, value);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -996,7 +997,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setValue_LessEqual(String value, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("value", ConditionKey.CK_LESS_EQUAL, value);
+        RangeQueryBuilder builder = regRangeQ("value", ConditionKey.CK_LESS_EQUAL, value);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1017,29 +1018,29 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setWebConfigId_Term(String webConfigId, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("webConfigId", webConfigId);
+        TermQueryBuilder builder = regTermQ("webConfigId", webConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setWebConfigId_Terms(Collection<String> webConfigIdList) {
-        setWebConfigId_MatchPhrasePrefix(webConfigIdList, null);
+        setWebConfigId_Terms(webConfigIdList, null);
     }
 
-    public void setWebConfigId_MatchPhrasePrefix(Collection<String> webConfigIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("webConfigId", webConfigIdList);
+    public void setWebConfigId_Terms(Collection<String> webConfigIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("webConfigId", webConfigIdList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setWebConfigId_InScope(Collection<String> webConfigIdList) {
-        setWebConfigId_MatchPhrasePrefix(webConfigIdList, null);
+        setWebConfigId_Terms(webConfigIdList, null);
     }
 
     public void setWebConfigId_InScope(Collection<String> webConfigIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setWebConfigId_MatchPhrasePrefix(webConfigIdList, opLambda);
+        setWebConfigId_Terms(webConfigIdList, opLambda);
     }
 
     public void setWebConfigId_Match(String webConfigId) {
@@ -1047,7 +1048,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setWebConfigId_Match(String webConfigId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("webConfigId", webConfigId);
+        MatchQueryBuilder builder = regMatchQ("webConfigId", webConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1058,7 +1059,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setWebConfigId_MatchPhrase(String webConfigId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("webConfigId", webConfigId);
+        MatchQueryBuilder builder = regMatchPhraseQ("webConfigId", webConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1069,7 +1070,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setWebConfigId_MatchPhrasePrefix(String webConfigId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("webConfigId", webConfigId);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("webConfigId", webConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1080,7 +1081,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setWebConfigId_Fuzzy(String webConfigId, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("webConfigId", webConfigId);
+        FuzzyQueryBuilder builder = regFuzzyQ("webConfigId", webConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1091,7 +1092,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setWebConfigId_Prefix(String webConfigId, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("webConfigId", webConfigId);
+        PrefixQueryBuilder builder = regPrefixQ("webConfigId", webConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1102,7 +1103,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setWebConfigId_GreaterThan(String webConfigId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("webConfigId", ConditionKey.CK_GREATER_THAN, webConfigId);
+        RangeQueryBuilder builder = regRangeQ("webConfigId", ConditionKey.CK_GREATER_THAN, webConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1113,7 +1114,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setWebConfigId_LessThan(String webConfigId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("webConfigId", ConditionKey.CK_LESS_THAN, webConfigId);
+        RangeQueryBuilder builder = regRangeQ("webConfigId", ConditionKey.CK_LESS_THAN, webConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1124,7 +1125,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setWebConfigId_GreaterEqual(String webConfigId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("webConfigId", ConditionKey.CK_GREATER_EQUAL, webConfigId);
+        RangeQueryBuilder builder = regRangeQ("webConfigId", ConditionKey.CK_GREATER_EQUAL, webConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1135,7 +1136,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery {
     }
 
     public void setWebConfigId_LessEqual(String webConfigId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("webConfigId", ConditionKey.CK_LESS_EQUAL, webConfigId);
+        RangeQueryBuilder builder = regRangeQ("webConfigId", ConditionKey.CK_LESS_EQUAL, webConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }

src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsRoleTypeCQ.java

@@ -3,6 +3,7 @@ package org.codelibs.fess.es.cbean.cq.bs;
 import java.util.Collection;
 
 import org.codelibs.fess.es.cbean.cq.RoleTypeCQ;
+import org.codelibs.fess.es.cbean.cf.RoleTypeCF;
 import org.dbflute.cbean.ckey.ConditionKey;
 import org.elasticsearch.index.query.BoolQueryBuilder;
 import org.elasticsearch.index.query.FilteredQueryBuilder;
@@ -28,16 +29,16 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
         return "role_type";
     }
 
-    public void filtered(FilteredCall<RoleTypeCQ> filteredLambda) {
+    public void filtered(FilteredCall<RoleTypeCQ, RoleTypeCF> filteredLambda) {
         filtered(filteredLambda, null);
     }
 
-    public void filtered(FilteredCall<RoleTypeCQ> filteredLambda, ConditionOptionCall<FilteredQueryBuilder> opLambda) {
+    public void filtered(FilteredCall<RoleTypeCQ, RoleTypeCF> filteredLambda, ConditionOptionCall<FilteredQueryBuilder> opLambda) {
         RoleTypeCQ query = new RoleTypeCQ();
-        filteredLambda.callback(query);
-        if (!query.queryBuilderList.isEmpty()) {
-            // TODO filter
-            FilteredQueryBuilder builder = reqFilteredQ(query.getQuery(), null);
+        RoleTypeCF filter = new RoleTypeCF();
+        filteredLambda.callback(query, filter);
+        if (query.hasQueries()) {
+            FilteredQueryBuilder builder = regFilteredQ(query.getQuery(), filter.getFilter());
             if (opLambda != null) {
                 opLambda.callback(builder);
             }
@@ -53,8 +54,8 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
         RoleTypeCQ shouldQuery = new RoleTypeCQ();
         RoleTypeCQ mustNotQuery = new RoleTypeCQ();
         boolLambda.callback(mustQuery, shouldQuery, mustNotQuery);
-        if (!mustQuery.queryBuilderList.isEmpty() || !shouldQuery.queryBuilderList.isEmpty() || !mustNotQuery.queryBuilderList.isEmpty()) {
-            BoolQueryBuilder builder = reqBoolCQ(mustQuery.queryBuilderList, shouldQuery.queryBuilderList, mustNotQuery.queryBuilderList);
+        if (mustQuery.hasQueries() || shouldQuery.hasQueries() || mustNotQuery.hasQueries()) {
+            BoolQueryBuilder builder = regBoolCQ(mustQuery.queryBuilderList, shouldQuery.queryBuilderList, mustNotQuery.queryBuilderList);
             if (opLambda != null) {
                 opLambda.callback(builder);
             }
@@ -66,29 +67,29 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedBy_Term(String createdBy, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("createdBy", createdBy);
+        TermQueryBuilder builder = regTermQ("createdBy", createdBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setCreatedBy_Terms(Collection<String> createdByList) {
-        setCreatedBy_MatchPhrasePrefix(createdByList, null);
+        setCreatedBy_Terms(createdByList, null);
     }
 
-    public void setCreatedBy_MatchPhrasePrefix(Collection<String> createdByList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("createdBy", createdByList);
+    public void setCreatedBy_Terms(Collection<String> createdByList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("createdBy", createdByList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setCreatedBy_InScope(Collection<String> createdByList) {
-        setCreatedBy_MatchPhrasePrefix(createdByList, null);
+        setCreatedBy_Terms(createdByList, null);
     }
 
     public void setCreatedBy_InScope(Collection<String> createdByList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setCreatedBy_MatchPhrasePrefix(createdByList, opLambda);
+        setCreatedBy_Terms(createdByList, opLambda);
     }
 
     public void setCreatedBy_Match(String createdBy) {
@@ -96,7 +97,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedBy_Match(String createdBy, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("createdBy", createdBy);
+        MatchQueryBuilder builder = regMatchQ("createdBy", createdBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -107,7 +108,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedBy_MatchPhrase(String createdBy, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("createdBy", createdBy);
+        MatchQueryBuilder builder = regMatchPhraseQ("createdBy", createdBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -118,7 +119,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedBy_MatchPhrasePrefix(String createdBy, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("createdBy", createdBy);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("createdBy", createdBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -129,7 +130,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedBy_Fuzzy(String createdBy, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("createdBy", createdBy);
+        FuzzyQueryBuilder builder = regFuzzyQ("createdBy", createdBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -140,7 +141,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedBy_Prefix(String createdBy, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("createdBy", createdBy);
+        PrefixQueryBuilder builder = regPrefixQ("createdBy", createdBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -151,7 +152,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedBy_GreaterThan(String createdBy, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_GREATER_THAN, createdBy);
+        RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_GREATER_THAN, createdBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -162,7 +163,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedBy_LessThan(String createdBy, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_LESS_THAN, createdBy);
+        RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_LESS_THAN, createdBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -173,7 +174,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedBy_GreaterEqual(String createdBy, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy);
+        RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -184,7 +185,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedBy_LessEqual(String createdBy, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy);
+        RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -205,29 +206,29 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_Term(Long createdTime, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("createdTime", createdTime);
+        TermQueryBuilder builder = regTermQ("createdTime", createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setCreatedTime_Terms(Collection<Long> createdTimeList) {
-        setCreatedTime_MatchPhrasePrefix(createdTimeList, null);
+        setCreatedTime_Terms(createdTimeList, null);
     }
 
-    public void setCreatedTime_MatchPhrasePrefix(Collection<Long> createdTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("createdTime", createdTimeList);
+    public void setCreatedTime_Terms(Collection<Long> createdTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("createdTime", createdTimeList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setCreatedTime_InScope(Collection<Long> createdTimeList) {
-        setCreatedTime_MatchPhrasePrefix(createdTimeList, null);
+        setCreatedTime_Terms(createdTimeList, null);
     }
 
     public void setCreatedTime_InScope(Collection<Long> createdTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setCreatedTime_MatchPhrasePrefix(createdTimeList, opLambda);
+        setCreatedTime_Terms(createdTimeList, opLambda);
     }
 
     public void setCreatedTime_Match(Long createdTime) {
@@ -235,7 +236,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_Match(Long createdTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("createdTime", createdTime);
+        MatchQueryBuilder builder = regMatchQ("createdTime", createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -246,7 +247,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_MatchPhrase(Long createdTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("createdTime", createdTime);
+        MatchQueryBuilder builder = regMatchPhraseQ("createdTime", createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -257,7 +258,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_MatchPhrasePrefix(Long createdTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("createdTime", createdTime);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("createdTime", createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -268,7 +269,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_Fuzzy(Long createdTime, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("createdTime", createdTime);
+        FuzzyQueryBuilder builder = regFuzzyQ("createdTime", createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -279,7 +280,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_GreaterThan(Long createdTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_GREATER_THAN, createdTime);
+        RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_GREATER_THAN, createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -290,7 +291,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_LessThan(Long createdTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_LESS_THAN, createdTime);
+        RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_LESS_THAN, createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -301,7 +302,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_GreaterEqual(Long createdTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime);
+        RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -312,7 +313,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_LessEqual(Long createdTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime);
+        RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -333,29 +334,29 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setId_Term(String id, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("id", id);
+        TermQueryBuilder builder = regTermQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setId_Terms(Collection<String> idList) {
-        setId_MatchPhrasePrefix(idList, null);
+        setId_Terms(idList, null);
     }
 
-    public void setId_MatchPhrasePrefix(Collection<String> idList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("id", idList);
+    public void setId_Terms(Collection<String> idList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("id", idList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setId_InScope(Collection<String> idList) {
-        setId_MatchPhrasePrefix(idList, null);
+        setId_Terms(idList, null);
     }
 
     public void setId_InScope(Collection<String> idList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setId_MatchPhrasePrefix(idList, opLambda);
+        setId_Terms(idList, opLambda);
     }
 
     public void setId_Match(String id) {
@@ -363,7 +364,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setId_Match(String id, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("id", id);
+        MatchQueryBuilder builder = regMatchQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -374,7 +375,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setId_MatchPhrase(String id, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("id", id);
+        MatchQueryBuilder builder = regMatchPhraseQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -385,7 +386,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setId_MatchPhrasePrefix(String id, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("id", id);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -396,7 +397,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setId_Fuzzy(String id, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("id", id);
+        FuzzyQueryBuilder builder = regFuzzyQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -407,7 +408,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setId_Prefix(String id, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("id", id);
+        PrefixQueryBuilder builder = regPrefixQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -418,7 +419,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setId_GreaterThan(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_THAN, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_THAN, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -429,7 +430,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setId_LessThan(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_THAN, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_THAN, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -440,7 +441,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setId_GreaterEqual(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -451,7 +452,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setId_LessEqual(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_EQUAL, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_EQUAL, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -472,29 +473,29 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setName_Term(String name, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("name", name);
+        TermQueryBuilder builder = regTermQ("name", name);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setName_Terms(Collection<String> nameList) {
-        setName_MatchPhrasePrefix(nameList, null);
+        setName_Terms(nameList, null);
     }
 
-    public void setName_MatchPhrasePrefix(Collection<String> nameList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("name", nameList);
+    public void setName_Terms(Collection<String> nameList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("name", nameList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setName_InScope(Collection<String> nameList) {
-        setName_MatchPhrasePrefix(nameList, null);
+        setName_Terms(nameList, null);
     }
 
     public void setName_InScope(Collection<String> nameList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setName_MatchPhrasePrefix(nameList, opLambda);
+        setName_Terms(nameList, opLambda);
     }
 
     public void setName_Match(String name) {
@@ -502,7 +503,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setName_Match(String name, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("name", name);
+        MatchQueryBuilder builder = regMatchQ("name", name);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -513,7 +514,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setName_MatchPhrase(String name, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("name", name);
+        MatchQueryBuilder builder = regMatchPhraseQ("name", name);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -524,7 +525,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setName_MatchPhrasePrefix(String name, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("name", name);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("name", name);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -535,7 +536,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setName_Fuzzy(String name, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("name", name);
+        FuzzyQueryBuilder builder = regFuzzyQ("name", name);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -546,7 +547,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setName_Prefix(String name, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("name", name);
+        PrefixQueryBuilder builder = regPrefixQ("name", name);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -557,7 +558,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setName_GreaterThan(String name, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("name", ConditionKey.CK_GREATER_THAN, name);
+        RangeQueryBuilder builder = regRangeQ("name", ConditionKey.CK_GREATER_THAN, name);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -568,7 +569,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setName_LessThan(String name, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("name", ConditionKey.CK_LESS_THAN, name);
+        RangeQueryBuilder builder = regRangeQ("name", ConditionKey.CK_LESS_THAN, name);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -579,7 +580,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setName_GreaterEqual(String name, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("name", ConditionKey.CK_GREATER_EQUAL, name);
+        RangeQueryBuilder builder = regRangeQ("name", ConditionKey.CK_GREATER_EQUAL, name);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -590,7 +591,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setName_LessEqual(String name, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("name", ConditionKey.CK_LESS_EQUAL, name);
+        RangeQueryBuilder builder = regRangeQ("name", ConditionKey.CK_LESS_EQUAL, name);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -611,29 +612,29 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setSortOrder_Term(Integer sortOrder, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("sortOrder", sortOrder);
+        TermQueryBuilder builder = regTermQ("sortOrder", sortOrder);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setSortOrder_Terms(Collection<Integer> sortOrderList) {
-        setSortOrder_MatchPhrasePrefix(sortOrderList, null);
+        setSortOrder_Terms(sortOrderList, null);
     }
 
-    public void setSortOrder_MatchPhrasePrefix(Collection<Integer> sortOrderList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("sortOrder", sortOrderList);
+    public void setSortOrder_Terms(Collection<Integer> sortOrderList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("sortOrder", sortOrderList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setSortOrder_InScope(Collection<Integer> sortOrderList) {
-        setSortOrder_MatchPhrasePrefix(sortOrderList, null);
+        setSortOrder_Terms(sortOrderList, null);
     }
 
     public void setSortOrder_InScope(Collection<Integer> sortOrderList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setSortOrder_MatchPhrasePrefix(sortOrderList, opLambda);
+        setSortOrder_Terms(sortOrderList, opLambda);
     }
 
     public void setSortOrder_Match(Integer sortOrder) {
@@ -641,7 +642,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setSortOrder_Match(Integer sortOrder, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("sortOrder", sortOrder);
+        MatchQueryBuilder builder = regMatchQ("sortOrder", sortOrder);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -652,7 +653,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setSortOrder_MatchPhrase(Integer sortOrder, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("sortOrder", sortOrder);
+        MatchQueryBuilder builder = regMatchPhraseQ("sortOrder", sortOrder);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -663,7 +664,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setSortOrder_MatchPhrasePrefix(Integer sortOrder, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("sortOrder", sortOrder);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("sortOrder", sortOrder);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -674,7 +675,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setSortOrder_Fuzzy(Integer sortOrder, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("sortOrder", sortOrder);
+        FuzzyQueryBuilder builder = regFuzzyQ("sortOrder", sortOrder);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -685,7 +686,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setSortOrder_GreaterThan(Integer sortOrder, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("sortOrder", ConditionKey.CK_GREATER_THAN, sortOrder);
+        RangeQueryBuilder builder = regRangeQ("sortOrder", ConditionKey.CK_GREATER_THAN, sortOrder);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -696,7 +697,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setSortOrder_LessThan(Integer sortOrder, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("sortOrder", ConditionKey.CK_LESS_THAN, sortOrder);
+        RangeQueryBuilder builder = regRangeQ("sortOrder", ConditionKey.CK_LESS_THAN, sortOrder);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -707,7 +708,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setSortOrder_GreaterEqual(Integer sortOrder, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("sortOrder", ConditionKey.CK_GREATER_EQUAL, sortOrder);
+        RangeQueryBuilder builder = regRangeQ("sortOrder", ConditionKey.CK_GREATER_EQUAL, sortOrder);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -718,7 +719,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setSortOrder_LessEqual(Integer sortOrder, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("sortOrder", ConditionKey.CK_LESS_EQUAL, sortOrder);
+        RangeQueryBuilder builder = regRangeQ("sortOrder", ConditionKey.CK_LESS_EQUAL, sortOrder);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -739,29 +740,29 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedBy_Term(String updatedBy, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("updatedBy", updatedBy);
+        TermQueryBuilder builder = regTermQ("updatedBy", updatedBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setUpdatedBy_Terms(Collection<String> updatedByList) {
-        setUpdatedBy_MatchPhrasePrefix(updatedByList, null);
+        setUpdatedBy_Terms(updatedByList, null);
     }
 
-    public void setUpdatedBy_MatchPhrasePrefix(Collection<String> updatedByList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("updatedBy", updatedByList);
+    public void setUpdatedBy_Terms(Collection<String> updatedByList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("updatedBy", updatedByList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setUpdatedBy_InScope(Collection<String> updatedByList) {
-        setUpdatedBy_MatchPhrasePrefix(updatedByList, null);
+        setUpdatedBy_Terms(updatedByList, null);
     }
 
     public void setUpdatedBy_InScope(Collection<String> updatedByList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setUpdatedBy_MatchPhrasePrefix(updatedByList, opLambda);
+        setUpdatedBy_Terms(updatedByList, opLambda);
     }
 
     public void setUpdatedBy_Match(String updatedBy) {
@@ -769,7 +770,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedBy_Match(String updatedBy, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("updatedBy", updatedBy);
+        MatchQueryBuilder builder = regMatchQ("updatedBy", updatedBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -780,7 +781,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedBy_MatchPhrase(String updatedBy, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("updatedBy", updatedBy);
+        MatchQueryBuilder builder = regMatchPhraseQ("updatedBy", updatedBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -791,7 +792,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedBy_MatchPhrasePrefix(String updatedBy, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("updatedBy", updatedBy);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("updatedBy", updatedBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -802,7 +803,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedBy_Fuzzy(String updatedBy, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("updatedBy", updatedBy);
+        FuzzyQueryBuilder builder = regFuzzyQ("updatedBy", updatedBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -813,7 +814,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedBy_Prefix(String updatedBy, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("updatedBy", updatedBy);
+        PrefixQueryBuilder builder = regPrefixQ("updatedBy", updatedBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -824,7 +825,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedBy_GreaterThan(String updatedBy, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy);
+        RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -835,7 +836,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedBy_LessThan(String updatedBy, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy);
+        RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -846,7 +847,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedBy_GreaterEqual(String updatedBy, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy);
+        RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -857,7 +858,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedBy_LessEqual(String updatedBy, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy);
+        RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -878,29 +879,29 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedTime_Term(Long updatedTime, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("updatedTime", updatedTime);
+        TermQueryBuilder builder = regTermQ("updatedTime", updatedTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setUpdatedTime_Terms(Collection<Long> updatedTimeList) {
-        setUpdatedTime_MatchPhrasePrefix(updatedTimeList, null);
+        setUpdatedTime_Terms(updatedTimeList, null);
     }
 
-    public void setUpdatedTime_MatchPhrasePrefix(Collection<Long> updatedTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("updatedTime", updatedTimeList);
+    public void setUpdatedTime_Terms(Collection<Long> updatedTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("updatedTime", updatedTimeList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setUpdatedTime_InScope(Collection<Long> updatedTimeList) {
-        setUpdatedTime_MatchPhrasePrefix(updatedTimeList, null);
+        setUpdatedTime_Terms(updatedTimeList, null);
     }
 
     public void setUpdatedTime_InScope(Collection<Long> updatedTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setUpdatedTime_MatchPhrasePrefix(updatedTimeList, opLambda);
+        setUpdatedTime_Terms(updatedTimeList, opLambda);
     }
 
     public void setUpdatedTime_Match(Long updatedTime) {
@@ -908,7 +909,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedTime_Match(Long updatedTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("updatedTime", updatedTime);
+        MatchQueryBuilder builder = regMatchQ("updatedTime", updatedTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -919,7 +920,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedTime_MatchPhrase(Long updatedTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("updatedTime", updatedTime);
+        MatchQueryBuilder builder = regMatchPhraseQ("updatedTime", updatedTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -930,7 +931,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedTime_MatchPhrasePrefix(Long updatedTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("updatedTime", updatedTime);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("updatedTime", updatedTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -941,7 +942,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedTime_Fuzzy(Long updatedTime, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("updatedTime", updatedTime);
+        FuzzyQueryBuilder builder = regFuzzyQ("updatedTime", updatedTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -952,7 +953,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedTime_GreaterThan(Long updatedTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime);
+        RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -963,7 +964,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedTime_LessThan(Long updatedTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime);
+        RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -974,7 +975,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedTime_GreaterEqual(Long updatedTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime);
+        RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -985,7 +986,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedTime_LessEqual(Long updatedTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime);
+        RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1006,29 +1007,29 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setValue_Term(String value, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("value", value);
+        TermQueryBuilder builder = regTermQ("value", value);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setValue_Terms(Collection<String> valueList) {
-        setValue_MatchPhrasePrefix(valueList, null);
+        setValue_Terms(valueList, null);
     }
 
-    public void setValue_MatchPhrasePrefix(Collection<String> valueList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("value", valueList);
+    public void setValue_Terms(Collection<String> valueList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("value", valueList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setValue_InScope(Collection<String> valueList) {
-        setValue_MatchPhrasePrefix(valueList, null);
+        setValue_Terms(valueList, null);
     }
 
     public void setValue_InScope(Collection<String> valueList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setValue_MatchPhrasePrefix(valueList, opLambda);
+        setValue_Terms(valueList, opLambda);
     }
 
     public void setValue_Match(String value) {
@@ -1036,7 +1037,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setValue_Match(String value, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("value", value);
+        MatchQueryBuilder builder = regMatchQ("value", value);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1047,7 +1048,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setValue_MatchPhrase(String value, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("value", value);
+        MatchQueryBuilder builder = regMatchPhraseQ("value", value);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1058,7 +1059,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setValue_MatchPhrasePrefix(String value, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("value", value);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("value", value);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1069,7 +1070,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setValue_Fuzzy(String value, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("value", value);
+        FuzzyQueryBuilder builder = regFuzzyQ("value", value);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1080,7 +1081,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setValue_Prefix(String value, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("value", value);
+        PrefixQueryBuilder builder = regPrefixQ("value", value);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1091,7 +1092,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setValue_GreaterThan(String value, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("value", ConditionKey.CK_GREATER_THAN, value);
+        RangeQueryBuilder builder = regRangeQ("value", ConditionKey.CK_GREATER_THAN, value);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1102,7 +1103,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setValue_LessThan(String value, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("value", ConditionKey.CK_LESS_THAN, value);
+        RangeQueryBuilder builder = regRangeQ("value", ConditionKey.CK_LESS_THAN, value);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1113,7 +1114,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setValue_GreaterEqual(String value, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("value", ConditionKey.CK_GREATER_EQUAL, value);
+        RangeQueryBuilder builder = regRangeQ("value", ConditionKey.CK_GREATER_EQUAL, value);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1124,7 +1125,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery {
     }
 
     public void setValue_LessEqual(String value, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("value", ConditionKey.CK_LESS_EQUAL, value);
+        RangeQueryBuilder builder = regRangeQ("value", ConditionKey.CK_LESS_EQUAL, value);
         if (opLambda != null) {
             opLambda.callback(builder);
         }

src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsSearchFieldLogCQ.java

@@ -3,6 +3,7 @@ package org.codelibs.fess.es.cbean.cq.bs;
 import java.util.Collection;
 
 import org.codelibs.fess.es.cbean.cq.SearchFieldLogCQ;
+import org.codelibs.fess.es.cbean.cf.SearchFieldLogCF;
 import org.dbflute.cbean.ckey.ConditionKey;
 import org.elasticsearch.index.query.BoolQueryBuilder;
 import org.elasticsearch.index.query.FilteredQueryBuilder;
@@ -28,16 +29,16 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery {
         return "search_field_log";
     }
 
-    public void filtered(FilteredCall<SearchFieldLogCQ> filteredLambda) {
+    public void filtered(FilteredCall<SearchFieldLogCQ, SearchFieldLogCF> filteredLambda) {
         filtered(filteredLambda, null);
     }
 
-    public void filtered(FilteredCall<SearchFieldLogCQ> filteredLambda, ConditionOptionCall<FilteredQueryBuilder> opLambda) {
+    public void filtered(FilteredCall<SearchFieldLogCQ, SearchFieldLogCF> filteredLambda, ConditionOptionCall<FilteredQueryBuilder> opLambda) {
         SearchFieldLogCQ query = new SearchFieldLogCQ();
-        filteredLambda.callback(query);
-        if (!query.queryBuilderList.isEmpty()) {
-            // TODO filter
-            FilteredQueryBuilder builder = reqFilteredQ(query.getQuery(), null);
+        SearchFieldLogCF filter = new SearchFieldLogCF();
+        filteredLambda.callback(query, filter);
+        if (query.hasQueries()) {
+            FilteredQueryBuilder builder = regFilteredQ(query.getQuery(), filter.getFilter());
             if (opLambda != null) {
                 opLambda.callback(builder);
             }
@@ -53,8 +54,8 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery {
         SearchFieldLogCQ shouldQuery = new SearchFieldLogCQ();
         SearchFieldLogCQ mustNotQuery = new SearchFieldLogCQ();
         boolLambda.callback(mustQuery, shouldQuery, mustNotQuery);
-        if (!mustQuery.queryBuilderList.isEmpty() || !shouldQuery.queryBuilderList.isEmpty() || !mustNotQuery.queryBuilderList.isEmpty()) {
-            BoolQueryBuilder builder = reqBoolCQ(mustQuery.queryBuilderList, shouldQuery.queryBuilderList, mustNotQuery.queryBuilderList);
+        if (mustQuery.hasQueries() || shouldQuery.hasQueries() || mustNotQuery.hasQueries()) {
+            BoolQueryBuilder builder = regBoolCQ(mustQuery.queryBuilderList, shouldQuery.queryBuilderList, mustNotQuery.queryBuilderList);
             if (opLambda != null) {
                 opLambda.callback(builder);
             }
@@ -66,29 +67,29 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery {
     }
 
     public void setId_Term(String id, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("id", id);
+        TermQueryBuilder builder = regTermQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setId_Terms(Collection<String> idList) {
-        setId_MatchPhrasePrefix(idList, null);
+        setId_Terms(idList, null);
     }
 
-    public void setId_MatchPhrasePrefix(Collection<String> idList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("id", idList);
+    public void setId_Terms(Collection<String> idList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("id", idList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setId_InScope(Collection<String> idList) {
-        setId_MatchPhrasePrefix(idList, null);
+        setId_Terms(idList, null);
     }
 
     public void setId_InScope(Collection<String> idList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setId_MatchPhrasePrefix(idList, opLambda);
+        setId_Terms(idList, opLambda);
     }
 
     public void setId_Match(String id) {
@@ -96,7 +97,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery {
     }
 
     public void setId_Match(String id, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("id", id);
+        MatchQueryBuilder builder = regMatchQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -107,7 +108,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery {
     }
 
     public void setId_MatchPhrase(String id, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("id", id);
+        MatchQueryBuilder builder = regMatchPhraseQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -118,7 +119,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery {
     }
 
     public void setId_MatchPhrasePrefix(String id, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("id", id);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -129,7 +130,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery {
     }
 
     public void setId_Fuzzy(String id, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("id", id);
+        FuzzyQueryBuilder builder = regFuzzyQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -140,7 +141,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery {
     }
 
     public void setId_Prefix(String id, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("id", id);
+        PrefixQueryBuilder builder = regPrefixQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -151,7 +152,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery {
     }
 
     public void setId_GreaterThan(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_THAN, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_THAN, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -162,7 +163,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery {
     }
 
     public void setId_LessThan(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_THAN, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_THAN, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -173,7 +174,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery {
     }
 
     public void setId_GreaterEqual(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -184,7 +185,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery {
     }
 
     public void setId_LessEqual(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_EQUAL, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_EQUAL, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -205,29 +206,29 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery {
     }
 
     public void setName_Term(String name, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("name", name);
+        TermQueryBuilder builder = regTermQ("name", name);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setName_Terms(Collection<String> nameList) {
-        setName_MatchPhrasePrefix(nameList, null);
+        setName_Terms(nameList, null);
     }
 
-    public void setName_MatchPhrasePrefix(Collection<String> nameList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("name", nameList);
+    public void setName_Terms(Collection<String> nameList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("name", nameList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setName_InScope(Collection<String> nameList) {
-        setName_MatchPhrasePrefix(nameList, null);
+        setName_Terms(nameList, null);
     }
 
     public void setName_InScope(Collection<String> nameList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setName_MatchPhrasePrefix(nameList, opLambda);
+        setName_Terms(nameList, opLambda);
     }
 
     public void setName_Match(String name) {
@@ -235,7 +236,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery {
     }
 
     public void setName_Match(String name, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("name", name);
+        MatchQueryBuilder builder = regMatchQ("name", name);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -246,7 +247,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery {
     }
 
     public void setName_MatchPhrase(String name, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("name", name);
+        MatchQueryBuilder builder = regMatchPhraseQ("name", name);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -257,7 +258,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery {
     }
 
     public void setName_MatchPhrasePrefix(String name, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("name", name);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("name", name);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -268,7 +269,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery {
     }
 
     public void setName_Fuzzy(String name, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("name", name);
+        FuzzyQueryBuilder builder = regFuzzyQ("name", name);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -279,7 +280,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery {
     }
 
     public void setName_Prefix(String name, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("name", name);
+        PrefixQueryBuilder builder = regPrefixQ("name", name);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -290,7 +291,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery {
     }
 
     public void setName_GreaterThan(String name, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("name", ConditionKey.CK_GREATER_THAN, name);
+        RangeQueryBuilder builder = regRangeQ("name", ConditionKey.CK_GREATER_THAN, name);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -301,7 +302,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery {
     }
 
     public void setName_LessThan(String name, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("name", ConditionKey.CK_LESS_THAN, name);
+        RangeQueryBuilder builder = regRangeQ("name", ConditionKey.CK_LESS_THAN, name);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -312,7 +313,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery {
     }
 
     public void setName_GreaterEqual(String name, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("name", ConditionKey.CK_GREATER_EQUAL, name);
+        RangeQueryBuilder builder = regRangeQ("name", ConditionKey.CK_GREATER_EQUAL, name);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -323,7 +324,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery {
     }
 
     public void setName_LessEqual(String name, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("name", ConditionKey.CK_LESS_EQUAL, name);
+        RangeQueryBuilder builder = regRangeQ("name", ConditionKey.CK_LESS_EQUAL, name);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -344,29 +345,29 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery {
     }
 
     public void setSearchLogId_Term(String searchLogId, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("searchLogId", searchLogId);
+        TermQueryBuilder builder = regTermQ("searchLogId", searchLogId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setSearchLogId_Terms(Collection<String> searchLogIdList) {
-        setSearchLogId_MatchPhrasePrefix(searchLogIdList, null);
+        setSearchLogId_Terms(searchLogIdList, null);
     }
 
-    public void setSearchLogId_MatchPhrasePrefix(Collection<String> searchLogIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("searchLogId", searchLogIdList);
+    public void setSearchLogId_Terms(Collection<String> searchLogIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("searchLogId", searchLogIdList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setSearchLogId_InScope(Collection<String> searchLogIdList) {
-        setSearchLogId_MatchPhrasePrefix(searchLogIdList, null);
+        setSearchLogId_Terms(searchLogIdList, null);
     }
 
     public void setSearchLogId_InScope(Collection<String> searchLogIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setSearchLogId_MatchPhrasePrefix(searchLogIdList, opLambda);
+        setSearchLogId_Terms(searchLogIdList, opLambda);
     }
 
     public void setSearchLogId_Match(String searchLogId) {
@@ -374,7 +375,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery {
     }
 
     public void setSearchLogId_Match(String searchLogId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("searchLogId", searchLogId);
+        MatchQueryBuilder builder = regMatchQ("searchLogId", searchLogId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -385,7 +386,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery {
     }
 
     public void setSearchLogId_MatchPhrase(String searchLogId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("searchLogId", searchLogId);
+        MatchQueryBuilder builder = regMatchPhraseQ("searchLogId", searchLogId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -396,7 +397,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery {
     }
 
     public void setSearchLogId_MatchPhrasePrefix(String searchLogId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("searchLogId", searchLogId);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("searchLogId", searchLogId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -407,7 +408,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery {
     }
 
     public void setSearchLogId_Fuzzy(String searchLogId, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("searchLogId", searchLogId);
+        FuzzyQueryBuilder builder = regFuzzyQ("searchLogId", searchLogId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -418,7 +419,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery {
     }
 
     public void setSearchLogId_Prefix(String searchLogId, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("searchLogId", searchLogId);
+        PrefixQueryBuilder builder = regPrefixQ("searchLogId", searchLogId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -429,7 +430,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery {
     }
 
     public void setSearchLogId_GreaterThan(String searchLogId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("searchLogId", ConditionKey.CK_GREATER_THAN, searchLogId);
+        RangeQueryBuilder builder = regRangeQ("searchLogId", ConditionKey.CK_GREATER_THAN, searchLogId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -440,7 +441,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery {
     }
 
     public void setSearchLogId_LessThan(String searchLogId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("searchLogId", ConditionKey.CK_LESS_THAN, searchLogId);
+        RangeQueryBuilder builder = regRangeQ("searchLogId", ConditionKey.CK_LESS_THAN, searchLogId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -451,7 +452,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery {
     }
 
     public void setSearchLogId_GreaterEqual(String searchLogId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("searchLogId", ConditionKey.CK_GREATER_EQUAL, searchLogId);
+        RangeQueryBuilder builder = regRangeQ("searchLogId", ConditionKey.CK_GREATER_EQUAL, searchLogId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -462,7 +463,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery {
     }
 
     public void setSearchLogId_LessEqual(String searchLogId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("searchLogId", ConditionKey.CK_LESS_EQUAL, searchLogId);
+        RangeQueryBuilder builder = regRangeQ("searchLogId", ConditionKey.CK_LESS_EQUAL, searchLogId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -483,29 +484,29 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery {
     }
 
     public void setValue_Term(String value, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("value", value);
+        TermQueryBuilder builder = regTermQ("value", value);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setValue_Terms(Collection<String> valueList) {
-        setValue_MatchPhrasePrefix(valueList, null);
+        setValue_Terms(valueList, null);
     }
 
-    public void setValue_MatchPhrasePrefix(Collection<String> valueList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("value", valueList);
+    public void setValue_Terms(Collection<String> valueList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("value", valueList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setValue_InScope(Collection<String> valueList) {
-        setValue_MatchPhrasePrefix(valueList, null);
+        setValue_Terms(valueList, null);
     }
 
     public void setValue_InScope(Collection<String> valueList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setValue_MatchPhrasePrefix(valueList, opLambda);
+        setValue_Terms(valueList, opLambda);
     }
 
     public void setValue_Match(String value) {
@@ -513,7 +514,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery {
     }
 
     public void setValue_Match(String value, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("value", value);
+        MatchQueryBuilder builder = regMatchQ("value", value);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -524,7 +525,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery {
     }
 
     public void setValue_MatchPhrase(String value, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("value", value);
+        MatchQueryBuilder builder = regMatchPhraseQ("value", value);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -535,7 +536,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery {
     }
 
     public void setValue_MatchPhrasePrefix(String value, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("value", value);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("value", value);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -546,7 +547,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery {
     }
 
     public void setValue_Fuzzy(String value, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("value", value);
+        FuzzyQueryBuilder builder = regFuzzyQ("value", value);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -557,7 +558,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery {
     }
 
     public void setValue_Prefix(String value, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("value", value);
+        PrefixQueryBuilder builder = regPrefixQ("value", value);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -568,7 +569,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery {
     }
 
     public void setValue_GreaterThan(String value, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("value", ConditionKey.CK_GREATER_THAN, value);
+        RangeQueryBuilder builder = regRangeQ("value", ConditionKey.CK_GREATER_THAN, value);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -579,7 +580,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery {
     }
 
     public void setValue_LessThan(String value, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("value", ConditionKey.CK_LESS_THAN, value);
+        RangeQueryBuilder builder = regRangeQ("value", ConditionKey.CK_LESS_THAN, value);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -590,7 +591,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery {
     }
 
     public void setValue_GreaterEqual(String value, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("value", ConditionKey.CK_GREATER_EQUAL, value);
+        RangeQueryBuilder builder = regRangeQ("value", ConditionKey.CK_GREATER_EQUAL, value);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -601,7 +602,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery {
     }
 
     public void setValue_LessEqual(String value, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("value", ConditionKey.CK_LESS_EQUAL, value);
+        RangeQueryBuilder builder = regRangeQ("value", ConditionKey.CK_LESS_EQUAL, value);
         if (opLambda != null) {
             opLambda.callback(builder);
         }

src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsSuggestBadWordCQ.java

@@ -3,6 +3,7 @@ package org.codelibs.fess.es.cbean.cq.bs;
 import java.util.Collection;
 
 import org.codelibs.fess.es.cbean.cq.SuggestBadWordCQ;
+import org.codelibs.fess.es.cbean.cf.SuggestBadWordCF;
 import org.dbflute.cbean.ckey.ConditionKey;
 import org.elasticsearch.index.query.BoolQueryBuilder;
 import org.elasticsearch.index.query.FilteredQueryBuilder;
@@ -28,16 +29,16 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
         return "suggest_bad_word";
     }
 
-    public void filtered(FilteredCall<SuggestBadWordCQ> filteredLambda) {
+    public void filtered(FilteredCall<SuggestBadWordCQ, SuggestBadWordCF> filteredLambda) {
         filtered(filteredLambda, null);
     }
 
-    public void filtered(FilteredCall<SuggestBadWordCQ> filteredLambda, ConditionOptionCall<FilteredQueryBuilder> opLambda) {
+    public void filtered(FilteredCall<SuggestBadWordCQ, SuggestBadWordCF> filteredLambda, ConditionOptionCall<FilteredQueryBuilder> opLambda) {
         SuggestBadWordCQ query = new SuggestBadWordCQ();
-        filteredLambda.callback(query);
-        if (!query.queryBuilderList.isEmpty()) {
-            // TODO filter
-            FilteredQueryBuilder builder = reqFilteredQ(query.getQuery(), null);
+        SuggestBadWordCF filter = new SuggestBadWordCF();
+        filteredLambda.callback(query, filter);
+        if (query.hasQueries()) {
+            FilteredQueryBuilder builder = regFilteredQ(query.getQuery(), filter.getFilter());
             if (opLambda != null) {
                 opLambda.callback(builder);
             }
@@ -53,8 +54,8 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
         SuggestBadWordCQ shouldQuery = new SuggestBadWordCQ();
         SuggestBadWordCQ mustNotQuery = new SuggestBadWordCQ();
         boolLambda.callback(mustQuery, shouldQuery, mustNotQuery);
-        if (!mustQuery.queryBuilderList.isEmpty() || !shouldQuery.queryBuilderList.isEmpty() || !mustNotQuery.queryBuilderList.isEmpty()) {
-            BoolQueryBuilder builder = reqBoolCQ(mustQuery.queryBuilderList, shouldQuery.queryBuilderList, mustNotQuery.queryBuilderList);
+        if (mustQuery.hasQueries() || shouldQuery.hasQueries() || mustNotQuery.hasQueries()) {
+            BoolQueryBuilder builder = regBoolCQ(mustQuery.queryBuilderList, shouldQuery.queryBuilderList, mustNotQuery.queryBuilderList);
             if (opLambda != null) {
                 opLambda.callback(builder);
             }
@@ -66,29 +67,29 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedBy_Term(String createdBy, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("createdBy", createdBy);
+        TermQueryBuilder builder = regTermQ("createdBy", createdBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setCreatedBy_Terms(Collection<String> createdByList) {
-        setCreatedBy_MatchPhrasePrefix(createdByList, null);
+        setCreatedBy_Terms(createdByList, null);
     }
 
-    public void setCreatedBy_MatchPhrasePrefix(Collection<String> createdByList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("createdBy", createdByList);
+    public void setCreatedBy_Terms(Collection<String> createdByList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("createdBy", createdByList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setCreatedBy_InScope(Collection<String> createdByList) {
-        setCreatedBy_MatchPhrasePrefix(createdByList, null);
+        setCreatedBy_Terms(createdByList, null);
     }
 
     public void setCreatedBy_InScope(Collection<String> createdByList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setCreatedBy_MatchPhrasePrefix(createdByList, opLambda);
+        setCreatedBy_Terms(createdByList, opLambda);
     }
 
     public void setCreatedBy_Match(String createdBy) {
@@ -96,7 +97,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedBy_Match(String createdBy, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("createdBy", createdBy);
+        MatchQueryBuilder builder = regMatchQ("createdBy", createdBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -107,7 +108,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedBy_MatchPhrase(String createdBy, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("createdBy", createdBy);
+        MatchQueryBuilder builder = regMatchPhraseQ("createdBy", createdBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -118,7 +119,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedBy_MatchPhrasePrefix(String createdBy, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("createdBy", createdBy);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("createdBy", createdBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -129,7 +130,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedBy_Fuzzy(String createdBy, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("createdBy", createdBy);
+        FuzzyQueryBuilder builder = regFuzzyQ("createdBy", createdBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -140,7 +141,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedBy_Prefix(String createdBy, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("createdBy", createdBy);
+        PrefixQueryBuilder builder = regPrefixQ("createdBy", createdBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -151,7 +152,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedBy_GreaterThan(String createdBy, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_GREATER_THAN, createdBy);
+        RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_GREATER_THAN, createdBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -162,7 +163,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedBy_LessThan(String createdBy, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_LESS_THAN, createdBy);
+        RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_LESS_THAN, createdBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -173,7 +174,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedBy_GreaterEqual(String createdBy, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy);
+        RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -184,7 +185,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedBy_LessEqual(String createdBy, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy);
+        RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -205,29 +206,29 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_Term(Long createdTime, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("createdTime", createdTime);
+        TermQueryBuilder builder = regTermQ("createdTime", createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setCreatedTime_Terms(Collection<Long> createdTimeList) {
-        setCreatedTime_MatchPhrasePrefix(createdTimeList, null);
+        setCreatedTime_Terms(createdTimeList, null);
     }
 
-    public void setCreatedTime_MatchPhrasePrefix(Collection<Long> createdTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("createdTime", createdTimeList);
+    public void setCreatedTime_Terms(Collection<Long> createdTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("createdTime", createdTimeList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setCreatedTime_InScope(Collection<Long> createdTimeList) {
-        setCreatedTime_MatchPhrasePrefix(createdTimeList, null);
+        setCreatedTime_Terms(createdTimeList, null);
     }
 
     public void setCreatedTime_InScope(Collection<Long> createdTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setCreatedTime_MatchPhrasePrefix(createdTimeList, opLambda);
+        setCreatedTime_Terms(createdTimeList, opLambda);
     }
 
     public void setCreatedTime_Match(Long createdTime) {
@@ -235,7 +236,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_Match(Long createdTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("createdTime", createdTime);
+        MatchQueryBuilder builder = regMatchQ("createdTime", createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -246,7 +247,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_MatchPhrase(Long createdTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("createdTime", createdTime);
+        MatchQueryBuilder builder = regMatchPhraseQ("createdTime", createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -257,7 +258,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_MatchPhrasePrefix(Long createdTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("createdTime", createdTime);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("createdTime", createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -268,7 +269,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_Fuzzy(Long createdTime, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("createdTime", createdTime);
+        FuzzyQueryBuilder builder = regFuzzyQ("createdTime", createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -279,7 +280,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_GreaterThan(Long createdTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_GREATER_THAN, createdTime);
+        RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_GREATER_THAN, createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -290,7 +291,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_LessThan(Long createdTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_LESS_THAN, createdTime);
+        RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_LESS_THAN, createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -301,7 +302,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_GreaterEqual(Long createdTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime);
+        RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -312,7 +313,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_LessEqual(Long createdTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime);
+        RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -333,29 +334,29 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setId_Term(String id, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("id", id);
+        TermQueryBuilder builder = regTermQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setId_Terms(Collection<String> idList) {
-        setId_MatchPhrasePrefix(idList, null);
+        setId_Terms(idList, null);
     }
 
-    public void setId_MatchPhrasePrefix(Collection<String> idList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("id", idList);
+    public void setId_Terms(Collection<String> idList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("id", idList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setId_InScope(Collection<String> idList) {
-        setId_MatchPhrasePrefix(idList, null);
+        setId_Terms(idList, null);
     }
 
     public void setId_InScope(Collection<String> idList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setId_MatchPhrasePrefix(idList, opLambda);
+        setId_Terms(idList, opLambda);
     }
 
     public void setId_Match(String id) {
@@ -363,7 +364,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setId_Match(String id, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("id", id);
+        MatchQueryBuilder builder = regMatchQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -374,7 +375,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setId_MatchPhrase(String id, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("id", id);
+        MatchQueryBuilder builder = regMatchPhraseQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -385,7 +386,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setId_MatchPhrasePrefix(String id, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("id", id);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -396,7 +397,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setId_Fuzzy(String id, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("id", id);
+        FuzzyQueryBuilder builder = regFuzzyQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -407,7 +408,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setId_Prefix(String id, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("id", id);
+        PrefixQueryBuilder builder = regPrefixQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -418,7 +419,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setId_GreaterThan(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_THAN, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_THAN, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -429,7 +430,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setId_LessThan(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_THAN, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_THAN, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -440,7 +441,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setId_GreaterEqual(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -451,7 +452,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setId_LessEqual(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_EQUAL, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_EQUAL, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -472,29 +473,29 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setSuggestWord_Term(String suggestWord, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("suggestWord", suggestWord);
+        TermQueryBuilder builder = regTermQ("suggestWord", suggestWord);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setSuggestWord_Terms(Collection<String> suggestWordList) {
-        setSuggestWord_MatchPhrasePrefix(suggestWordList, null);
+        setSuggestWord_Terms(suggestWordList, null);
     }
 
-    public void setSuggestWord_MatchPhrasePrefix(Collection<String> suggestWordList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("suggestWord", suggestWordList);
+    public void setSuggestWord_Terms(Collection<String> suggestWordList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("suggestWord", suggestWordList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setSuggestWord_InScope(Collection<String> suggestWordList) {
-        setSuggestWord_MatchPhrasePrefix(suggestWordList, null);
+        setSuggestWord_Terms(suggestWordList, null);
     }
 
     public void setSuggestWord_InScope(Collection<String> suggestWordList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setSuggestWord_MatchPhrasePrefix(suggestWordList, opLambda);
+        setSuggestWord_Terms(suggestWordList, opLambda);
     }
 
     public void setSuggestWord_Match(String suggestWord) {
@@ -502,7 +503,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setSuggestWord_Match(String suggestWord, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("suggestWord", suggestWord);
+        MatchQueryBuilder builder = regMatchQ("suggestWord", suggestWord);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -513,7 +514,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setSuggestWord_MatchPhrase(String suggestWord, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("suggestWord", suggestWord);
+        MatchQueryBuilder builder = regMatchPhraseQ("suggestWord", suggestWord);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -524,7 +525,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setSuggestWord_MatchPhrasePrefix(String suggestWord, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("suggestWord", suggestWord);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("suggestWord", suggestWord);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -535,7 +536,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setSuggestWord_Fuzzy(String suggestWord, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("suggestWord", suggestWord);
+        FuzzyQueryBuilder builder = regFuzzyQ("suggestWord", suggestWord);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -546,7 +547,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setSuggestWord_Prefix(String suggestWord, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("suggestWord", suggestWord);
+        PrefixQueryBuilder builder = regPrefixQ("suggestWord", suggestWord);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -557,7 +558,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setSuggestWord_GreaterThan(String suggestWord, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("suggestWord", ConditionKey.CK_GREATER_THAN, suggestWord);
+        RangeQueryBuilder builder = regRangeQ("suggestWord", ConditionKey.CK_GREATER_THAN, suggestWord);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -568,7 +569,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setSuggestWord_LessThan(String suggestWord, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("suggestWord", ConditionKey.CK_LESS_THAN, suggestWord);
+        RangeQueryBuilder builder = regRangeQ("suggestWord", ConditionKey.CK_LESS_THAN, suggestWord);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -579,7 +580,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setSuggestWord_GreaterEqual(String suggestWord, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("suggestWord", ConditionKey.CK_GREATER_EQUAL, suggestWord);
+        RangeQueryBuilder builder = regRangeQ("suggestWord", ConditionKey.CK_GREATER_EQUAL, suggestWord);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -590,7 +591,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setSuggestWord_LessEqual(String suggestWord, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("suggestWord", ConditionKey.CK_LESS_EQUAL, suggestWord);
+        RangeQueryBuilder builder = regRangeQ("suggestWord", ConditionKey.CK_LESS_EQUAL, suggestWord);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -611,29 +612,29 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setTargetLabel_Term(String targetLabel, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("targetLabel", targetLabel);
+        TermQueryBuilder builder = regTermQ("targetLabel", targetLabel);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setTargetLabel_Terms(Collection<String> targetLabelList) {
-        setTargetLabel_MatchPhrasePrefix(targetLabelList, null);
+        setTargetLabel_Terms(targetLabelList, null);
     }
 
-    public void setTargetLabel_MatchPhrasePrefix(Collection<String> targetLabelList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("targetLabel", targetLabelList);
+    public void setTargetLabel_Terms(Collection<String> targetLabelList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("targetLabel", targetLabelList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setTargetLabel_InScope(Collection<String> targetLabelList) {
-        setTargetLabel_MatchPhrasePrefix(targetLabelList, null);
+        setTargetLabel_Terms(targetLabelList, null);
     }
 
     public void setTargetLabel_InScope(Collection<String> targetLabelList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setTargetLabel_MatchPhrasePrefix(targetLabelList, opLambda);
+        setTargetLabel_Terms(targetLabelList, opLambda);
     }
 
     public void setTargetLabel_Match(String targetLabel) {
@@ -641,7 +642,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setTargetLabel_Match(String targetLabel, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("targetLabel", targetLabel);
+        MatchQueryBuilder builder = regMatchQ("targetLabel", targetLabel);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -652,7 +653,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setTargetLabel_MatchPhrase(String targetLabel, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("targetLabel", targetLabel);
+        MatchQueryBuilder builder = regMatchPhraseQ("targetLabel", targetLabel);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -663,7 +664,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setTargetLabel_MatchPhrasePrefix(String targetLabel, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("targetLabel", targetLabel);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("targetLabel", targetLabel);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -674,7 +675,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setTargetLabel_Fuzzy(String targetLabel, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("targetLabel", targetLabel);
+        FuzzyQueryBuilder builder = regFuzzyQ("targetLabel", targetLabel);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -685,7 +686,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setTargetLabel_Prefix(String targetLabel, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("targetLabel", targetLabel);
+        PrefixQueryBuilder builder = regPrefixQ("targetLabel", targetLabel);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -696,7 +697,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setTargetLabel_GreaterThan(String targetLabel, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("targetLabel", ConditionKey.CK_GREATER_THAN, targetLabel);
+        RangeQueryBuilder builder = regRangeQ("targetLabel", ConditionKey.CK_GREATER_THAN, targetLabel);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -707,7 +708,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setTargetLabel_LessThan(String targetLabel, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("targetLabel", ConditionKey.CK_LESS_THAN, targetLabel);
+        RangeQueryBuilder builder = regRangeQ("targetLabel", ConditionKey.CK_LESS_THAN, targetLabel);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -718,7 +719,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setTargetLabel_GreaterEqual(String targetLabel, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("targetLabel", ConditionKey.CK_GREATER_EQUAL, targetLabel);
+        RangeQueryBuilder builder = regRangeQ("targetLabel", ConditionKey.CK_GREATER_EQUAL, targetLabel);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -729,7 +730,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setTargetLabel_LessEqual(String targetLabel, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("targetLabel", ConditionKey.CK_LESS_EQUAL, targetLabel);
+        RangeQueryBuilder builder = regRangeQ("targetLabel", ConditionKey.CK_LESS_EQUAL, targetLabel);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -750,29 +751,29 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setTargetRole_Term(String targetRole, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("targetRole", targetRole);
+        TermQueryBuilder builder = regTermQ("targetRole", targetRole);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setTargetRole_Terms(Collection<String> targetRoleList) {
-        setTargetRole_MatchPhrasePrefix(targetRoleList, null);
+        setTargetRole_Terms(targetRoleList, null);
     }
 
-    public void setTargetRole_MatchPhrasePrefix(Collection<String> targetRoleList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("targetRole", targetRoleList);
+    public void setTargetRole_Terms(Collection<String> targetRoleList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("targetRole", targetRoleList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setTargetRole_InScope(Collection<String> targetRoleList) {
-        setTargetRole_MatchPhrasePrefix(targetRoleList, null);
+        setTargetRole_Terms(targetRoleList, null);
     }
 
     public void setTargetRole_InScope(Collection<String> targetRoleList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setTargetRole_MatchPhrasePrefix(targetRoleList, opLambda);
+        setTargetRole_Terms(targetRoleList, opLambda);
     }
 
     public void setTargetRole_Match(String targetRole) {
@@ -780,7 +781,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setTargetRole_Match(String targetRole, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("targetRole", targetRole);
+        MatchQueryBuilder builder = regMatchQ("targetRole", targetRole);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -791,7 +792,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setTargetRole_MatchPhrase(String targetRole, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("targetRole", targetRole);
+        MatchQueryBuilder builder = regMatchPhraseQ("targetRole", targetRole);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -802,7 +803,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setTargetRole_MatchPhrasePrefix(String targetRole, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("targetRole", targetRole);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("targetRole", targetRole);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -813,7 +814,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setTargetRole_Fuzzy(String targetRole, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("targetRole", targetRole);
+        FuzzyQueryBuilder builder = regFuzzyQ("targetRole", targetRole);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -824,7 +825,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setTargetRole_Prefix(String targetRole, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("targetRole", targetRole);
+        PrefixQueryBuilder builder = regPrefixQ("targetRole", targetRole);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -835,7 +836,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setTargetRole_GreaterThan(String targetRole, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("targetRole", ConditionKey.CK_GREATER_THAN, targetRole);
+        RangeQueryBuilder builder = regRangeQ("targetRole", ConditionKey.CK_GREATER_THAN, targetRole);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -846,7 +847,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setTargetRole_LessThan(String targetRole, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("targetRole", ConditionKey.CK_LESS_THAN, targetRole);
+        RangeQueryBuilder builder = regRangeQ("targetRole", ConditionKey.CK_LESS_THAN, targetRole);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -857,7 +858,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setTargetRole_GreaterEqual(String targetRole, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("targetRole", ConditionKey.CK_GREATER_EQUAL, targetRole);
+        RangeQueryBuilder builder = regRangeQ("targetRole", ConditionKey.CK_GREATER_EQUAL, targetRole);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -868,7 +869,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setTargetRole_LessEqual(String targetRole, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("targetRole", ConditionKey.CK_LESS_EQUAL, targetRole);
+        RangeQueryBuilder builder = regRangeQ("targetRole", ConditionKey.CK_LESS_EQUAL, targetRole);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -889,29 +890,29 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedBy_Term(String updatedBy, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("updatedBy", updatedBy);
+        TermQueryBuilder builder = regTermQ("updatedBy", updatedBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setUpdatedBy_Terms(Collection<String> updatedByList) {
-        setUpdatedBy_MatchPhrasePrefix(updatedByList, null);
+        setUpdatedBy_Terms(updatedByList, null);
     }
 
-    public void setUpdatedBy_MatchPhrasePrefix(Collection<String> updatedByList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("updatedBy", updatedByList);
+    public void setUpdatedBy_Terms(Collection<String> updatedByList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("updatedBy", updatedByList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setUpdatedBy_InScope(Collection<String> updatedByList) {
-        setUpdatedBy_MatchPhrasePrefix(updatedByList, null);
+        setUpdatedBy_Terms(updatedByList, null);
     }
 
     public void setUpdatedBy_InScope(Collection<String> updatedByList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setUpdatedBy_MatchPhrasePrefix(updatedByList, opLambda);
+        setUpdatedBy_Terms(updatedByList, opLambda);
     }
 
     public void setUpdatedBy_Match(String updatedBy) {
@@ -919,7 +920,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedBy_Match(String updatedBy, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("updatedBy", updatedBy);
+        MatchQueryBuilder builder = regMatchQ("updatedBy", updatedBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -930,7 +931,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedBy_MatchPhrase(String updatedBy, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("updatedBy", updatedBy);
+        MatchQueryBuilder builder = regMatchPhraseQ("updatedBy", updatedBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -941,7 +942,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedBy_MatchPhrasePrefix(String updatedBy, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("updatedBy", updatedBy);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("updatedBy", updatedBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -952,7 +953,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedBy_Fuzzy(String updatedBy, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("updatedBy", updatedBy);
+        FuzzyQueryBuilder builder = regFuzzyQ("updatedBy", updatedBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -963,7 +964,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedBy_Prefix(String updatedBy, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("updatedBy", updatedBy);
+        PrefixQueryBuilder builder = regPrefixQ("updatedBy", updatedBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -974,7 +975,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedBy_GreaterThan(String updatedBy, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy);
+        RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -985,7 +986,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedBy_LessThan(String updatedBy, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy);
+        RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -996,7 +997,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedBy_GreaterEqual(String updatedBy, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy);
+        RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1007,7 +1008,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedBy_LessEqual(String updatedBy, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy);
+        RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1028,29 +1029,29 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedTime_Term(Long updatedTime, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("updatedTime", updatedTime);
+        TermQueryBuilder builder = regTermQ("updatedTime", updatedTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setUpdatedTime_Terms(Collection<Long> updatedTimeList) {
-        setUpdatedTime_MatchPhrasePrefix(updatedTimeList, null);
+        setUpdatedTime_Terms(updatedTimeList, null);
     }
 
-    public void setUpdatedTime_MatchPhrasePrefix(Collection<Long> updatedTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("updatedTime", updatedTimeList);
+    public void setUpdatedTime_Terms(Collection<Long> updatedTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("updatedTime", updatedTimeList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setUpdatedTime_InScope(Collection<Long> updatedTimeList) {
-        setUpdatedTime_MatchPhrasePrefix(updatedTimeList, null);
+        setUpdatedTime_Terms(updatedTimeList, null);
     }
 
     public void setUpdatedTime_InScope(Collection<Long> updatedTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setUpdatedTime_MatchPhrasePrefix(updatedTimeList, opLambda);
+        setUpdatedTime_Terms(updatedTimeList, opLambda);
     }
 
     public void setUpdatedTime_Match(Long updatedTime) {
@@ -1058,7 +1059,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedTime_Match(Long updatedTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("updatedTime", updatedTime);
+        MatchQueryBuilder builder = regMatchQ("updatedTime", updatedTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1069,7 +1070,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedTime_MatchPhrase(Long updatedTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("updatedTime", updatedTime);
+        MatchQueryBuilder builder = regMatchPhraseQ("updatedTime", updatedTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1080,7 +1081,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedTime_MatchPhrasePrefix(Long updatedTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("updatedTime", updatedTime);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("updatedTime", updatedTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1091,7 +1092,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedTime_Fuzzy(Long updatedTime, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("updatedTime", updatedTime);
+        FuzzyQueryBuilder builder = regFuzzyQ("updatedTime", updatedTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1102,7 +1103,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedTime_GreaterThan(Long updatedTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime);
+        RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1113,7 +1114,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedTime_LessThan(Long updatedTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime);
+        RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1124,7 +1125,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedTime_GreaterEqual(Long updatedTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime);
+        RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1135,7 +1136,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedTime_LessEqual(Long updatedTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime);
+        RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }

src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsUserInfoCQ.java

@@ -3,6 +3,7 @@ package org.codelibs.fess.es.cbean.cq.bs;
 import java.util.Collection;
 
 import org.codelibs.fess.es.cbean.cq.UserInfoCQ;
+import org.codelibs.fess.es.cbean.cf.UserInfoCF;
 import org.dbflute.cbean.ckey.ConditionKey;
 import org.elasticsearch.index.query.BoolQueryBuilder;
 import org.elasticsearch.index.query.FilteredQueryBuilder;
@@ -28,16 +29,16 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery {
         return "user_info";
     }
 
-    public void filtered(FilteredCall<UserInfoCQ> filteredLambda) {
+    public void filtered(FilteredCall<UserInfoCQ, UserInfoCF> filteredLambda) {
         filtered(filteredLambda, null);
     }
 
-    public void filtered(FilteredCall<UserInfoCQ> filteredLambda, ConditionOptionCall<FilteredQueryBuilder> opLambda) {
+    public void filtered(FilteredCall<UserInfoCQ, UserInfoCF> filteredLambda, ConditionOptionCall<FilteredQueryBuilder> opLambda) {
         UserInfoCQ query = new UserInfoCQ();
-        filteredLambda.callback(query);
-        if (!query.queryBuilderList.isEmpty()) {
-            // TODO filter
-            FilteredQueryBuilder builder = reqFilteredQ(query.getQuery(), null);
+        UserInfoCF filter = new UserInfoCF();
+        filteredLambda.callback(query, filter);
+        if (query.hasQueries()) {
+            FilteredQueryBuilder builder = regFilteredQ(query.getQuery(), filter.getFilter());
             if (opLambda != null) {
                 opLambda.callback(builder);
             }
@@ -53,8 +54,8 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery {
         UserInfoCQ shouldQuery = new UserInfoCQ();
         UserInfoCQ mustNotQuery = new UserInfoCQ();
         boolLambda.callback(mustQuery, shouldQuery, mustNotQuery);
-        if (!mustQuery.queryBuilderList.isEmpty() || !shouldQuery.queryBuilderList.isEmpty() || !mustNotQuery.queryBuilderList.isEmpty()) {
-            BoolQueryBuilder builder = reqBoolCQ(mustQuery.queryBuilderList, shouldQuery.queryBuilderList, mustNotQuery.queryBuilderList);
+        if (mustQuery.hasQueries() || shouldQuery.hasQueries() || mustNotQuery.hasQueries()) {
+            BoolQueryBuilder builder = regBoolCQ(mustQuery.queryBuilderList, shouldQuery.queryBuilderList, mustNotQuery.queryBuilderList);
             if (opLambda != null) {
                 opLambda.callback(builder);
             }
@@ -66,29 +67,29 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery {
     }
 
     public void setCode_Term(String code, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("code", code);
+        TermQueryBuilder builder = regTermQ("code", code);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setCode_Terms(Collection<String> codeList) {
-        setCode_MatchPhrasePrefix(codeList, null);
+        setCode_Terms(codeList, null);
     }
 
-    public void setCode_MatchPhrasePrefix(Collection<String> codeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("code", codeList);
+    public void setCode_Terms(Collection<String> codeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("code", codeList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setCode_InScope(Collection<String> codeList) {
-        setCode_MatchPhrasePrefix(codeList, null);
+        setCode_Terms(codeList, null);
     }
 
     public void setCode_InScope(Collection<String> codeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setCode_MatchPhrasePrefix(codeList, opLambda);
+        setCode_Terms(codeList, opLambda);
     }
 
     public void setCode_Match(String code) {
@@ -96,7 +97,7 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery {
     }
 
     public void setCode_Match(String code, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("code", code);
+        MatchQueryBuilder builder = regMatchQ("code", code);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -107,7 +108,7 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery {
     }
 
     public void setCode_MatchPhrase(String code, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("code", code);
+        MatchQueryBuilder builder = regMatchPhraseQ("code", code);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -118,7 +119,7 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery {
     }
 
     public void setCode_MatchPhrasePrefix(String code, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("code", code);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("code", code);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -129,7 +130,7 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery {
     }
 
     public void setCode_Fuzzy(String code, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("code", code);
+        FuzzyQueryBuilder builder = regFuzzyQ("code", code);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -140,7 +141,7 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery {
     }
 
     public void setCode_Prefix(String code, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("code", code);
+        PrefixQueryBuilder builder = regPrefixQ("code", code);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -151,7 +152,7 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery {
     }
 
     public void setCode_GreaterThan(String code, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("code", ConditionKey.CK_GREATER_THAN, code);
+        RangeQueryBuilder builder = regRangeQ("code", ConditionKey.CK_GREATER_THAN, code);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -162,7 +163,7 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery {
     }
 
     public void setCode_LessThan(String code, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("code", ConditionKey.CK_LESS_THAN, code);
+        RangeQueryBuilder builder = regRangeQ("code", ConditionKey.CK_LESS_THAN, code);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -173,7 +174,7 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery {
     }
 
     public void setCode_GreaterEqual(String code, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("code", ConditionKey.CK_GREATER_EQUAL, code);
+        RangeQueryBuilder builder = regRangeQ("code", ConditionKey.CK_GREATER_EQUAL, code);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -184,7 +185,7 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery {
     }
 
     public void setCode_LessEqual(String code, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("code", ConditionKey.CK_LESS_EQUAL, code);
+        RangeQueryBuilder builder = regRangeQ("code", ConditionKey.CK_LESS_EQUAL, code);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -205,29 +206,29 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_Term(Long createdTime, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("createdTime", createdTime);
+        TermQueryBuilder builder = regTermQ("createdTime", createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setCreatedTime_Terms(Collection<Long> createdTimeList) {
-        setCreatedTime_MatchPhrasePrefix(createdTimeList, null);
+        setCreatedTime_Terms(createdTimeList, null);
     }
 
-    public void setCreatedTime_MatchPhrasePrefix(Collection<Long> createdTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("createdTime", createdTimeList);
+    public void setCreatedTime_Terms(Collection<Long> createdTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("createdTime", createdTimeList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setCreatedTime_InScope(Collection<Long> createdTimeList) {
-        setCreatedTime_MatchPhrasePrefix(createdTimeList, null);
+        setCreatedTime_Terms(createdTimeList, null);
     }
 
     public void setCreatedTime_InScope(Collection<Long> createdTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setCreatedTime_MatchPhrasePrefix(createdTimeList, opLambda);
+        setCreatedTime_Terms(createdTimeList, opLambda);
     }
 
     public void setCreatedTime_Match(Long createdTime) {
@@ -235,7 +236,7 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_Match(Long createdTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("createdTime", createdTime);
+        MatchQueryBuilder builder = regMatchQ("createdTime", createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -246,7 +247,7 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_MatchPhrase(Long createdTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("createdTime", createdTime);
+        MatchQueryBuilder builder = regMatchPhraseQ("createdTime", createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -257,7 +258,7 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_MatchPhrasePrefix(Long createdTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("createdTime", createdTime);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("createdTime", createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -268,7 +269,7 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_Fuzzy(Long createdTime, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("createdTime", createdTime);
+        FuzzyQueryBuilder builder = regFuzzyQ("createdTime", createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -279,7 +280,7 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_GreaterThan(Long createdTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_GREATER_THAN, createdTime);
+        RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_GREATER_THAN, createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -290,7 +291,7 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_LessThan(Long createdTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_LESS_THAN, createdTime);
+        RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_LESS_THAN, createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -301,7 +302,7 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_GreaterEqual(Long createdTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime);
+        RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -312,7 +313,7 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery {
     }
 
     public void setCreatedTime_LessEqual(Long createdTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime);
+        RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -333,29 +334,29 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery {
     }
 
     public void setId_Term(String id, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("id", id);
+        TermQueryBuilder builder = regTermQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setId_Terms(Collection<String> idList) {
-        setId_MatchPhrasePrefix(idList, null);
+        setId_Terms(idList, null);
     }
 
-    public void setId_MatchPhrasePrefix(Collection<String> idList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("id", idList);
+    public void setId_Terms(Collection<String> idList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("id", idList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setId_InScope(Collection<String> idList) {
-        setId_MatchPhrasePrefix(idList, null);
+        setId_Terms(idList, null);
     }
 
     public void setId_InScope(Collection<String> idList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setId_MatchPhrasePrefix(idList, opLambda);
+        setId_Terms(idList, opLambda);
     }
 
     public void setId_Match(String id) {
@@ -363,7 +364,7 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery {
     }
 
     public void setId_Match(String id, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("id", id);
+        MatchQueryBuilder builder = regMatchQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -374,7 +375,7 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery {
     }
 
     public void setId_MatchPhrase(String id, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("id", id);
+        MatchQueryBuilder builder = regMatchPhraseQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -385,7 +386,7 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery {
     }
 
     public void setId_MatchPhrasePrefix(String id, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("id", id);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -396,7 +397,7 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery {
     }
 
     public void setId_Fuzzy(String id, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("id", id);
+        FuzzyQueryBuilder builder = regFuzzyQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -407,7 +408,7 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery {
     }
 
     public void setId_Prefix(String id, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("id", id);
+        PrefixQueryBuilder builder = regPrefixQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -418,7 +419,7 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery {
     }
 
     public void setId_GreaterThan(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_THAN, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_THAN, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -429,7 +430,7 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery {
     }
 
     public void setId_LessThan(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_THAN, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_THAN, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -440,7 +441,7 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery {
     }
 
     public void setId_GreaterEqual(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -451,7 +452,7 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery {
     }
 
     public void setId_LessEqual(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_EQUAL, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_EQUAL, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -472,29 +473,29 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedTime_Term(Long updatedTime, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("updatedTime", updatedTime);
+        TermQueryBuilder builder = regTermQ("updatedTime", updatedTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setUpdatedTime_Terms(Collection<Long> updatedTimeList) {
-        setUpdatedTime_MatchPhrasePrefix(updatedTimeList, null);
+        setUpdatedTime_Terms(updatedTimeList, null);
     }
 
-    public void setUpdatedTime_MatchPhrasePrefix(Collection<Long> updatedTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("updatedTime", updatedTimeList);
+    public void setUpdatedTime_Terms(Collection<Long> updatedTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("updatedTime", updatedTimeList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setUpdatedTime_InScope(Collection<Long> updatedTimeList) {
-        setUpdatedTime_MatchPhrasePrefix(updatedTimeList, null);
+        setUpdatedTime_Terms(updatedTimeList, null);
     }
 
     public void setUpdatedTime_InScope(Collection<Long> updatedTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setUpdatedTime_MatchPhrasePrefix(updatedTimeList, opLambda);
+        setUpdatedTime_Terms(updatedTimeList, opLambda);
     }
 
     public void setUpdatedTime_Match(Long updatedTime) {
@@ -502,7 +503,7 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedTime_Match(Long updatedTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("updatedTime", updatedTime);
+        MatchQueryBuilder builder = regMatchQ("updatedTime", updatedTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -513,7 +514,7 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedTime_MatchPhrase(Long updatedTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("updatedTime", updatedTime);
+        MatchQueryBuilder builder = regMatchPhraseQ("updatedTime", updatedTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -524,7 +525,7 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedTime_MatchPhrasePrefix(Long updatedTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("updatedTime", updatedTime);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("updatedTime", updatedTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -535,7 +536,7 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedTime_Fuzzy(Long updatedTime, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("updatedTime", updatedTime);
+        FuzzyQueryBuilder builder = regFuzzyQ("updatedTime", updatedTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -546,7 +547,7 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedTime_GreaterThan(Long updatedTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime);
+        RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -557,7 +558,7 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedTime_LessThan(Long updatedTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime);
+        RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -568,7 +569,7 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedTime_GreaterEqual(Long updatedTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime);
+        RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -579,7 +580,7 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery {
     }
 
     public void setUpdatedTime_LessEqual(Long updatedTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime);
+        RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }

src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsWebConfigToLabelCQ.java

@@ -3,6 +3,7 @@ package org.codelibs.fess.es.cbean.cq.bs;
 import java.util.Collection;
 
 import org.codelibs.fess.es.cbean.cq.WebConfigToLabelCQ;
+import org.codelibs.fess.es.cbean.cf.WebConfigToLabelCF;
 import org.dbflute.cbean.ckey.ConditionKey;
 import org.elasticsearch.index.query.BoolQueryBuilder;
 import org.elasticsearch.index.query.FilteredQueryBuilder;
@@ -28,16 +29,17 @@ public abstract class BsWebConfigToLabelCQ extends AbstractConditionQuery {
         return "web_config_to_label";
     }
 
-    public void filtered(FilteredCall<WebConfigToLabelCQ> filteredLambda) {
+    public void filtered(FilteredCall<WebConfigToLabelCQ, WebConfigToLabelCF> filteredLambda) {
         filtered(filteredLambda, null);
     }
 
-    public void filtered(FilteredCall<WebConfigToLabelCQ> filteredLambda, ConditionOptionCall<FilteredQueryBuilder> opLambda) {
+    public void filtered(FilteredCall<WebConfigToLabelCQ, WebConfigToLabelCF> filteredLambda,
+            ConditionOptionCall<FilteredQueryBuilder> opLambda) {
         WebConfigToLabelCQ query = new WebConfigToLabelCQ();
-        filteredLambda.callback(query);
-        if (!query.queryBuilderList.isEmpty()) {
-            // TODO filter
-            FilteredQueryBuilder builder = reqFilteredQ(query.getQuery(), null);
+        WebConfigToLabelCF filter = new WebConfigToLabelCF();
+        filteredLambda.callback(query, filter);
+        if (query.hasQueries()) {
+            FilteredQueryBuilder builder = regFilteredQ(query.getQuery(), filter.getFilter());
             if (opLambda != null) {
                 opLambda.callback(builder);
             }
@@ -53,8 +55,8 @@ public abstract class BsWebConfigToLabelCQ extends AbstractConditionQuery {
         WebConfigToLabelCQ shouldQuery = new WebConfigToLabelCQ();
         WebConfigToLabelCQ mustNotQuery = new WebConfigToLabelCQ();
         boolLambda.callback(mustQuery, shouldQuery, mustNotQuery);
-        if (!mustQuery.queryBuilderList.isEmpty() || !shouldQuery.queryBuilderList.isEmpty() || !mustNotQuery.queryBuilderList.isEmpty()) {
-            BoolQueryBuilder builder = reqBoolCQ(mustQuery.queryBuilderList, shouldQuery.queryBuilderList, mustNotQuery.queryBuilderList);
+        if (mustQuery.hasQueries() || shouldQuery.hasQueries() || mustNotQuery.hasQueries()) {
+            BoolQueryBuilder builder = regBoolCQ(mustQuery.queryBuilderList, shouldQuery.queryBuilderList, mustNotQuery.queryBuilderList);
             if (opLambda != null) {
                 opLambda.callback(builder);
             }
@@ -66,29 +68,29 @@ public abstract class BsWebConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setId_Term(String id, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("id", id);
+        TermQueryBuilder builder = regTermQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setId_Terms(Collection<String> idList) {
-        setId_MatchPhrasePrefix(idList, null);
+        setId_Terms(idList, null);
     }
 
-    public void setId_MatchPhrasePrefix(Collection<String> idList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("id", idList);
+    public void setId_Terms(Collection<String> idList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("id", idList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setId_InScope(Collection<String> idList) {
-        setId_MatchPhrasePrefix(idList, null);
+        setId_Terms(idList, null);
     }
 
     public void setId_InScope(Collection<String> idList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setId_MatchPhrasePrefix(idList, opLambda);
+        setId_Terms(idList, opLambda);
     }
 
     public void setId_Match(String id) {
@@ -96,7 +98,7 @@ public abstract class BsWebConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setId_Match(String id, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("id", id);
+        MatchQueryBuilder builder = regMatchQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -107,7 +109,7 @@ public abstract class BsWebConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setId_MatchPhrase(String id, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("id", id);
+        MatchQueryBuilder builder = regMatchPhraseQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -118,7 +120,7 @@ public abstract class BsWebConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setId_MatchPhrasePrefix(String id, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("id", id);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -129,7 +131,7 @@ public abstract class BsWebConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setId_Fuzzy(String id, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("id", id);
+        FuzzyQueryBuilder builder = regFuzzyQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -140,7 +142,7 @@ public abstract class BsWebConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setId_Prefix(String id, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("id", id);
+        PrefixQueryBuilder builder = regPrefixQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -151,7 +153,7 @@ public abstract class BsWebConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setId_GreaterThan(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_THAN, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_THAN, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -162,7 +164,7 @@ public abstract class BsWebConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setId_LessThan(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_THAN, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_THAN, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -173,7 +175,7 @@ public abstract class BsWebConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setId_GreaterEqual(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -184,7 +186,7 @@ public abstract class BsWebConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setId_LessEqual(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_EQUAL, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_EQUAL, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -205,29 +207,29 @@ public abstract class BsWebConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setLabelTypeId_Term(String labelTypeId, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("labelTypeId", labelTypeId);
+        TermQueryBuilder builder = regTermQ("labelTypeId", labelTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setLabelTypeId_Terms(Collection<String> labelTypeIdList) {
-        setLabelTypeId_MatchPhrasePrefix(labelTypeIdList, null);
+        setLabelTypeId_Terms(labelTypeIdList, null);
     }
 
-    public void setLabelTypeId_MatchPhrasePrefix(Collection<String> labelTypeIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("labelTypeId", labelTypeIdList);
+    public void setLabelTypeId_Terms(Collection<String> labelTypeIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("labelTypeId", labelTypeIdList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setLabelTypeId_InScope(Collection<String> labelTypeIdList) {
-        setLabelTypeId_MatchPhrasePrefix(labelTypeIdList, null);
+        setLabelTypeId_Terms(labelTypeIdList, null);
     }
 
     public void setLabelTypeId_InScope(Collection<String> labelTypeIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setLabelTypeId_MatchPhrasePrefix(labelTypeIdList, opLambda);
+        setLabelTypeId_Terms(labelTypeIdList, opLambda);
     }
 
     public void setLabelTypeId_Match(String labelTypeId) {
@@ -235,7 +237,7 @@ public abstract class BsWebConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setLabelTypeId_Match(String labelTypeId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("labelTypeId", labelTypeId);
+        MatchQueryBuilder builder = regMatchQ("labelTypeId", labelTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -246,7 +248,7 @@ public abstract class BsWebConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setLabelTypeId_MatchPhrase(String labelTypeId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("labelTypeId", labelTypeId);
+        MatchQueryBuilder builder = regMatchPhraseQ("labelTypeId", labelTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -257,7 +259,7 @@ public abstract class BsWebConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setLabelTypeId_MatchPhrasePrefix(String labelTypeId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("labelTypeId", labelTypeId);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("labelTypeId", labelTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -268,7 +270,7 @@ public abstract class BsWebConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setLabelTypeId_Fuzzy(String labelTypeId, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("labelTypeId", labelTypeId);
+        FuzzyQueryBuilder builder = regFuzzyQ("labelTypeId", labelTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -279,7 +281,7 @@ public abstract class BsWebConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setLabelTypeId_Prefix(String labelTypeId, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("labelTypeId", labelTypeId);
+        PrefixQueryBuilder builder = regPrefixQ("labelTypeId", labelTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -290,7 +292,7 @@ public abstract class BsWebConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setLabelTypeId_GreaterThan(String labelTypeId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("labelTypeId", ConditionKey.CK_GREATER_THAN, labelTypeId);
+        RangeQueryBuilder builder = regRangeQ("labelTypeId", ConditionKey.CK_GREATER_THAN, labelTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -301,7 +303,7 @@ public abstract class BsWebConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setLabelTypeId_LessThan(String labelTypeId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("labelTypeId", ConditionKey.CK_LESS_THAN, labelTypeId);
+        RangeQueryBuilder builder = regRangeQ("labelTypeId", ConditionKey.CK_LESS_THAN, labelTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -312,7 +314,7 @@ public abstract class BsWebConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setLabelTypeId_GreaterEqual(String labelTypeId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("labelTypeId", ConditionKey.CK_GREATER_EQUAL, labelTypeId);
+        RangeQueryBuilder builder = regRangeQ("labelTypeId", ConditionKey.CK_GREATER_EQUAL, labelTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -323,7 +325,7 @@ public abstract class BsWebConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setLabelTypeId_LessEqual(String labelTypeId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("labelTypeId", ConditionKey.CK_LESS_EQUAL, labelTypeId);
+        RangeQueryBuilder builder = regRangeQ("labelTypeId", ConditionKey.CK_LESS_EQUAL, labelTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -344,29 +346,29 @@ public abstract class BsWebConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setWebConfigId_Term(String webConfigId, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("webConfigId", webConfigId);
+        TermQueryBuilder builder = regTermQ("webConfigId", webConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setWebConfigId_Terms(Collection<String> webConfigIdList) {
-        setWebConfigId_MatchPhrasePrefix(webConfigIdList, null);
+        setWebConfigId_Terms(webConfigIdList, null);
     }
 
-    public void setWebConfigId_MatchPhrasePrefix(Collection<String> webConfigIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("webConfigId", webConfigIdList);
+    public void setWebConfigId_Terms(Collection<String> webConfigIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("webConfigId", webConfigIdList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setWebConfigId_InScope(Collection<String> webConfigIdList) {
-        setWebConfigId_MatchPhrasePrefix(webConfigIdList, null);
+        setWebConfigId_Terms(webConfigIdList, null);
     }
 
     public void setWebConfigId_InScope(Collection<String> webConfigIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setWebConfigId_MatchPhrasePrefix(webConfigIdList, opLambda);
+        setWebConfigId_Terms(webConfigIdList, opLambda);
     }
 
     public void setWebConfigId_Match(String webConfigId) {
@@ -374,7 +376,7 @@ public abstract class BsWebConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setWebConfigId_Match(String webConfigId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("webConfigId", webConfigId);
+        MatchQueryBuilder builder = regMatchQ("webConfigId", webConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -385,7 +387,7 @@ public abstract class BsWebConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setWebConfigId_MatchPhrase(String webConfigId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("webConfigId", webConfigId);
+        MatchQueryBuilder builder = regMatchPhraseQ("webConfigId", webConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -396,7 +398,7 @@ public abstract class BsWebConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setWebConfigId_MatchPhrasePrefix(String webConfigId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("webConfigId", webConfigId);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("webConfigId", webConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -407,7 +409,7 @@ public abstract class BsWebConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setWebConfigId_Fuzzy(String webConfigId, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("webConfigId", webConfigId);
+        FuzzyQueryBuilder builder = regFuzzyQ("webConfigId", webConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -418,7 +420,7 @@ public abstract class BsWebConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setWebConfigId_Prefix(String webConfigId, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("webConfigId", webConfigId);
+        PrefixQueryBuilder builder = regPrefixQ("webConfigId", webConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -429,7 +431,7 @@ public abstract class BsWebConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setWebConfigId_GreaterThan(String webConfigId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("webConfigId", ConditionKey.CK_GREATER_THAN, webConfigId);
+        RangeQueryBuilder builder = regRangeQ("webConfigId", ConditionKey.CK_GREATER_THAN, webConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -440,7 +442,7 @@ public abstract class BsWebConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setWebConfigId_LessThan(String webConfigId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("webConfigId", ConditionKey.CK_LESS_THAN, webConfigId);
+        RangeQueryBuilder builder = regRangeQ("webConfigId", ConditionKey.CK_LESS_THAN, webConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -451,7 +453,7 @@ public abstract class BsWebConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setWebConfigId_GreaterEqual(String webConfigId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("webConfigId", ConditionKey.CK_GREATER_EQUAL, webConfigId);
+        RangeQueryBuilder builder = regRangeQ("webConfigId", ConditionKey.CK_GREATER_EQUAL, webConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -462,7 +464,7 @@ public abstract class BsWebConfigToLabelCQ extends AbstractConditionQuery {
     }
 
     public void setWebConfigId_LessEqual(String webConfigId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("webConfigId", ConditionKey.CK_LESS_EQUAL, webConfigId);
+        RangeQueryBuilder builder = regRangeQ("webConfigId", ConditionKey.CK_LESS_EQUAL, webConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }

src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsWebConfigToRoleCQ.java

@@ -3,6 +3,7 @@ package org.codelibs.fess.es.cbean.cq.bs;
 import java.util.Collection;
 
 import org.codelibs.fess.es.cbean.cq.WebConfigToRoleCQ;
+import org.codelibs.fess.es.cbean.cf.WebConfigToRoleCF;
 import org.dbflute.cbean.ckey.ConditionKey;
 import org.elasticsearch.index.query.BoolQueryBuilder;
 import org.elasticsearch.index.query.FilteredQueryBuilder;
@@ -28,16 +29,17 @@ public abstract class BsWebConfigToRoleCQ extends AbstractConditionQuery {
         return "web_config_to_role";
     }
 
-    public void filtered(FilteredCall<WebConfigToRoleCQ> filteredLambda) {
+    public void filtered(FilteredCall<WebConfigToRoleCQ, WebConfigToRoleCF> filteredLambda) {
         filtered(filteredLambda, null);
     }
 
-    public void filtered(FilteredCall<WebConfigToRoleCQ> filteredLambda, ConditionOptionCall<FilteredQueryBuilder> opLambda) {
+    public void filtered(FilteredCall<WebConfigToRoleCQ, WebConfigToRoleCF> filteredLambda,
+            ConditionOptionCall<FilteredQueryBuilder> opLambda) {
         WebConfigToRoleCQ query = new WebConfigToRoleCQ();
-        filteredLambda.callback(query);
-        if (!query.queryBuilderList.isEmpty()) {
-            // TODO filter
-            FilteredQueryBuilder builder = reqFilteredQ(query.getQuery(), null);
+        WebConfigToRoleCF filter = new WebConfigToRoleCF();
+        filteredLambda.callback(query, filter);
+        if (query.hasQueries()) {
+            FilteredQueryBuilder builder = regFilteredQ(query.getQuery(), filter.getFilter());
             if (opLambda != null) {
                 opLambda.callback(builder);
             }
@@ -53,8 +55,8 @@ public abstract class BsWebConfigToRoleCQ extends AbstractConditionQuery {
         WebConfigToRoleCQ shouldQuery = new WebConfigToRoleCQ();
         WebConfigToRoleCQ mustNotQuery = new WebConfigToRoleCQ();
         boolLambda.callback(mustQuery, shouldQuery, mustNotQuery);
-        if (!mustQuery.queryBuilderList.isEmpty() || !shouldQuery.queryBuilderList.isEmpty() || !mustNotQuery.queryBuilderList.isEmpty()) {
-            BoolQueryBuilder builder = reqBoolCQ(mustQuery.queryBuilderList, shouldQuery.queryBuilderList, mustNotQuery.queryBuilderList);
+        if (mustQuery.hasQueries() || shouldQuery.hasQueries() || mustNotQuery.hasQueries()) {
+            BoolQueryBuilder builder = regBoolCQ(mustQuery.queryBuilderList, shouldQuery.queryBuilderList, mustNotQuery.queryBuilderList);
             if (opLambda != null) {
                 opLambda.callback(builder);
             }
@@ -66,29 +68,29 @@ public abstract class BsWebConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setId_Term(String id, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("id", id);
+        TermQueryBuilder builder = regTermQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setId_Terms(Collection<String> idList) {
-        setId_MatchPhrasePrefix(idList, null);
+        setId_Terms(idList, null);
     }
 
-    public void setId_MatchPhrasePrefix(Collection<String> idList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("id", idList);
+    public void setId_Terms(Collection<String> idList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("id", idList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setId_InScope(Collection<String> idList) {
-        setId_MatchPhrasePrefix(idList, null);
+        setId_Terms(idList, null);
     }
 
     public void setId_InScope(Collection<String> idList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setId_MatchPhrasePrefix(idList, opLambda);
+        setId_Terms(idList, opLambda);
     }
 
     public void setId_Match(String id) {
@@ -96,7 +98,7 @@ public abstract class BsWebConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setId_Match(String id, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("id", id);
+        MatchQueryBuilder builder = regMatchQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -107,7 +109,7 @@ public abstract class BsWebConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setId_MatchPhrase(String id, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("id", id);
+        MatchQueryBuilder builder = regMatchPhraseQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -118,7 +120,7 @@ public abstract class BsWebConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setId_MatchPhrasePrefix(String id, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("id", id);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -129,7 +131,7 @@ public abstract class BsWebConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setId_Fuzzy(String id, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("id", id);
+        FuzzyQueryBuilder builder = regFuzzyQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -140,7 +142,7 @@ public abstract class BsWebConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setId_Prefix(String id, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("id", id);
+        PrefixQueryBuilder builder = regPrefixQ("id", id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -151,7 +153,7 @@ public abstract class BsWebConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setId_GreaterThan(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_THAN, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_THAN, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -162,7 +164,7 @@ public abstract class BsWebConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setId_LessThan(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_THAN, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_THAN, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -173,7 +175,7 @@ public abstract class BsWebConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setId_GreaterEqual(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -184,7 +186,7 @@ public abstract class BsWebConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setId_LessEqual(String id, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_EQUAL, id);
+        RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_EQUAL, id);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -205,29 +207,29 @@ public abstract class BsWebConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setRoleTypeId_Term(String roleTypeId, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("roleTypeId", roleTypeId);
+        TermQueryBuilder builder = regTermQ("roleTypeId", roleTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setRoleTypeId_Terms(Collection<String> roleTypeIdList) {
-        setRoleTypeId_MatchPhrasePrefix(roleTypeIdList, null);
+        setRoleTypeId_Terms(roleTypeIdList, null);
     }
 
-    public void setRoleTypeId_MatchPhrasePrefix(Collection<String> roleTypeIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("roleTypeId", roleTypeIdList);
+    public void setRoleTypeId_Terms(Collection<String> roleTypeIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("roleTypeId", roleTypeIdList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setRoleTypeId_InScope(Collection<String> roleTypeIdList) {
-        setRoleTypeId_MatchPhrasePrefix(roleTypeIdList, null);
+        setRoleTypeId_Terms(roleTypeIdList, null);
     }
 
     public void setRoleTypeId_InScope(Collection<String> roleTypeIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setRoleTypeId_MatchPhrasePrefix(roleTypeIdList, opLambda);
+        setRoleTypeId_Terms(roleTypeIdList, opLambda);
     }
 
     public void setRoleTypeId_Match(String roleTypeId) {
@@ -235,7 +237,7 @@ public abstract class BsWebConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setRoleTypeId_Match(String roleTypeId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("roleTypeId", roleTypeId);
+        MatchQueryBuilder builder = regMatchQ("roleTypeId", roleTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -246,7 +248,7 @@ public abstract class BsWebConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setRoleTypeId_MatchPhrase(String roleTypeId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("roleTypeId", roleTypeId);
+        MatchQueryBuilder builder = regMatchPhraseQ("roleTypeId", roleTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -257,7 +259,7 @@ public abstract class BsWebConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setRoleTypeId_MatchPhrasePrefix(String roleTypeId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("roleTypeId", roleTypeId);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("roleTypeId", roleTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -268,7 +270,7 @@ public abstract class BsWebConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setRoleTypeId_Fuzzy(String roleTypeId, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("roleTypeId", roleTypeId);
+        FuzzyQueryBuilder builder = regFuzzyQ("roleTypeId", roleTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -279,7 +281,7 @@ public abstract class BsWebConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setRoleTypeId_Prefix(String roleTypeId, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("roleTypeId", roleTypeId);
+        PrefixQueryBuilder builder = regPrefixQ("roleTypeId", roleTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -290,7 +292,7 @@ public abstract class BsWebConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setRoleTypeId_GreaterThan(String roleTypeId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("roleTypeId", ConditionKey.CK_GREATER_THAN, roleTypeId);
+        RangeQueryBuilder builder = regRangeQ("roleTypeId", ConditionKey.CK_GREATER_THAN, roleTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -301,7 +303,7 @@ public abstract class BsWebConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setRoleTypeId_LessThan(String roleTypeId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("roleTypeId", ConditionKey.CK_LESS_THAN, roleTypeId);
+        RangeQueryBuilder builder = regRangeQ("roleTypeId", ConditionKey.CK_LESS_THAN, roleTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -312,7 +314,7 @@ public abstract class BsWebConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setRoleTypeId_GreaterEqual(String roleTypeId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("roleTypeId", ConditionKey.CK_GREATER_EQUAL, roleTypeId);
+        RangeQueryBuilder builder = regRangeQ("roleTypeId", ConditionKey.CK_GREATER_EQUAL, roleTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -323,7 +325,7 @@ public abstract class BsWebConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setRoleTypeId_LessEqual(String roleTypeId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("roleTypeId", ConditionKey.CK_LESS_EQUAL, roleTypeId);
+        RangeQueryBuilder builder = regRangeQ("roleTypeId", ConditionKey.CK_LESS_EQUAL, roleTypeId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -344,29 +346,29 @@ public abstract class BsWebConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setWebConfigId_Term(String webConfigId, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("webConfigId", webConfigId);
+        TermQueryBuilder builder = regTermQ("webConfigId", webConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setWebConfigId_Terms(Collection<String> webConfigIdList) {
-        setWebConfigId_MatchPhrasePrefix(webConfigIdList, null);
+        setWebConfigId_Terms(webConfigIdList, null);
     }
 
-    public void setWebConfigId_MatchPhrasePrefix(Collection<String> webConfigIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("webConfigId", webConfigIdList);
+    public void setWebConfigId_Terms(Collection<String> webConfigIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("webConfigId", webConfigIdList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setWebConfigId_InScope(Collection<String> webConfigIdList) {
-        setWebConfigId_MatchPhrasePrefix(webConfigIdList, null);
+        setWebConfigId_Terms(webConfigIdList, null);
     }
 
     public void setWebConfigId_InScope(Collection<String> webConfigIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setWebConfigId_MatchPhrasePrefix(webConfigIdList, opLambda);
+        setWebConfigId_Terms(webConfigIdList, opLambda);
     }
 
     public void setWebConfigId_Match(String webConfigId) {
@@ -374,7 +376,7 @@ public abstract class BsWebConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setWebConfigId_Match(String webConfigId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("webConfigId", webConfigId);
+        MatchQueryBuilder builder = regMatchQ("webConfigId", webConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -385,7 +387,7 @@ public abstract class BsWebConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setWebConfigId_MatchPhrase(String webConfigId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("webConfigId", webConfigId);
+        MatchQueryBuilder builder = regMatchPhraseQ("webConfigId", webConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -396,7 +398,7 @@ public abstract class BsWebConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setWebConfigId_MatchPhrasePrefix(String webConfigId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("webConfigId", webConfigId);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("webConfigId", webConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -407,7 +409,7 @@ public abstract class BsWebConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setWebConfigId_Fuzzy(String webConfigId, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("webConfigId", webConfigId);
+        FuzzyQueryBuilder builder = regFuzzyQ("webConfigId", webConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -418,7 +420,7 @@ public abstract class BsWebConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setWebConfigId_Prefix(String webConfigId, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("webConfigId", webConfigId);
+        PrefixQueryBuilder builder = regPrefixQ("webConfigId", webConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -429,7 +431,7 @@ public abstract class BsWebConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setWebConfigId_GreaterThan(String webConfigId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("webConfigId", ConditionKey.CK_GREATER_THAN, webConfigId);
+        RangeQueryBuilder builder = regRangeQ("webConfigId", ConditionKey.CK_GREATER_THAN, webConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -440,7 +442,7 @@ public abstract class BsWebConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setWebConfigId_LessThan(String webConfigId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("webConfigId", ConditionKey.CK_LESS_THAN, webConfigId);
+        RangeQueryBuilder builder = regRangeQ("webConfigId", ConditionKey.CK_LESS_THAN, webConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -451,7 +453,7 @@ public abstract class BsWebConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setWebConfigId_GreaterEqual(String webConfigId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("webConfigId", ConditionKey.CK_GREATER_EQUAL, webConfigId);
+        RangeQueryBuilder builder = regRangeQ("webConfigId", ConditionKey.CK_GREATER_EQUAL, webConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -462,7 +464,7 @@ public abstract class BsWebConfigToRoleCQ extends AbstractConditionQuery {
     }
 
     public void setWebConfigId_LessEqual(String webConfigId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("webConfigId", ConditionKey.CK_LESS_EQUAL, webConfigId);
+        RangeQueryBuilder builder = regRangeQ("webConfigId", ConditionKey.CK_LESS_EQUAL, webConfigId);
         if (opLambda != null) {
             opLambda.callback(builder);
         }