//                                                                           =========

    public void filter(String name, EsAbstractConditionQuery.OperatorCall<BsWebAuthenticationCQ> queryLambda,
            ConditionOptionCall<FilterAggregationBuilder> opLambda, OperatorCall<BsWebAuthenticationCA> aggsLambda) {
        WebAuthenticationCQ cq = new WebAuthenticationCQ();
        if (queryLambda != null) {
            queryLambda.callback(cq);

    //                                                                           =========

    public void filter(String name, EsAbstractConditionQuery.OperatorCall<BsFileAuthenticationCQ> queryLambda,
            ConditionOptionCall<FilterAggregationBuilder> opLambda, OperatorCall<BsFileAuthenticationCA> aggsLambda) {
        FileAuthenticationCQ cq = new FileAuthenticationCQ();
        if (queryLambda != null) {

    //                                                                           =========

    public void filter(String name, EsAbstractConditionQuery.OperatorCall<BsRelatedContentCQ> queryLambda,
            ConditionOptionCall<FilterAggregationBuilder> opLambda, OperatorCall<BsRelatedContentCA> aggsLambda) {
        RelatedContentCQ cq = new RelatedContentCQ();
        if (queryLambda != null) {
            queryLambda.callback(cq);

    //                                                                           =========

    public void filter(String name, EsAbstractConditionQuery.OperatorCall<BsDuplicateHostCQ> queryLambda,
            ConditionOptionCall<FilterAggregationBuilder> opLambda, OperatorCall<BsDuplicateHostCA> aggsLambda) {
        DuplicateHostCQ cq = new DuplicateHostCQ();
        if (queryLambda != null) {
            queryLambda.callback(cq);
        }

        bool((must, should, mustNot, filter) -> {
            filteredLambda.callback(must, filter);
        }, opLambda);
    }

    public void not(OperatorCall<DuplicateHostCQ> notLambda) {
        not(notLambda, null);
    }

    public void not(final OperatorCall<DuplicateHostCQ> notLambda, final ConditionOptionCall<BoolQueryBuilder> opLambda) {
        bool((must, should, mustNot, filter) -> notLambda.callback(mustNot), opLambda);

        bool((must, should, mustNot, filter) -> {
            filteredLambda.callback(must, filter);
        }, opLambda);
    }

    public void not(OperatorCall<RelatedContentCQ> notLambda) {
        not(notLambda, null);
    }

    public void not(final OperatorCall<RelatedContentCQ> notLambda, final ConditionOptionCall<BoolQueryBuilder> opLambda) {
        bool((must, should, mustNot, filter) -> notLambda.callback(mustNot), opLambda);

        bool((must, should, mustNot, filter) -> {
            filteredLambda.callback(must, filter);
        }, opLambda);
    }

    public void not(OperatorCall<ThumbnailQueueCQ> notLambda) {
        not(notLambda, null);
    }

    public void not(final OperatorCall<ThumbnailQueueCQ> notLambda, final ConditionOptionCall<BoolQueryBuilder> opLambda) {
        bool((must, should, mustNot, filter) -> notLambda.callback(mustNot), opLambda);

        bool((must, should, mustNot, filter) -> {
            filteredLambda.callback(must, filter);
        }, opLambda);
    }

    public void not(OperatorCall<KeyMatchCQ> notLambda) {
        not(notLambda, null);
    }

    public void not(final OperatorCall<KeyMatchCQ> notLambda, final ConditionOptionCall<BoolQueryBuilder> opLambda) {
        bool((must, should, mustNot, filter) -> notLambda.callback(mustNot), opLambda);
    }

        bool((must, should, mustNot, filter) -> {
            filteredLambda.callback(must, filter);
        }, opLambda);
    }

    public void not(OperatorCall<RequestHeaderCQ> notLambda) {
        not(notLambda, null);
    }

    public void not(final OperatorCall<RequestHeaderCQ> notLambda, final ConditionOptionCall<BoolQueryBuilder> opLambda) {
        bool((must, should, mustNot, filter) -> notLambda.callback(mustNot), opLambda);

        bool((must, should, mustNot, filter) -> {
            filteredLambda.callback(must, filter);
        }, opLambda);
    }

    public void not(OperatorCall<JobLogCQ> notLambda) {
        not(notLambda, null);
    }

    public void not(final OperatorCall<JobLogCQ> notLambda, final ConditionOptionCall<BoolQueryBuilder> opLambda) {
        bool((must, should, mustNot, filter) -> notLambda.callback(mustNot), opLambda);
    }