#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/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/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/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/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/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/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/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/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/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);
+        void callback(CQ query, CF filter);
+    }
+
+    @FunctionalInterface
+    public interface OperatorCall<CQ extends AbstractConditionQuery> {
+
+        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/BsJobLogCQ.java

@@ -3,6 +3,7 @@ package org.codelibs.fess.es.cbean.cq.bs;
 import java.util.Collection;
 
 import org.codelibs.fess.es.cbean.cq.JobLogCQ;
+import org.codelibs.fess.es.cbean.cf.JobLogCF;
 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 BsJobLogCQ extends AbstractConditionQuery {
         return "job_log";
     }
 
-    public void filtered(FilteredCall<JobLogCQ> filteredLambda) {
+    public void filtered(FilteredCall<JobLogCQ, JobLogCF> filteredLambda) {
         filtered(filteredLambda, null);
     }
 
-    public void filtered(FilteredCall<JobLogCQ> filteredLambda, ConditionOptionCall<FilteredQueryBuilder> opLambda) {
+    public void filtered(FilteredCall<JobLogCQ, JobLogCF> filteredLambda, ConditionOptionCall<FilteredQueryBuilder> opLambda) {
         JobLogCQ query = new JobLogCQ();
-        filteredLambda.callback(query);
-        if (!query.queryBuilderList.isEmpty()) {
-            // TODO filter
-            FilteredQueryBuilder builder = reqFilteredQ(query.getQuery(), null);
+        JobLogCF filter = new JobLogCF();
+        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 BsJobLogCQ extends AbstractConditionQuery {
         JobLogCQ shouldQuery = new JobLogCQ();
         JobLogCQ mustNotQuery = new JobLogCQ();
         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 BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setEndTime_Term(Long endTime, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("endTime", endTime);
+        TermQueryBuilder builder = regTermQ("endTime", endTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setEndTime_Terms(Collection<Long> endTimeList) {
-        setEndTime_MatchPhrasePrefix(endTimeList, null);
+        setEndTime_Terms(endTimeList, null);
     }
 
-    public void setEndTime_MatchPhrasePrefix(Collection<Long> endTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("endTime", endTimeList);
+    public void setEndTime_Terms(Collection<Long> endTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("endTime", endTimeList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setEndTime_InScope(Collection<Long> endTimeList) {
-        setEndTime_MatchPhrasePrefix(endTimeList, null);
+        setEndTime_Terms(endTimeList, null);
     }
 
     public void setEndTime_InScope(Collection<Long> endTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setEndTime_MatchPhrasePrefix(endTimeList, opLambda);
+        setEndTime_Terms(endTimeList, opLambda);
     }
 
     public void setEndTime_Match(Long endTime) {
@@ -96,7 +97,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setEndTime_Match(Long endTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("endTime", endTime);
+        MatchQueryBuilder builder = regMatchQ("endTime", endTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -107,7 +108,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setEndTime_MatchPhrase(Long endTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("endTime", endTime);
+        MatchQueryBuilder builder = regMatchPhraseQ("endTime", endTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -118,7 +119,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setEndTime_MatchPhrasePrefix(Long endTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("endTime", endTime);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("endTime", endTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -129,7 +130,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setEndTime_Fuzzy(Long endTime, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("endTime", endTime);
+        FuzzyQueryBuilder builder = regFuzzyQ("endTime", endTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -140,7 +141,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setEndTime_GreaterThan(Long endTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("endTime", ConditionKey.CK_GREATER_THAN, endTime);
+        RangeQueryBuilder builder = regRangeQ("endTime", ConditionKey.CK_GREATER_THAN, endTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -151,7 +152,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setEndTime_LessThan(Long endTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("endTime", ConditionKey.CK_LESS_THAN, endTime);
+        RangeQueryBuilder builder = regRangeQ("endTime", ConditionKey.CK_LESS_THAN, endTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -162,7 +163,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setEndTime_GreaterEqual(Long endTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("endTime", ConditionKey.CK_GREATER_EQUAL, endTime);
+        RangeQueryBuilder builder = regRangeQ("endTime", ConditionKey.CK_GREATER_EQUAL, endTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -173,7 +174,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setEndTime_LessEqual(Long endTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("endTime", ConditionKey.CK_LESS_EQUAL, endTime);
+        RangeQueryBuilder builder = regRangeQ("endTime", ConditionKey.CK_LESS_EQUAL, endTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -194,29 +195,29 @@ public abstract class BsJobLogCQ 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 BsJobLogCQ 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 BsJobLogCQ 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 BsJobLogCQ 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 BsJobLogCQ 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 BsJobLogCQ 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 BsJobLogCQ 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 BsJobLogCQ 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 BsJobLogCQ 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 BsJobLogCQ 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 BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setJobName_Term(String jobName, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("jobName", jobName);
+        TermQueryBuilder builder = regTermQ("jobName", jobName);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setJobName_Terms(Collection<String> jobNameList) {
-        setJobName_MatchPhrasePrefix(jobNameList, null);
+        setJobName_Terms(jobNameList, null);
     }
 
-    public void setJobName_MatchPhrasePrefix(Collection<String> jobNameList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("jobName", jobNameList);
+    public void setJobName_Terms(Collection<String> jobNameList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("jobName", jobNameList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setJobName_InScope(Collection<String> jobNameList) {
-        setJobName_MatchPhrasePrefix(jobNameList, null);
+        setJobName_Terms(jobNameList, null);
     }
 
     public void setJobName_InScope(Collection<String> jobNameList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setJobName_MatchPhrasePrefix(jobNameList, opLambda);
+        setJobName_Terms(jobNameList, opLambda);
     }
 
     public void setJobName_Match(String jobName) {
@@ -363,7 +364,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setJobName_Match(String jobName, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("jobName", jobName);
+        MatchQueryBuilder builder = regMatchQ("jobName", jobName);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -374,7 +375,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setJobName_MatchPhrase(String jobName, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("jobName", jobName);
+        MatchQueryBuilder builder = regMatchPhraseQ("jobName", jobName);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -385,7 +386,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setJobName_MatchPhrasePrefix(String jobName, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("jobName", jobName);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("jobName", jobName);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -396,7 +397,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setJobName_Fuzzy(String jobName, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("jobName", jobName);
+        FuzzyQueryBuilder builder = regFuzzyQ("jobName", jobName);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -407,7 +408,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setJobName_Prefix(String jobName, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("jobName", jobName);
+        PrefixQueryBuilder builder = regPrefixQ("jobName", jobName);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -418,7 +419,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setJobName_GreaterThan(String jobName, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("jobName", ConditionKey.CK_GREATER_THAN, jobName);
+        RangeQueryBuilder builder = regRangeQ("jobName", ConditionKey.CK_GREATER_THAN, jobName);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -429,7 +430,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setJobName_LessThan(String jobName, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("jobName", ConditionKey.CK_LESS_THAN, jobName);
+        RangeQueryBuilder builder = regRangeQ("jobName", ConditionKey.CK_LESS_THAN, jobName);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -440,7 +441,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setJobName_GreaterEqual(String jobName, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("jobName", ConditionKey.CK_GREATER_EQUAL, jobName);
+        RangeQueryBuilder builder = regRangeQ("jobName", ConditionKey.CK_GREATER_EQUAL, jobName);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -451,7 +452,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setJobName_LessEqual(String jobName, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("jobName", ConditionKey.CK_LESS_EQUAL, jobName);
+        RangeQueryBuilder builder = regRangeQ("jobName", ConditionKey.CK_LESS_EQUAL, jobName);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -472,29 +473,29 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setJobStatus_Term(String jobStatus, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("jobStatus", jobStatus);
+        TermQueryBuilder builder = regTermQ("jobStatus", jobStatus);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setJobStatus_Terms(Collection<String> jobStatusList) {
-        setJobStatus_MatchPhrasePrefix(jobStatusList, null);
+        setJobStatus_Terms(jobStatusList, null);
     }
 
-    public void setJobStatus_MatchPhrasePrefix(Collection<String> jobStatusList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("jobStatus", jobStatusList);
+    public void setJobStatus_Terms(Collection<String> jobStatusList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("jobStatus", jobStatusList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setJobStatus_InScope(Collection<String> jobStatusList) {
-        setJobStatus_MatchPhrasePrefix(jobStatusList, null);
+        setJobStatus_Terms(jobStatusList, null);
     }
 
     public void setJobStatus_InScope(Collection<String> jobStatusList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setJobStatus_MatchPhrasePrefix(jobStatusList, opLambda);
+        setJobStatus_Terms(jobStatusList, opLambda);
     }
 
     public void setJobStatus_Match(String jobStatus) {
@@ -502,7 +503,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setJobStatus_Match(String jobStatus, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("jobStatus", jobStatus);
+        MatchQueryBuilder builder = regMatchQ("jobStatus", jobStatus);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -513,7 +514,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setJobStatus_MatchPhrase(String jobStatus, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("jobStatus", jobStatus);
+        MatchQueryBuilder builder = regMatchPhraseQ("jobStatus", jobStatus);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -524,7 +525,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setJobStatus_MatchPhrasePrefix(String jobStatus, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("jobStatus", jobStatus);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("jobStatus", jobStatus);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -535,7 +536,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setJobStatus_Fuzzy(String jobStatus, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("jobStatus", jobStatus);
+        FuzzyQueryBuilder builder = regFuzzyQ("jobStatus", jobStatus);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -546,7 +547,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setJobStatus_Prefix(String jobStatus, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("jobStatus", jobStatus);
+        PrefixQueryBuilder builder = regPrefixQ("jobStatus", jobStatus);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -557,7 +558,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setJobStatus_GreaterThan(String jobStatus, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("jobStatus", ConditionKey.CK_GREATER_THAN, jobStatus);
+        RangeQueryBuilder builder = regRangeQ("jobStatus", ConditionKey.CK_GREATER_THAN, jobStatus);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -568,7 +569,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setJobStatus_LessThan(String jobStatus, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("jobStatus", ConditionKey.CK_LESS_THAN, jobStatus);
+        RangeQueryBuilder builder = regRangeQ("jobStatus", ConditionKey.CK_LESS_THAN, jobStatus);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -579,7 +580,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setJobStatus_GreaterEqual(String jobStatus, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("jobStatus", ConditionKey.CK_GREATER_EQUAL, jobStatus);
+        RangeQueryBuilder builder = regRangeQ("jobStatus", ConditionKey.CK_GREATER_EQUAL, jobStatus);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -590,7 +591,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setJobStatus_LessEqual(String jobStatus, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("jobStatus", ConditionKey.CK_LESS_EQUAL, jobStatus);
+        RangeQueryBuilder builder = regRangeQ("jobStatus", ConditionKey.CK_LESS_EQUAL, jobStatus);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -611,29 +612,29 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setScriptData_Term(String scriptData, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("scriptData", scriptData);
+        TermQueryBuilder builder = regTermQ("scriptData", scriptData);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setScriptData_Terms(Collection<String> scriptDataList) {
-        setScriptData_MatchPhrasePrefix(scriptDataList, null);
+        setScriptData_Terms(scriptDataList, null);
     }
 
-    public void setScriptData_MatchPhrasePrefix(Collection<String> scriptDataList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("scriptData", scriptDataList);
+    public void setScriptData_Terms(Collection<String> scriptDataList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("scriptData", scriptDataList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setScriptData_InScope(Collection<String> scriptDataList) {
-        setScriptData_MatchPhrasePrefix(scriptDataList, null);
+        setScriptData_Terms(scriptDataList, null);
     }
 
     public void setScriptData_InScope(Collection<String> scriptDataList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setScriptData_MatchPhrasePrefix(scriptDataList, opLambda);
+        setScriptData_Terms(scriptDataList, opLambda);
     }
 
     public void setScriptData_Match(String scriptData) {
@@ -641,7 +642,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setScriptData_Match(String scriptData, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("scriptData", scriptData);
+        MatchQueryBuilder builder = regMatchQ("scriptData", scriptData);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -652,7 +653,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setScriptData_MatchPhrase(String scriptData, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("scriptData", scriptData);
+        MatchQueryBuilder builder = regMatchPhraseQ("scriptData", scriptData);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -663,7 +664,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setScriptData_MatchPhrasePrefix(String scriptData, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("scriptData", scriptData);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("scriptData", scriptData);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -674,7 +675,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setScriptData_Fuzzy(String scriptData, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("scriptData", scriptData);
+        FuzzyQueryBuilder builder = regFuzzyQ("scriptData", scriptData);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -685,7 +686,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setScriptData_Prefix(String scriptData, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("scriptData", scriptData);
+        PrefixQueryBuilder builder = regPrefixQ("scriptData", scriptData);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -696,7 +697,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setScriptData_GreaterThan(String scriptData, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("scriptData", ConditionKey.CK_GREATER_THAN, scriptData);
+        RangeQueryBuilder builder = regRangeQ("scriptData", ConditionKey.CK_GREATER_THAN, scriptData);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -707,7 +708,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setScriptData_LessThan(String scriptData, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("scriptData", ConditionKey.CK_LESS_THAN, scriptData);
+        RangeQueryBuilder builder = regRangeQ("scriptData", ConditionKey.CK_LESS_THAN, scriptData);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -718,7 +719,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setScriptData_GreaterEqual(String scriptData, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("scriptData", ConditionKey.CK_GREATER_EQUAL, scriptData);
+        RangeQueryBuilder builder = regRangeQ("scriptData", ConditionKey.CK_GREATER_EQUAL, scriptData);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -729,7 +730,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setScriptData_LessEqual(String scriptData, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("scriptData", ConditionKey.CK_LESS_EQUAL, scriptData);
+        RangeQueryBuilder builder = regRangeQ("scriptData", ConditionKey.CK_LESS_EQUAL, scriptData);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -750,29 +751,29 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setScriptResult_Term(String scriptResult, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("scriptResult", scriptResult);
+        TermQueryBuilder builder = regTermQ("scriptResult", scriptResult);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setScriptResult_Terms(Collection<String> scriptResultList) {
-        setScriptResult_MatchPhrasePrefix(scriptResultList, null);
+        setScriptResult_Terms(scriptResultList, null);
     }
 
-    public void setScriptResult_MatchPhrasePrefix(Collection<String> scriptResultList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("scriptResult", scriptResultList);
+    public void setScriptResult_Terms(Collection<String> scriptResultList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("scriptResult", scriptResultList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setScriptResult_InScope(Collection<String> scriptResultList) {
-        setScriptResult_MatchPhrasePrefix(scriptResultList, null);
+        setScriptResult_Terms(scriptResultList, null);
     }
 
     public void setScriptResult_InScope(Collection<String> scriptResultList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setScriptResult_MatchPhrasePrefix(scriptResultList, opLambda);
+        setScriptResult_Terms(scriptResultList, opLambda);
     }
 
     public void setScriptResult_Match(String scriptResult) {
@@ -780,7 +781,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setScriptResult_Match(String scriptResult, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("scriptResult", scriptResult);
+        MatchQueryBuilder builder = regMatchQ("scriptResult", scriptResult);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -791,7 +792,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setScriptResult_MatchPhrase(String scriptResult, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("scriptResult", scriptResult);
+        MatchQueryBuilder builder = regMatchPhraseQ("scriptResult", scriptResult);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -802,7 +803,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setScriptResult_MatchPhrasePrefix(String scriptResult, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("scriptResult", scriptResult);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("scriptResult", scriptResult);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -813,7 +814,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setScriptResult_Fuzzy(String scriptResult, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("scriptResult", scriptResult);
+        FuzzyQueryBuilder builder = regFuzzyQ("scriptResult", scriptResult);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -824,7 +825,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setScriptResult_Prefix(String scriptResult, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("scriptResult", scriptResult);
+        PrefixQueryBuilder builder = regPrefixQ("scriptResult", scriptResult);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -835,7 +836,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setScriptResult_GreaterThan(String scriptResult, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("scriptResult", ConditionKey.CK_GREATER_THAN, scriptResult);
+        RangeQueryBuilder builder = regRangeQ("scriptResult", ConditionKey.CK_GREATER_THAN, scriptResult);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -846,7 +847,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setScriptResult_LessThan(String scriptResult, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("scriptResult", ConditionKey.CK_LESS_THAN, scriptResult);
+        RangeQueryBuilder builder = regRangeQ("scriptResult", ConditionKey.CK_LESS_THAN, scriptResult);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -857,7 +858,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setScriptResult_GreaterEqual(String scriptResult, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("scriptResult", ConditionKey.CK_GREATER_EQUAL, scriptResult);
+        RangeQueryBuilder builder = regRangeQ("scriptResult", ConditionKey.CK_GREATER_EQUAL, scriptResult);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -868,7 +869,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setScriptResult_LessEqual(String scriptResult, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("scriptResult", ConditionKey.CK_LESS_EQUAL, scriptResult);
+        RangeQueryBuilder builder = regRangeQ("scriptResult", ConditionKey.CK_LESS_EQUAL, scriptResult);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -889,29 +890,29 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setScriptType_Term(String scriptType, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("scriptType", scriptType);
+        TermQueryBuilder builder = regTermQ("scriptType", scriptType);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setScriptType_Terms(Collection<String> scriptTypeList) {
-        setScriptType_MatchPhrasePrefix(scriptTypeList, null);
+        setScriptType_Terms(scriptTypeList, null);
     }
 
-    public void setScriptType_MatchPhrasePrefix(Collection<String> scriptTypeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("scriptType", scriptTypeList);
+    public void setScriptType_Terms(Collection<String> scriptTypeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("scriptType", scriptTypeList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setScriptType_InScope(Collection<String> scriptTypeList) {
-        setScriptType_MatchPhrasePrefix(scriptTypeList, null);
+        setScriptType_Terms(scriptTypeList, null);
     }
 
     public void setScriptType_InScope(Collection<String> scriptTypeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setScriptType_MatchPhrasePrefix(scriptTypeList, opLambda);
+        setScriptType_Terms(scriptTypeList, opLambda);
     }
 
     public void setScriptType_Match(String scriptType) {
@@ -919,7 +920,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setScriptType_Match(String scriptType, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("scriptType", scriptType);
+        MatchQueryBuilder builder = regMatchQ("scriptType", scriptType);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -930,7 +931,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setScriptType_MatchPhrase(String scriptType, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("scriptType", scriptType);
+        MatchQueryBuilder builder = regMatchPhraseQ("scriptType", scriptType);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -941,7 +942,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setScriptType_MatchPhrasePrefix(String scriptType, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("scriptType", scriptType);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("scriptType", scriptType);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -952,7 +953,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setScriptType_Fuzzy(String scriptType, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("scriptType", scriptType);
+        FuzzyQueryBuilder builder = regFuzzyQ("scriptType", scriptType);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -963,7 +964,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setScriptType_Prefix(String scriptType, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("scriptType", scriptType);
+        PrefixQueryBuilder builder = regPrefixQ("scriptType", scriptType);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -974,7 +975,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setScriptType_GreaterThan(String scriptType, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("scriptType", ConditionKey.CK_GREATER_THAN, scriptType);
+        RangeQueryBuilder builder = regRangeQ("scriptType", ConditionKey.CK_GREATER_THAN, scriptType);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -985,7 +986,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setScriptType_LessThan(String scriptType, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("scriptType", ConditionKey.CK_LESS_THAN, scriptType);
+        RangeQueryBuilder builder = regRangeQ("scriptType", ConditionKey.CK_LESS_THAN, scriptType);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -996,7 +997,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setScriptType_GreaterEqual(String scriptType, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("scriptType", ConditionKey.CK_GREATER_EQUAL, scriptType);
+        RangeQueryBuilder builder = regRangeQ("scriptType", ConditionKey.CK_GREATER_EQUAL, scriptType);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1007,7 +1008,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setScriptType_LessEqual(String scriptType, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("scriptType", ConditionKey.CK_LESS_EQUAL, scriptType);
+        RangeQueryBuilder builder = regRangeQ("scriptType", ConditionKey.CK_LESS_EQUAL, scriptType);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1028,29 +1029,29 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setStartTime_Term(Long startTime, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("startTime", startTime);
+        TermQueryBuilder builder = regTermQ("startTime", startTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setStartTime_Terms(Collection<Long> startTimeList) {
-        setStartTime_MatchPhrasePrefix(startTimeList, null);
+        setStartTime_Terms(startTimeList, null);
     }
 
-    public void setStartTime_MatchPhrasePrefix(Collection<Long> startTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("startTime", startTimeList);
+    public void setStartTime_Terms(Collection<Long> startTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("startTime", startTimeList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setStartTime_InScope(Collection<Long> startTimeList) {
-        setStartTime_MatchPhrasePrefix(startTimeList, null);
+        setStartTime_Terms(startTimeList, null);
     }
 
     public void setStartTime_InScope(Collection<Long> startTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setStartTime_MatchPhrasePrefix(startTimeList, opLambda);
+        setStartTime_Terms(startTimeList, opLambda);
     }
 
     public void setStartTime_Match(Long startTime) {
@@ -1058,7 +1059,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setStartTime_Match(Long startTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("startTime", startTime);
+        MatchQueryBuilder builder = regMatchQ("startTime", startTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1069,7 +1070,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setStartTime_MatchPhrase(Long startTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("startTime", startTime);
+        MatchQueryBuilder builder = regMatchPhraseQ("startTime", startTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1080,7 +1081,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setStartTime_MatchPhrasePrefix(Long startTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("startTime", startTime);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("startTime", startTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1091,7 +1092,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setStartTime_Fuzzy(Long startTime, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("startTime", startTime);
+        FuzzyQueryBuilder builder = regFuzzyQ("startTime", startTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1102,7 +1103,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setStartTime_GreaterThan(Long startTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("startTime", ConditionKey.CK_GREATER_THAN, startTime);
+        RangeQueryBuilder builder = regRangeQ("startTime", ConditionKey.CK_GREATER_THAN, startTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1113,7 +1114,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setStartTime_LessThan(Long startTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("startTime", ConditionKey.CK_LESS_THAN, startTime);
+        RangeQueryBuilder builder = regRangeQ("startTime", ConditionKey.CK_LESS_THAN, startTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1124,7 +1125,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setStartTime_GreaterEqual(Long startTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("startTime", ConditionKey.CK_GREATER_EQUAL, startTime);
+        RangeQueryBuilder builder = regRangeQ("startTime", ConditionKey.CK_GREATER_EQUAL, startTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1135,7 +1136,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setStartTime_LessEqual(Long startTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("startTime", ConditionKey.CK_LESS_EQUAL, startTime);
+        RangeQueryBuilder builder = regRangeQ("startTime", ConditionKey.CK_LESS_EQUAL, startTime);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1156,29 +1157,29 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setTarget_Term(String target, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("target", target);
+        TermQueryBuilder builder = regTermQ("target", target);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setTarget_Terms(Collection<String> targetList) {
-        setTarget_MatchPhrasePrefix(targetList, null);
+        setTarget_Terms(targetList, null);
     }
 
-    public void setTarget_MatchPhrasePrefix(Collection<String> targetList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("target", targetList);
+    public void setTarget_Terms(Collection<String> targetList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("target", targetList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setTarget_InScope(Collection<String> targetList) {
-        setTarget_MatchPhrasePrefix(targetList, null);
+        setTarget_Terms(targetList, null);
     }
 
     public void setTarget_InScope(Collection<String> targetList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setTarget_MatchPhrasePrefix(targetList, opLambda);
+        setTarget_Terms(targetList, opLambda);
     }
 
     public void setTarget_Match(String target) {
@@ -1186,7 +1187,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setTarget_Match(String target, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("target", target);
+        MatchQueryBuilder builder = regMatchQ("target", target);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1197,7 +1198,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setTarget_MatchPhrase(String target, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("target", target);
+        MatchQueryBuilder builder = regMatchPhraseQ("target", target);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1208,7 +1209,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setTarget_MatchPhrasePrefix(String target, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("target", target);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("target", target);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1219,7 +1220,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setTarget_Fuzzy(String target, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("target", target);
+        FuzzyQueryBuilder builder = regFuzzyQ("target", target);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1230,7 +1231,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setTarget_Prefix(String target, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("target", target);
+        PrefixQueryBuilder builder = regPrefixQ("target", target);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1241,7 +1242,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setTarget_GreaterThan(String target, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("target", ConditionKey.CK_GREATER_THAN, target);
+        RangeQueryBuilder builder = regRangeQ("target", ConditionKey.CK_GREATER_THAN, target);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1252,7 +1253,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setTarget_LessThan(String target, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("target", ConditionKey.CK_LESS_THAN, target);
+        RangeQueryBuilder builder = regRangeQ("target", ConditionKey.CK_LESS_THAN, target);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1263,7 +1264,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setTarget_GreaterEqual(String target, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("target", ConditionKey.CK_GREATER_EQUAL, target);
+        RangeQueryBuilder builder = regRangeQ("target", ConditionKey.CK_GREATER_EQUAL, target);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1274,7 +1275,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery {
     }
 
     public void setTarget_LessEqual(String target, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("target", ConditionKey.CK_LESS_EQUAL, target);
+        RangeQueryBuilder builder = regRangeQ("target", ConditionKey.CK_LESS_EQUAL, target);
         if (opLambda != null) {
             opLambda.callback(builder);
         }

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

@@ -3,6 +3,7 @@ package org.codelibs.fess.es.cbean.cq.bs;
 import java.util.Collection;
 
 import org.codelibs.fess.es.cbean.cq.KeyMatchCQ;
+import org.codelibs.fess.es.cbean.cf.KeyMatchCF;
 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 BsKeyMatchCQ extends AbstractConditionQuery {
         return "key_match";
     }
 
-    public void filtered(FilteredCall<KeyMatchCQ> filteredLambda) {
+    public void filtered(FilteredCall<KeyMatchCQ, KeyMatchCF> filteredLambda) {
         filtered(filteredLambda, null);
     }
 
-    public void filtered(FilteredCall<KeyMatchCQ> filteredLambda, ConditionOptionCall<FilteredQueryBuilder> opLambda) {
+    public void filtered(FilteredCall<KeyMatchCQ, KeyMatchCF> filteredLambda, ConditionOptionCall<FilteredQueryBuilder> opLambda) {
         KeyMatchCQ query = new KeyMatchCQ();
-        filteredLambda.callback(query);
-        if (!query.queryBuilderList.isEmpty()) {
-            // TODO filter
-            FilteredQueryBuilder builder = reqFilteredQ(query.getQuery(), null);
+        KeyMatchCF filter = new KeyMatchCF();
+        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 BsKeyMatchCQ extends AbstractConditionQuery {
         KeyMatchCQ shouldQuery = new KeyMatchCQ();
         KeyMatchCQ mustNotQuery = new KeyMatchCQ();
         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 BsKeyMatchCQ extends AbstractConditionQuery {
     }
 
     public void setBoost_Term(Float boost, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("boost", boost);
+        TermQueryBuilder builder = regTermQ("boost", boost);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setBoost_Terms(Collection<Float> boostList) {
-        setBoost_MatchPhrasePrefix(boostList, null);
+        setBoost_Terms(boostList, null);
     }
 
-    public void setBoost_MatchPhrasePrefix(Collection<Float> boostList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("boost", boostList);
+    public void setBoost_Terms(Collection<Float> boostList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("boost", boostList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setBoost_InScope(Collection<Float> boostList) {
-        setBoost_MatchPhrasePrefix(boostList, null);
+        setBoost_Terms(boostList, null);
     }
 
     public void setBoost_InScope(Collection<Float> boostList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setBoost_MatchPhrasePrefix(boostList, opLambda);
+        setBoost_Terms(boostList, opLambda);
     }
 
     public void setBoost_Match(Float boost) {
@@ -96,7 +97,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery {
     }
 
     public void setBoost_Match(Float boost, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("boost", boost);
+        MatchQueryBuilder builder = regMatchQ("boost", boost);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -107,7 +108,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery {
     }
 
     public void setBoost_MatchPhrase(Float boost, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("boost", boost);
+        MatchQueryBuilder builder = regMatchPhraseQ("boost", boost);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -118,7 +119,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery {
     }
 
     public void setBoost_MatchPhrasePrefix(Float boost, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("boost", boost);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("boost", boost);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -129,7 +130,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery {
     }
 
     public void setBoost_Fuzzy(Float boost, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("boost", boost);
+        FuzzyQueryBuilder builder = regFuzzyQ("boost", boost);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -140,7 +141,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery {
     }
 
     public void setBoost_GreaterThan(Float boost, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("boost", ConditionKey.CK_GREATER_THAN, boost);
+        RangeQueryBuilder builder = regRangeQ("boost", ConditionKey.CK_GREATER_THAN, boost);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -151,7 +152,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery {
     }
 
     public void setBoost_LessThan(Float boost, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("boost", ConditionKey.CK_LESS_THAN, boost);
+        RangeQueryBuilder builder = regRangeQ("boost", ConditionKey.CK_LESS_THAN, boost);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -162,7 +163,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery {
     }
 
     public void setBoost_GreaterEqual(Float boost, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("boost", ConditionKey.CK_GREATER_EQUAL, boost);
+        RangeQueryBuilder builder = regRangeQ("boost", ConditionKey.CK_GREATER_EQUAL, boost);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -173,7 +174,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery {
     }
 
     public void setBoost_LessEqual(Float boost, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("boost", ConditionKey.CK_LESS_EQUAL, boost);
+        RangeQueryBuilder builder = regRangeQ("boost", ConditionKey.CK_LESS_EQUAL, boost);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -194,29 +195,29 @@ public abstract class BsKeyMatchCQ 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) {
@@ -224,7 +225,7 @@ public abstract class BsKeyMatchCQ 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);
         }
@@ -235,7 +236,7 @@ public abstract class BsKeyMatchCQ 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);
         }
@@ -246,7 +247,7 @@ public abstract class BsKeyMatchCQ 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);
         }
@@ -257,7 +258,7 @@ public abstract class BsKeyMatchCQ 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);
         }
@@ -268,7 +269,7 @@ public abstract class BsKeyMatchCQ 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);
         }
@@ -279,7 +280,7 @@ public abstract class BsKeyMatchCQ 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);
         }
@@ -290,7 +291,7 @@ public abstract class BsKeyMatchCQ 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);
         }
@@ -301,7 +302,7 @@ public abstract class BsKeyMatchCQ 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);
         }
@@ -312,7 +313,7 @@ public abstract class BsKeyMatchCQ 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);
         }
@@ -333,29 +334,29 @@ public abstract class BsKeyMatchCQ 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) {
@@ -363,7 +364,7 @@ public abstract class BsKeyMatchCQ 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);
         }
@@ -374,7 +375,7 @@ public abstract class BsKeyMatchCQ 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);
         }
@@ -385,7 +386,7 @@ public abstract class BsKeyMatchCQ 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);
         }
@@ -396,7 +397,7 @@ public abstract class BsKeyMatchCQ 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);
         }
@@ -407,7 +408,7 @@ public abstract class BsKeyMatchCQ 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);
         }
@@ -418,7 +419,7 @@ public abstract class BsKeyMatchCQ 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);
         }
@@ -429,7 +430,7 @@ public abstract class BsKeyMatchCQ 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);
         }
@@ -440,7 +441,7 @@ public abstract class BsKeyMatchCQ 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);
         }
@@ -461,29 +462,29 @@ public abstract class BsKeyMatchCQ 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) {
@@ -491,7 +492,7 @@ public abstract class BsKeyMatchCQ 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);
         }
@@ -502,7 +503,7 @@ public abstract class BsKeyMatchCQ 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);
         }
@@ -513,7 +514,7 @@ public abstract class BsKeyMatchCQ 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);
         }
@@ -524,7 +525,7 @@ public abstract class BsKeyMatchCQ 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);
         }
@@ -535,7 +536,7 @@ public abstract class BsKeyMatchCQ 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);
         }
@@ -546,7 +547,7 @@ public abstract class BsKeyMatchCQ 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);
         }
@@ -557,7 +558,7 @@ public abstract class BsKeyMatchCQ 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);
         }
@@ -568,7 +569,7 @@ public abstract class BsKeyMatchCQ 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);
         }
@@ -579,7 +580,7 @@ public abstract class BsKeyMatchCQ 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);
         }
@@ -600,29 +601,29 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery {
     }
 
     public void setMaxSize_Term(Integer maxSize, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("maxSize", maxSize);
+        TermQueryBuilder builder = regTermQ("maxSize", maxSize);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setMaxSize_Terms(Collection<Integer> maxSizeList) {
-        setMaxSize_MatchPhrasePrefix(maxSizeList, null);
+        setMaxSize_Terms(maxSizeList, null);
     }
 
-    public void setMaxSize_MatchPhrasePrefix(Collection<Integer> maxSizeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("maxSize", maxSizeList);
+    public void setMaxSize_Terms(Collection<Integer> maxSizeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("maxSize", maxSizeList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setMaxSize_InScope(Collection<Integer> maxSizeList) {
-        setMaxSize_MatchPhrasePrefix(maxSizeList, null);
+        setMaxSize_Terms(maxSizeList, null);
     }
 
     public void setMaxSize_InScope(Collection<Integer> maxSizeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setMaxSize_MatchPhrasePrefix(maxSizeList, opLambda);
+        setMaxSize_Terms(maxSizeList, opLambda);
     }
 
     public void setMaxSize_Match(Integer maxSize) {
@@ -630,7 +631,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery {
     }
 
     public void setMaxSize_Match(Integer maxSize, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("maxSize", maxSize);
+        MatchQueryBuilder builder = regMatchQ("maxSize", maxSize);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -641,7 +642,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery {
     }
 
     public void setMaxSize_MatchPhrase(Integer maxSize, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("maxSize", maxSize);
+        MatchQueryBuilder builder = regMatchPhraseQ("maxSize", maxSize);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -652,7 +653,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery {
     }
 
     public void setMaxSize_MatchPhrasePrefix(Integer maxSize, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("maxSize", maxSize);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("maxSize", maxSize);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -663,7 +664,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery {
     }
 
     public void setMaxSize_Fuzzy(Integer maxSize, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("maxSize", maxSize);
+        FuzzyQueryBuilder builder = regFuzzyQ("maxSize", maxSize);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -674,7 +675,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery {
     }
 
     public void setMaxSize_GreaterThan(Integer maxSize, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("maxSize", ConditionKey.CK_GREATER_THAN, maxSize);
+        RangeQueryBuilder builder = regRangeQ("maxSize", ConditionKey.CK_GREATER_THAN, maxSize);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -685,7 +686,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery {
     }
 
     public void setMaxSize_LessThan(Integer maxSize, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("maxSize", ConditionKey.CK_LESS_THAN, maxSize);
+        RangeQueryBuilder builder = regRangeQ("maxSize", ConditionKey.CK_LESS_THAN, maxSize);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -696,7 +697,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery {
     }
 
     public void setMaxSize_GreaterEqual(Integer maxSize, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("maxSize", ConditionKey.CK_GREATER_EQUAL, maxSize);
+        RangeQueryBuilder builder = regRangeQ("maxSize", ConditionKey.CK_GREATER_EQUAL, maxSize);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -707,7 +708,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery {
     }
 
     public void setMaxSize_LessEqual(Integer maxSize, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("maxSize", ConditionKey.CK_LESS_EQUAL, maxSize);
+        RangeQueryBuilder builder = regRangeQ("maxSize", ConditionKey.CK_LESS_EQUAL, maxSize);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -728,29 +729,29 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery {
     }
 
     public void setQuery_Term(String query, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("query", query);
+        TermQueryBuilder builder = regTermQ("query", query);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setQuery_Terms(Collection<String> queryList) {
-        setQuery_MatchPhrasePrefix(queryList, null);
+        setQuery_Terms(queryList, null);
     }
 
-    public void setQuery_MatchPhrasePrefix(Collection<String> queryList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("query", queryList);
+    public void setQuery_Terms(Collection<String> queryList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("query", queryList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setQuery_InScope(Collection<String> queryList) {
-        setQuery_MatchPhrasePrefix(queryList, null);
+        setQuery_Terms(queryList, null);
     }
 
     public void setQuery_InScope(Collection<String> queryList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setQuery_MatchPhrasePrefix(queryList, opLambda);
+        setQuery_Terms(queryList, opLambda);
     }
 
     public void setQuery_Match(String query) {
@@ -758,7 +759,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery {
     }
 
     public void setQuery_Match(String query, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("query", query);
+        MatchQueryBuilder builder = regMatchQ("query", query);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -769,7 +770,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery {
     }
 
     public void setQuery_MatchPhrase(String query, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("query", query);
+        MatchQueryBuilder builder = regMatchPhraseQ("query", query);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -780,7 +781,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery {
     }
 
     public void setQuery_MatchPhrasePrefix(String query, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("query", query);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("query", query);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -791,7 +792,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery {
     }
 
     public void setQuery_Fuzzy(String query, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("query", query);
+        FuzzyQueryBuilder builder = regFuzzyQ("query", query);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -802,7 +803,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery {
     }
 
     public void setQuery_Prefix(String query, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("query", query);
+        PrefixQueryBuilder builder = regPrefixQ("query", query);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -813,7 +814,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery {
     }
 
     public void setQuery_GreaterThan(String query, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("query", ConditionKey.CK_GREATER_THAN, query);
+        RangeQueryBuilder builder = regRangeQ("query", ConditionKey.CK_GREATER_THAN, query);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -824,7 +825,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery {
     }
 
     public void setQuery_LessThan(String query, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("query", ConditionKey.CK_LESS_THAN, query);
+        RangeQueryBuilder builder = regRangeQ("query", ConditionKey.CK_LESS_THAN, query);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -835,7 +836,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery {
     }
 
     public void setQuery_GreaterEqual(String query, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("query", ConditionKey.CK_GREATER_EQUAL, query);
+        RangeQueryBuilder builder = regRangeQ("query", ConditionKey.CK_GREATER_EQUAL, query);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -846,7 +847,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery {
     }
 
     public void setQuery_LessEqual(String query, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("query", ConditionKey.CK_LESS_EQUAL, query);
+        RangeQueryBuilder builder = regRangeQ("query", ConditionKey.CK_LESS_EQUAL, query);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -867,29 +868,29 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery {
     }
 
     public void setTerm_Term(String term, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("term", term);
+        TermQueryBuilder builder = regTermQ("term", term);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setTerm_Terms(Collection<String> termList) {
-        setTerm_MatchPhrasePrefix(termList, null);
+        setTerm_Terms(termList, null);
     }
 
-    public void setTerm_MatchPhrasePrefix(Collection<String> termList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("term", termList);
+    public void setTerm_Terms(Collection<String> termList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("term", termList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setTerm_InScope(Collection<String> termList) {
-        setTerm_MatchPhrasePrefix(termList, null);
+        setTerm_Terms(termList, null);
     }
 
     public void setTerm_InScope(Collection<String> termList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setTerm_MatchPhrasePrefix(termList, opLambda);
+        setTerm_Terms(termList, opLambda);
     }
 
     public void setTerm_Match(String term) {
@@ -897,7 +898,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery {
     }
 
     public void setTerm_Match(String term, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("term", term);
+        MatchQueryBuilder builder = regMatchQ("term", term);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -908,7 +909,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery {
     }
 
     public void setTerm_MatchPhrase(String term, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("term", term);
+        MatchQueryBuilder builder = regMatchPhraseQ("term", term);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -919,7 +920,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery {
     }
 
     public void setTerm_MatchPhrasePrefix(String term, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("term", term);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("term", term);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -930,7 +931,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery {
     }
 
     public void setTerm_Fuzzy(String term, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("term", term);
+        FuzzyQueryBuilder builder = regFuzzyQ("term", term);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -941,7 +942,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery {
     }
 
     public void setTerm_Prefix(String term, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("term", term);
+        PrefixQueryBuilder builder = regPrefixQ("term", term);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -952,7 +953,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery {
     }
 
     public void setTerm_GreaterThan(String term, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("term", ConditionKey.CK_GREATER_THAN, term);
+        RangeQueryBuilder builder = regRangeQ("term", ConditionKey.CK_GREATER_THAN, term);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -963,7 +964,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery {
     }
 
     public void setTerm_LessThan(String term, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("term", ConditionKey.CK_LESS_THAN, term);
+        RangeQueryBuilder builder = regRangeQ("term", ConditionKey.CK_LESS_THAN, term);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -974,7 +975,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery {
     }
 
     public void setTerm_GreaterEqual(String term, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("term", ConditionKey.CK_GREATER_EQUAL, term);
+        RangeQueryBuilder builder = regRangeQ("term", ConditionKey.CK_GREATER_EQUAL, term);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -985,7 +986,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery {
     }
 
     public void setTerm_LessEqual(String term, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("term", ConditionKey.CK_LESS_EQUAL, term);
+        RangeQueryBuilder builder = regRangeQ("term", ConditionKey.CK_LESS_EQUAL, term);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -1006,29 +1007,29 @@ public abstract class BsKeyMatchCQ 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) {
@@ -1036,7 +1037,7 @@ public abstract class BsKeyMatchCQ 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);
         }
@@ -1047,7 +1048,7 @@ public abstract class BsKeyMatchCQ 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);
         }
@@ -1058,7 +1059,7 @@ public abstract class BsKeyMatchCQ 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);
         }
@@ -1069,7 +1070,7 @@ public abstract class BsKeyMatchCQ 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);
         }
@@ -1080,7 +1081,7 @@ public abstract class BsKeyMatchCQ 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);
         }
@@ -1091,7 +1092,7 @@ public abstract class BsKeyMatchCQ 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);
         }
@@ -1102,7 +1103,7 @@ public abstract class BsKeyMatchCQ 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);
         }
@@ -1113,7 +1114,7 @@ public abstract class BsKeyMatchCQ 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);
         }
@@ -1124,7 +1125,7 @@ public abstract class BsKeyMatchCQ 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);
         }
@@ -1145,29 +1146,29 @@ public abstract class BsKeyMatchCQ 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) {
@@ -1175,7 +1176,7 @@ public abstract class BsKeyMatchCQ 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);
         }
@@ -1186,7 +1187,7 @@ public abstract class BsKeyMatchCQ 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);
         }
@@ -1197,7 +1198,7 @@ public abstract class BsKeyMatchCQ 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);
         }
@@ -1208,7 +1209,7 @@ public abstract class BsKeyMatchCQ 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);
         }
@@ -1219,7 +1220,7 @@ public abstract class BsKeyMatchCQ 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);
         }
@@ -1230,7 +1231,7 @@ public abstract class BsKeyMatchCQ 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);
         }
@@ -1241,7 +1242,7 @@ public abstract class BsKeyMatchCQ 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);
         }
@@ -1252,7 +1253,7 @@ public abstract class BsKeyMatchCQ 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/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/BsPathMappingCQ.java

@@ -3,6 +3,7 @@ package org.codelibs.fess.es.cbean.cq.bs;
 import java.util.Collection;
 
 import org.codelibs.fess.es.cbean.cq.PathMappingCQ;
+import org.codelibs.fess.es.cbean.cf.PathMappingCF;
 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 BsPathMappingCQ extends AbstractConditionQuery {
         return "path_mapping";
     }
 
-    public void filtered(FilteredCall<PathMappingCQ> filteredLambda) {
+    public void filtered(FilteredCall<PathMappingCQ, PathMappingCF> filteredLambda) {
         filtered(filteredLambda, null);
     }
 
-    public void filtered(FilteredCall<PathMappingCQ> filteredLambda, ConditionOptionCall<FilteredQueryBuilder> opLambda) {
+    public void filtered(FilteredCall<PathMappingCQ, PathMappingCF> filteredLambda, ConditionOptionCall<FilteredQueryBuilder> opLambda) {
         PathMappingCQ query = new PathMappingCQ();
-        filteredLambda.callback(query);
-        if (!query.queryBuilderList.isEmpty()) {
-            // TODO filter
-            FilteredQueryBuilder builder = reqFilteredQ(query.getQuery(), null);
+        PathMappingCF filter = new PathMappingCF();
+        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 BsPathMappingCQ extends AbstractConditionQuery {
         PathMappingCQ shouldQuery = new PathMappingCQ();
         PathMappingCQ mustNotQuery = new PathMappingCQ();
         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 BsPathMappingCQ 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 BsPathMappingCQ 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 BsPathMappingCQ 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 BsPathMappingCQ 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 BsPathMappingCQ 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 BsPathMappingCQ 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 BsPathMappingCQ 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 BsPathMappingCQ 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 BsPathMappingCQ 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 BsPathMappingCQ 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 BsPathMappingCQ 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 BsPathMappingCQ 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 BsPathMappingCQ 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 BsPathMappingCQ 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 BsPathMappingCQ 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 BsPathMappingCQ 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 BsPathMappingCQ 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 BsPathMappingCQ 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 BsPathMappingCQ 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 BsPathMappingCQ 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 BsPathMappingCQ 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 BsPathMappingCQ 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 BsPathMappingCQ 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 BsPathMappingCQ 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 BsPathMappingCQ 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 BsPathMappingCQ 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 BsPathMappingCQ 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 BsPathMappingCQ 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 BsPathMappingCQ 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 BsPathMappingCQ extends AbstractConditionQuery {
     }
 
     public void setProcessType_Term(String processType, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("processType", processType);
+        TermQueryBuilder builder = regTermQ("processType", processType);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setProcessType_Terms(Collection<String> processTypeList) {
-        setProcessType_MatchPhrasePrefix(processTypeList, null);
+        setProcessType_Terms(processTypeList, null);
     }
 
-    public void setProcessType_MatchPhrasePrefix(Collection<String> processTypeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("processType", processTypeList);
+    public void setProcessType_Terms(Collection<String> processTypeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("processType", processTypeList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setProcessType_InScope(Collection<String> processTypeList) {
-        setProcessType_MatchPhrasePrefix(processTypeList, null);
+        setProcessType_Terms(processTypeList, null);
     }
 
     public void setProcessType_InScope(Collection<String> processTypeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setProcessType_MatchPhrasePrefix(processTypeList, opLambda);
+        setProcessType_Terms(processTypeList, opLambda);
     }
 
     public void setProcessType_Match(String processType) {
@@ -502,7 +503,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery {
     }
 
     public void setProcessType_Match(String processType, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("processType", processType);
+        MatchQueryBuilder builder = regMatchQ("processType", processType);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -513,7 +514,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery {
     }
 
     public void setProcessType_MatchPhrase(String processType, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("processType", processType);
+        MatchQueryBuilder builder = regMatchPhraseQ("processType", processType);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -524,7 +525,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery {
     }
 
     public void setProcessType_MatchPhrasePrefix(String processType, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("processType", processType);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("processType", processType);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -535,7 +536,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery {
     }
 
     public void setProcessType_Fuzzy(String processType, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("processType", processType);
+        FuzzyQueryBuilder builder = regFuzzyQ("processType", processType);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -546,7 +547,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery {
     }
 
     public void setProcessType_Prefix(String processType, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("processType", processType);
+        PrefixQueryBuilder builder = regPrefixQ("processType", processType);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -557,7 +558,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery {
     }
 
     public void setProcessType_GreaterThan(String processType, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("processType", ConditionKey.CK_GREATER_THAN, processType);
+        RangeQueryBuilder builder = regRangeQ("processType", ConditionKey.CK_GREATER_THAN, processType);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -568,7 +569,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery {
     }
 
     public void setProcessType_LessThan(String processType, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("processType", ConditionKey.CK_LESS_THAN, processType);
+        RangeQueryBuilder builder = regRangeQ("processType", ConditionKey.CK_LESS_THAN, processType);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -579,7 +580,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery {
     }
 
     public void setProcessType_GreaterEqual(String processType, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("processType", ConditionKey.CK_GREATER_EQUAL, processType);
+        RangeQueryBuilder builder = regRangeQ("processType", ConditionKey.CK_GREATER_EQUAL, processType);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -590,7 +591,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery {
     }
 
     public void setProcessType_LessEqual(String processType, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("processType", ConditionKey.CK_LESS_EQUAL, processType);
+        RangeQueryBuilder builder = regRangeQ("processType", ConditionKey.CK_LESS_EQUAL, processType);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -611,29 +612,29 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery {
     }
 
     public void setRegex_Term(String regex, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("regex", regex);
+        TermQueryBuilder builder = regTermQ("regex", regex);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setRegex_Terms(Collection<String> regexList) {
-        setRegex_MatchPhrasePrefix(regexList, null);
+        setRegex_Terms(regexList, null);
     }
 
-    public void setRegex_MatchPhrasePrefix(Collection<String> regexList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("regex", regexList);
+    public void setRegex_Terms(Collection<String> regexList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("regex", regexList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setRegex_InScope(Collection<String> regexList) {
-        setRegex_MatchPhrasePrefix(regexList, null);
+        setRegex_Terms(regexList, null);
     }
 
     public void setRegex_InScope(Collection<String> regexList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setRegex_MatchPhrasePrefix(regexList, opLambda);
+        setRegex_Terms(regexList, opLambda);
     }
 
     public void setRegex_Match(String regex) {
@@ -641,7 +642,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery {
     }
 
     public void setRegex_Match(String regex, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("regex", regex);
+        MatchQueryBuilder builder = regMatchQ("regex", regex);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -652,7 +653,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery {
     }
 
     public void setRegex_MatchPhrase(String regex, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("regex", regex);
+        MatchQueryBuilder builder = regMatchPhraseQ("regex", regex);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -663,7 +664,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery {
     }
 
     public void setRegex_MatchPhrasePrefix(String regex, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("regex", regex);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("regex", regex);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -674,7 +675,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery {
     }
 
     public void setRegex_Fuzzy(String regex, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("regex", regex);
+        FuzzyQueryBuilder builder = regFuzzyQ("regex", regex);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -685,7 +686,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery {
     }
 
     public void setRegex_Prefix(String regex, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("regex", regex);
+        PrefixQueryBuilder builder = regPrefixQ("regex", regex);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -696,7 +697,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery {
     }
 
     public void setRegex_GreaterThan(String regex, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("regex", ConditionKey.CK_GREATER_THAN, regex);
+        RangeQueryBuilder builder = regRangeQ("regex", ConditionKey.CK_GREATER_THAN, regex);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -707,7 +708,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery {
     }
 
     public void setRegex_LessThan(String regex, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("regex", ConditionKey.CK_LESS_THAN, regex);
+        RangeQueryBuilder builder = regRangeQ("regex", ConditionKey.CK_LESS_THAN, regex);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -718,7 +719,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery {
     }
 
     public void setRegex_GreaterEqual(String regex, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("regex", ConditionKey.CK_GREATER_EQUAL, regex);
+        RangeQueryBuilder builder = regRangeQ("regex", ConditionKey.CK_GREATER_EQUAL, regex);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -729,7 +730,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery {
     }
 
     public void setRegex_LessEqual(String regex, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("regex", ConditionKey.CK_LESS_EQUAL, regex);
+        RangeQueryBuilder builder = regRangeQ("regex", ConditionKey.CK_LESS_EQUAL, regex);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -750,29 +751,29 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery {
     }
 
     public void setReplacement_Term(String replacement, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("replacement", replacement);
+        TermQueryBuilder builder = regTermQ("replacement", replacement);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setReplacement_Terms(Collection<String> replacementList) {
-        setReplacement_MatchPhrasePrefix(replacementList, null);
+        setReplacement_Terms(replacementList, null);
     }
 
-    public void setReplacement_MatchPhrasePrefix(Collection<String> replacementList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("replacement", replacementList);
+    public void setReplacement_Terms(Collection<String> replacementList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("replacement", replacementList);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void setReplacement_InScope(Collection<String> replacementList) {
-        setReplacement_MatchPhrasePrefix(replacementList, null);
+        setReplacement_Terms(replacementList, null);
     }
 
     public void setReplacement_InScope(Collection<String> replacementList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        setReplacement_MatchPhrasePrefix(replacementList, opLambda);
+        setReplacement_Terms(replacementList, opLambda);
     }
 
     public void setReplacement_Match(String replacement) {
@@ -780,7 +781,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery {
     }
 
     public void setReplacement_Match(String replacement, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("replacement", replacement);
+        MatchQueryBuilder builder = regMatchQ("replacement", replacement);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -791,7 +792,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery {
     }
 
     public void setReplacement_MatchPhrase(String replacement, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("replacement", replacement);
+        MatchQueryBuilder builder = regMatchPhraseQ("replacement", replacement);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -802,7 +803,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery {
     }
 
     public void setReplacement_MatchPhrasePrefix(String replacement, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("replacement", replacement);
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("replacement", replacement);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -813,7 +814,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery {
     }
 
     public void setReplacement_Fuzzy(String replacement, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("replacement", replacement);
+        FuzzyQueryBuilder builder = regFuzzyQ("replacement", replacement);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -824,7 +825,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery {
     }
 
     public void setReplacement_Prefix(String replacement, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("replacement", replacement);
+        PrefixQueryBuilder builder = regPrefixQ("replacement", replacement);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -835,7 +836,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery {
     }
 
     public void setReplacement_GreaterThan(String replacement, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("replacement", ConditionKey.CK_GREATER_THAN, replacement);
+        RangeQueryBuilder builder = regRangeQ("replacement", ConditionKey.CK_GREATER_THAN, replacement);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -846,7 +847,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery {
     }
 
     public void setReplacement_LessThan(String replacement, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("replacement", ConditionKey.CK_LESS_THAN, replacement);
+        RangeQueryBuilder builder = regRangeQ("replacement", ConditionKey.CK_LESS_THAN, replacement);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -857,7 +858,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery {
     }
 
     public void setReplacement_GreaterEqual(String replacement, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("replacement", ConditionKey.CK_GREATER_EQUAL, replacement);
+        RangeQueryBuilder builder = regRangeQ("replacement", ConditionKey.CK_GREATER_EQUAL, replacement);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -868,7 +869,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery {
     }
 
     public void setReplacement_LessEqual(String replacement, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("replacement", ConditionKey.CK_LESS_EQUAL, replacement);
+        RangeQueryBuilder builder = regRangeQ("replacement", ConditionKey.CK_LESS_EQUAL, replacement);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -889,29 +890,29 @@ public abstract class BsPathMappingCQ 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) {
@@ -919,7 +920,7 @@ public abstract class BsPathMappingCQ 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);
         }
@@ -930,7 +931,7 @@ public abstract class BsPathMappingCQ 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);
         }
@@ -941,7 +942,7 @@ public abstract class BsPathMappingCQ 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);
         }
@@ -952,7 +953,7 @@ public abstract class BsPathMappingCQ 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);
         }
@@ -963,7 +964,7 @@ public abstract class BsPathMappingCQ 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);
         }
@@ -974,7 +975,7 @@ public abstract class BsPathMappingCQ 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);
         }
@@ -985,7 +986,7 @@ public abstract class BsPathMappingCQ 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);
         }
@@ -996,7 +997,7 @@ public abstract class BsPathMappingCQ 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);
         }
@@ -1017,29 +1018,29 @@ public abstract class BsPathMappingCQ 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) {
@@ -1047,7 +1048,7 @@ public abstract class BsPathMappingCQ 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);
         }
@@ -1058,7 +1059,7 @@ public abstract class BsPathMappingCQ 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);
         }
@@ -1069,7 +1070,7 @@ public abstract class BsPathMappingCQ 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);
         }
@@ -1080,7 +1081,7 @@ public abstract class BsPathMappingCQ 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);
         }
@@ -1091,7 +1092,7 @@ public abstract class BsPathMappingCQ 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);
         }
@@ -1102,7 +1103,7 @@ public abstract class BsPathMappingCQ 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);
         }
@@ -1113,7 +1114,7 @@ public abstract class BsPathMappingCQ 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);
         }
@@ -1124,7 +1125,7 @@ public abstract class BsPathMappingCQ 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);
         }
@@ -1135,7 +1136,7 @@ public abstract class BsPathMappingCQ 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);
         }
@@ -1156,29 +1157,29 @@ public abstract class BsPathMappingCQ 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) {
@@ -1186,7 +1187,7 @@ public abstract class BsPathMappingCQ 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);
         }
@@ -1197,7 +1198,7 @@ public abstract class BsPathMappingCQ 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);
         }
@@ -1208,7 +1209,7 @@ public abstract class BsPathMappingCQ 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);
         }
@@ -1219,7 +1220,7 @@ public abstract class BsPathMappingCQ 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);
         }
@@ -1230,7 +1231,7 @@ public abstract class BsPathMappingCQ 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);
         }
@@ -1241,7 +1242,7 @@ public abstract class BsPathMappingCQ 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);
         }
@@ -1252,7 +1253,7 @@ public abstract class BsPathMappingCQ 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);
         }
@@ -1263,7 +1264,7 @@ public abstract class BsPathMappingCQ 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);
         }