class TermsConditionEvaluator implements ConditionEvaluatorStrategy {
    public static final String TYPE = "terms";

    public static Condition createCondition(List<Term> terms) {<FILL_FUNCTION_BODY>}

    @Override
    public String getType() {
        return TYPE;
    }

    @Override
    public boolean evaluate(Condition condition, RuleData context) {
        return false;
    }

    @Override
    public Function<RuleData, Mono<Boolean>> prepare(Condition condition) {
        List<Term> terms = condition
            .getConfig("terms")
            .map(val -> CastUtils
                .castArray(val)
                .stream()
                .map(obj -> FastBeanCopier.copy(obj, new Term()))
                .collect(Collectors.toList()))
            .orElseGet(() -> condition
                .getConfig("where")
                .map(String::valueOf)
                .map(TermExpressionParser::parse)
                .orElseThrow(() -> new IllegalArgumentException("terms can not be null"))
            );

        return ReactorUtils.createFilter(terms,
                                         RuleDataHelper::toContextMap,
                                         (arg, map) -> VariableSource.of(arg).resolveStatic(map));
    }
}

        Condition condition = new Condition();
        condition.setType(TYPE);
        condition.setConfiguration(Collections.singletonMap("terms", terms));
        return condition;
    
<no_super_class>