diff --git a/src/main/java/org/hisp/dhis/rules/models/RuleVariable.java b/src/main/java/org/hisp/dhis/rules/models/RuleVariable.java
deleted file mode 100644
index a37290c5..00000000
--- a/src/main/java/org/hisp/dhis/rules/models/RuleVariable.java
+++ /dev/null
@@ -1,45 +0,0 @@
-package org.hisp.dhis.rules.models;
-
-import org.hisp.dhis.rules.Option;
-import org.hisp.dhis.rules.RuleVariableValue;
-import org.hisp.dhis.rules.RuleVariableValueMapBuilder;
-
-import javax.annotation.Nonnull;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-
-
-public interface RuleVariable
-{
-    /**
-     * @return Name of the variable. Something what users refer to
-     * when building program rules.
-     */
-    @Nonnull
-    String name();
-
-    boolean useCodeForOptionSet();
-
-    @Nonnull
-    List<Option> options();
-
-    Map<String, RuleVariableValue> createValues( RuleVariableValueMapBuilder builder,
-        Map<String, List<RuleDataValue>> allEventValues,
-        Map<String, RuleAttributeValue> currentEnrollmentValues,
-        Map<String, RuleDataValue> currentEventValues );
-
-    default String getOptionName( String value )
-    {
-        // if no option found then existing value in the context will be used
-        if ( options() == null || options().isEmpty() )
-        {
-            return value;
-        }
-        return options().stream()
-                .filter( op -> Objects.equals( value, op.getCode() ) )
-                .map( Option::getName)
-                .findAny()
-                .orElse( value );
-    }
-}
diff --git a/src/main/java/org/hisp/dhis/rules/models/RuleVariable.kt b/src/main/java/org/hisp/dhis/rules/models/RuleVariable.kt
new file mode 100644
index 00000000..6559c00f
--- /dev/null
+++ b/src/main/java/org/hisp/dhis/rules/models/RuleVariable.kt
@@ -0,0 +1,25 @@
+package org.hisp.dhis.rules.models
+
+import org.hisp.dhis.rules.Option
+import org.hisp.dhis.rules.RuleVariableValue
+import org.hisp.dhis.rules.RuleVariableValueMapBuilder
+import java.util.function.Predicate
+import javax.annotation.Nonnull
+
+interface RuleVariable {
+    fun options(): List<Option>
+    fun createValues(
+        builder: RuleVariableValueMapBuilder,
+        allEventValues: Map<String, List<RuleDataValue>>,
+        currentEnrollmentValues: Map<String, RuleAttributeValue>,
+        currentEventValues: Map<String, RuleDataValue>
+    ): Map<String, RuleVariableValue>
+
+    fun getOptionName(value: String?): String? {
+        // if no option found then existing value in the context will be used
+        return options()
+            .filter{ (_, code): Option -> value == code }
+            .map(Option::name)
+            .getOrElse(0) {_ -> value}
+    }
+}
diff --git a/src/main/java/org/hisp/dhis/rules/models/RuleVariableAttribute.java b/src/main/java/org/hisp/dhis/rules/models/RuleVariableAttribute.java
deleted file mode 100644
index 73b19f25..00000000
--- a/src/main/java/org/hisp/dhis/rules/models/RuleVariableAttribute.java
+++ /dev/null
@@ -1,55 +0,0 @@
-package org.hisp.dhis.rules.models;
-
-import org.hisp.dhis.rules.Option;
-import org.hisp.dhis.rules.RuleVariableValue;
-import org.hisp.dhis.rules.RuleVariableValueMapBuilder;
-
-import javax.annotation.Nonnull;
-import java.util.Date;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-import static org.hisp.dhis.rules.UtilsKt.getDateFormat;
-
-public record RuleVariableAttribute(
-        @Nonnull String name,
-        boolean useCodeForOptionSet,
-        @Nonnull List<Option> options,
-        @Nonnull String trackedEntityAttribute,
-        @Nonnull RuleValueType trackedEntityAttributeType
-) implements RuleVariable {
-
-    @Nonnull
-    public static RuleVariableAttribute create(@Nonnull String name,
-                                               @Nonnull String attribute, @Nonnull RuleValueType attributeType, boolean useCodeForOptionSet, List<Option> options) {
-        return new RuleVariableAttribute(name, useCodeForOptionSet, options, attribute, attributeType);
-    }
-
-    @Override
-    public Map<String, RuleVariableValue> createValues(RuleVariableValueMapBuilder builder,
-                                                       Map<String, List<RuleDataValue>> allEventValues,
-                                                       Map<String, RuleAttributeValue> currentEnrollmentValues,
-                                                       Map<String, RuleDataValue> currentEventValues) {
-        Map<String, RuleVariableValue> valueMap = new HashMap<>();
-
-        String currentDate = getDateFormat().format(new Date());
-
-        RuleVariableValue variableValue;
-
-        if (currentEnrollmentValues.containsKey(this.trackedEntityAttribute())) {
-            RuleAttributeValue value = currentEnrollmentValues
-                    .get(this.trackedEntityAttribute());
-
-            String optionValue = this.useCodeForOptionSet() ? value.value() : getOptionName(value.value());
-
-            variableValue = RuleVariableValue.create(optionValue, this.trackedEntityAttributeType(),
-                    List.of(optionValue), currentDate);
-        } else {
-            variableValue = RuleVariableValue.create(this.trackedEntityAttributeType());
-        }
-
-        valueMap.put(this.name(), variableValue);
-        return valueMap;
-    }
-}
diff --git a/src/main/java/org/hisp/dhis/rules/models/RuleVariableAttribute.kt b/src/main/java/org/hisp/dhis/rules/models/RuleVariableAttribute.kt
new file mode 100644
index 00000000..a099d4f9
--- /dev/null
+++ b/src/main/java/org/hisp/dhis/rules/models/RuleVariableAttribute.kt
@@ -0,0 +1,43 @@
+package org.hisp.dhis.rules.models
+
+import org.hisp.dhis.rules.Option
+import org.hisp.dhis.rules.RuleVariableValue
+import org.hisp.dhis.rules.RuleVariableValueMapBuilder
+import org.hisp.dhis.rules.dateFormat
+import java.util.*
+import javax.annotation.Nonnull
+
+data class RuleVariableAttribute(
+    val name: String,
+    val useCodeForOptionSet: Boolean,
+    val options: List<Option>,
+    val trackedEntityAttribute: String,
+    val trackedEntityAttributeType: RuleValueType
+) : RuleVariable {
+    override fun options(): List<Option> {
+        return options
+    }
+
+    override fun createValues(
+        builder: RuleVariableValueMapBuilder,
+        allEventValues: Map<String, List<RuleDataValue>>,
+        currentEnrollmentValues: Map<String, RuleAttributeValue>,
+        currentEventValues: Map<String, RuleDataValue>
+    ): Map<String, RuleVariableValue> {
+        val valueMap: MutableMap<String, RuleVariableValue> = HashMap()
+        val currentDate = dateFormat.format(Date())
+        val variableValue: RuleVariableValue
+        variableValue = if (currentEnrollmentValues.containsKey(trackedEntityAttribute)) {
+            val value = currentEnrollmentValues[trackedEntityAttribute]
+            val optionValue = if (useCodeForOptionSet) value!!.value else getOptionName(value!!.value)!!
+            RuleVariableValue.create(
+                optionValue, trackedEntityAttributeType,
+                java.util.List.of(optionValue), currentDate
+            )
+        } else {
+            RuleVariableValue.create(trackedEntityAttributeType)
+        }
+        valueMap[name] = variableValue
+        return valueMap
+    }
+}
diff --git a/src/main/java/org/hisp/dhis/rules/models/RuleVariableCalculatedValue.java b/src/main/java/org/hisp/dhis/rules/models/RuleVariableCalculatedValue.java
deleted file mode 100644
index cdfd818b..00000000
--- a/src/main/java/org/hisp/dhis/rules/models/RuleVariableCalculatedValue.java
+++ /dev/null
@@ -1,67 +0,0 @@
-package org.hisp.dhis.rules.models;
-
-/*
- * Copyright (c) 2004-2018, University of Oslo
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * Redistributions of source code must retain the above copyright notice, this
- * list of conditions and the following disclaimer.
- *
- * Redistributions in binary form must reproduce the above copyright notice,
- * this list of conditions and the following disclaimer in the documentation
- * and/or other materials provided with the distribution.
- * Neither the name of the HISP project nor the names of its contributors may
- * be used to endorse or promote products derived from this software without
- * specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
- * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
- * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-import org.hisp.dhis.rules.Option;
-import org.hisp.dhis.rules.RuleVariableValue;
-import org.hisp.dhis.rules.RuleVariableValueMapBuilder;
-
-import javax.annotation.Nonnull;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-/**
- * @author Zubair Asghar.
- */
-
-public record RuleVariableCalculatedValue(
-        @Nonnull String name,
-        boolean useCodeForOptionSet,
-        @Nonnull List<Option> options,
-        @Nonnull String calculatedValueVariable,
-        @Nonnull RuleValueType calculatedValueType
-) implements RuleVariable {
-    @Nonnull
-    public static RuleVariableCalculatedValue create(@Nonnull String name,
-                                                     @Nonnull String variable, @Nonnull RuleValueType variableType, boolean useCodeForOptionSet, List<Option> options) {
-        return new RuleVariableCalculatedValue(name, useCodeForOptionSet, options, variable, variableType);
-    }
-
-    @Override
-    public Map<String, RuleVariableValue> createValues(RuleVariableValueMapBuilder builder,
-                                                       Map<String, List<RuleDataValue>> allEventValues,
-                                                       Map<String, RuleAttributeValue> currentEnrollmentValues,
-                                                       Map<String, RuleDataValue> currentEventValues) {
-        Map<String, RuleVariableValue> valueMap = new HashMap<>();
-
-        valueMap.put(this.name(), RuleVariableValue.create(this.calculatedValueType()));
-        return valueMap;
-    }
-}
diff --git a/src/main/java/org/hisp/dhis/rules/models/RuleVariableCalculatedValue.kt b/src/main/java/org/hisp/dhis/rules/models/RuleVariableCalculatedValue.kt
new file mode 100644
index 00000000..fcc70583
--- /dev/null
+++ b/src/main/java/org/hisp/dhis/rules/models/RuleVariableCalculatedValue.kt
@@ -0,0 +1,56 @@
+package org.hisp.dhis.rules.models
+
+import org.hisp.dhis.rules.*
+import javax.annotation.Nonnull
+
+/*
+* Copyright (c) 2004-2018, University of Oslo
+* All rights reserved.
+*
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions are met:
+* Redistributions of source code must retain the above copyright notice, this
+* list of conditions and the following disclaimer.
+*
+* Redistributions in binary form must reproduce the above copyright notice,
+* this list of conditions and the following disclaimer in the documentation
+* and/or other materials provided with the distribution.
+* Neither the name of the HISP project nor the names of its contributors may
+* be used to endorse or promote products derived from this software without
+* specific prior written permission.
+*
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/ /**
+ * @author Zubair Asghar.
+ */
+class RuleVariableCalculatedValue(
+    val name: String,
+    val useCodeForOptionSet: Boolean,
+    val options: List<Option>,
+    val calculatedValueVariable: String,
+    val calculatedValueType: RuleValueType
+) : RuleVariable {
+    override fun options(): List<Option> {
+        return options
+    }
+
+    override fun createValues(
+        builder: RuleVariableValueMapBuilder,
+        allEventValues: Map<String, List<RuleDataValue>>,
+        currentEnrollmentValues: Map<String, RuleAttributeValue>,
+        currentEventValues: Map<String, RuleDataValue>
+    ): Map<String, RuleVariableValue> {
+        val valueMap: MutableMap<String, RuleVariableValue> = HashMap()
+        valueMap[name] = RuleVariableValue.create(calculatedValueType)
+        return valueMap
+    }
+}
diff --git a/src/main/java/org/hisp/dhis/rules/models/RuleVariableCurrentEvent.java b/src/main/java/org/hisp/dhis/rules/models/RuleVariableCurrentEvent.java
deleted file mode 100644
index d2f21280..00000000
--- a/src/main/java/org/hisp/dhis/rules/models/RuleVariableCurrentEvent.java
+++ /dev/null
@@ -1,51 +0,0 @@
-package org.hisp.dhis.rules.models;
-
-import org.hisp.dhis.rules.Option;
-import org.hisp.dhis.rules.RuleVariableValue;
-import org.hisp.dhis.rules.RuleVariableValueMapBuilder;
-
-import javax.annotation.Nonnull;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-import static org.hisp.dhis.rules.UtilsKt.getLastUpdateDate;
-
-public record RuleVariableCurrentEvent(
-        @Nonnull String name,
-        boolean useCodeForOptionSet,
-        @Nonnull List<Option> options,
-        @Nonnull String dataElement,
-        @Nonnull RuleValueType dataElementType
-) implements RuleVariableDataElement {
-
-    @Nonnull
-    public static RuleVariableCurrentEvent create(@Nonnull String name,
-                                                  @Nonnull String dataElement, @Nonnull RuleValueType dataElementValueType, boolean useCodeForOptionSet, List<Option> options) {
-        return new RuleVariableCurrentEvent(name, useCodeForOptionSet, options, dataElement, dataElementValueType);
-    }
-
-    @Override
-    public Map<String, RuleVariableValue> createValues(RuleVariableValueMapBuilder builder,
-                                                       Map<String, List<RuleDataValue>> allEventValues,
-                                                       Map<String, RuleAttributeValue> currentEnrollmentValues,
-                                                       Map<String, RuleDataValue> currentEventValues) {
-        Map<String, RuleVariableValue> valueMap = new HashMap<>();
-
-        RuleVariableValue variableValue;
-
-        if (currentEventValues.containsKey(this.dataElement())) {
-            RuleDataValue value = currentEventValues.get(this.dataElement());
-
-            String optionValue = this.useCodeForOptionSet() ? value.value() : getOptionName(value.value());
-
-            variableValue = RuleVariableValue.create(optionValue, this.dataElementType(),
-                    List.of(optionValue), getLastUpdateDate(List.of(value)));
-        } else {
-            variableValue = RuleVariableValue.create(this.dataElementType());
-        }
-
-        valueMap.put(this.name(), variableValue);
-        return valueMap;
-    }
-}
diff --git a/src/main/java/org/hisp/dhis/rules/models/RuleVariableCurrentEvent.kt b/src/main/java/org/hisp/dhis/rules/models/RuleVariableCurrentEvent.kt
new file mode 100644
index 00000000..2e603da2
--- /dev/null
+++ b/src/main/java/org/hisp/dhis/rules/models/RuleVariableCurrentEvent.kt
@@ -0,0 +1,46 @@
+package org.hisp.dhis.rules.models
+
+import org.hisp.dhis.rules.*
+import javax.annotation.Nonnull
+
+class RuleVariableCurrentEvent(
+    val name: String,
+    val useCodeForOptionSet: Boolean,
+    val options: List<Option>,
+    val dataElement: String,
+    val dataElementType: RuleValueType
+) : RuleVariableDataElement {
+    override fun dataElement(): String {
+        return dataElement
+    }
+
+    override fun dataElementType(): RuleValueType {
+        return dataElementType
+    }
+
+    override fun options(): List<Option> {
+        return options
+    }
+
+    override fun createValues(
+        builder: RuleVariableValueMapBuilder,
+        allEventValues: Map<String, List<RuleDataValue>>,
+        currentEnrollmentValues: Map<String, RuleAttributeValue>,
+        currentEventValues: Map<String, RuleDataValue>
+    ): Map<String, RuleVariableValue> {
+        val valueMap: MutableMap<String, RuleVariableValue> = HashMap()
+        val variableValue: RuleVariableValue
+        variableValue = if (currentEventValues.containsKey(dataElement)) {
+            val value = currentEventValues[dataElement]
+            val optionValue = if (useCodeForOptionSet) value!!.value else getOptionName(value!!.value)!!
+            RuleVariableValue.create(
+                optionValue, dataElementType,
+                java.util.List.of(optionValue), getLastUpdateDate(java.util.List.of(value))
+            )
+        } else {
+            RuleVariableValue.create(dataElementType)
+        }
+        valueMap[name] = variableValue
+        return valueMap
+    }
+}
diff --git a/src/main/java/org/hisp/dhis/rules/models/RuleVariableDataElement.java b/src/main/java/org/hisp/dhis/rules/models/RuleVariableDataElement.java
deleted file mode 100644
index fbe5631f..00000000
--- a/src/main/java/org/hisp/dhis/rules/models/RuleVariableDataElement.java
+++ /dev/null
@@ -1,13 +0,0 @@
-package org.hisp.dhis.rules.models;
-
-
-import javax.annotation.Nonnull;
-
-interface RuleVariableDataElement extends RuleVariable {
-
-    @Nonnull
-    String dataElement();
-
-    @Nonnull
-    RuleValueType dataElementType();
-}
diff --git a/src/main/java/org/hisp/dhis/rules/models/RuleVariableDataElement.kt b/src/main/java/org/hisp/dhis/rules/models/RuleVariableDataElement.kt
new file mode 100644
index 00000000..24fedb4a
--- /dev/null
+++ b/src/main/java/org/hisp/dhis/rules/models/RuleVariableDataElement.kt
@@ -0,0 +1,11 @@
+package org.hisp.dhis.rules.models
+
+import javax.annotation.Nonnull
+
+internal interface RuleVariableDataElement : RuleVariable {
+    @Nonnull
+    fun dataElement(): String
+
+    @Nonnull
+    fun dataElementType(): RuleValueType
+}
diff --git a/src/main/java/org/hisp/dhis/rules/models/RuleVariableNewestEvent.java b/src/main/java/org/hisp/dhis/rules/models/RuleVariableNewestEvent.java
deleted file mode 100644
index c0f91f99..00000000
--- a/src/main/java/org/hisp/dhis/rules/models/RuleVariableNewestEvent.java
+++ /dev/null
@@ -1,55 +0,0 @@
-package org.hisp.dhis.rules.models;
-
-import org.hisp.dhis.rules.Option;
-import org.hisp.dhis.rules.RuleVariableValue;
-import org.hisp.dhis.rules.RuleVariableValueMapBuilder;
-
-import javax.annotation.Nonnull;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-import static org.hisp.dhis.rules.UtilsKt.getLastUpdateDate;
-import static org.hisp.dhis.rules.UtilsKt.values;
-
-public record RuleVariableNewestEvent(
-        @Nonnull String name,
-        boolean useCodeForOptionSet,
-        @Nonnull List<Option> options,
-        @Nonnull String dataElement,
-        @Nonnull RuleValueType dataElementType
-) implements RuleVariableDataElement {
-
-    @Nonnull
-    public static RuleVariableNewestEvent create(@Nonnull String name,
-                                                 @Nonnull String dataElement, @Nonnull RuleValueType dataElementValueType, boolean useCodeForOptionSet, List<Option> options) {
-        return new RuleVariableNewestEvent(name, useCodeForOptionSet, options, dataElement, dataElementValueType);
-    }
-
-    @Override
-    public Map<String, RuleVariableValue> createValues(RuleVariableValueMapBuilder builder,
-                                                       Map<String, List<RuleDataValue>> allEventValues,
-                                                       Map<String, RuleAttributeValue> currentEnrollmentValues,
-                                                       Map<String, RuleDataValue> currentEventValues) {
-        Map<String, RuleVariableValue> valueMap = new HashMap<>();
-        List<RuleDataValue> ruleDataValues = allEventValues.get(this.dataElement());
-
-        if (ruleDataValues == null || ruleDataValues.isEmpty()) {
-            valueMap.put(this.name(), RuleVariableValue.create(this.dataElementType()));
-        } else {
-            RuleVariableValue variableValue;
-
-            RuleDataValue value = ruleDataValues.get(0);
-
-            String optionValue = this.useCodeForOptionSet() ? value.value() : getOptionName(value.value());
-
-            variableValue = RuleVariableValue.create(optionValue,
-                    this.dataElementType(), values(ruleDataValues), getLastUpdateDate(ruleDataValues));
-
-
-            valueMap.put(this.name(), variableValue);
-        }
-
-        return valueMap;
-    }
-}
diff --git a/src/main/java/org/hisp/dhis/rules/models/RuleVariableNewestEvent.kt b/src/main/java/org/hisp/dhis/rules/models/RuleVariableNewestEvent.kt
new file mode 100644
index 00000000..6f55a7eb
--- /dev/null
+++ b/src/main/java/org/hisp/dhis/rules/models/RuleVariableNewestEvent.kt
@@ -0,0 +1,47 @@
+package org.hisp.dhis.rules.models
+
+import org.hisp.dhis.rules.*
+import javax.annotation.Nonnull
+
+class RuleVariableNewestEvent(
+    val name: String,
+    val useCodeForOptionSet: Boolean,
+    val options: List<Option>,
+    val  dataElement: String,
+    val dataElementType: RuleValueType
+) : RuleVariableDataElement {
+    override fun dataElement(): String {
+        return dataElement
+    }
+
+    override fun dataElementType(): RuleValueType {
+        return dataElementType
+    }
+
+    override fun options(): List<Option> {
+        return options
+    }
+
+    override fun createValues(
+        builder: RuleVariableValueMapBuilder,
+        allEventValues: Map<String, List<RuleDataValue>>,
+        currentEnrollmentValues: Map<String, RuleAttributeValue>,
+        currentEventValues: Map<String, RuleDataValue>
+    ): Map<String, RuleVariableValue> {
+        val valueMap: MutableMap<String, RuleVariableValue> = HashMap()
+        val ruleDataValues = allEventValues[dataElement]
+        if (ruleDataValues == null || ruleDataValues.isEmpty()) {
+            valueMap[name] = RuleVariableValue.create(dataElementType)
+        } else {
+            val variableValue: RuleVariableValue
+            val value = ruleDataValues[0]
+            val optionValue = if (useCodeForOptionSet) value.value else getOptionName(value.value)!!
+            variableValue = RuleVariableValue.create(
+                optionValue,
+                dataElementType, values(ruleDataValues), getLastUpdateDate(ruleDataValues)
+            )
+            valueMap[name] = variableValue
+        }
+        return valueMap
+    }
+}
diff --git a/src/main/java/org/hisp/dhis/rules/models/RuleVariableNewestStageEvent.java b/src/main/java/org/hisp/dhis/rules/models/RuleVariableNewestStageEvent.java
deleted file mode 100644
index 64a40af3..00000000
--- a/src/main/java/org/hisp/dhis/rules/models/RuleVariableNewestStageEvent.java
+++ /dev/null
@@ -1,68 +0,0 @@
-package org.hisp.dhis.rules.models;
-
-import org.hisp.dhis.rules.Option;
-import org.hisp.dhis.rules.RuleVariableValue;
-import org.hisp.dhis.rules.RuleVariableValueMapBuilder;
-
-import javax.annotation.Nonnull;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-import static org.hisp.dhis.rules.UtilsKt.getLastUpdateDate;
-import static org.hisp.dhis.rules.UtilsKt.values;
-
-public record RuleVariableNewestStageEvent(
-        @Nonnull String name,
-        boolean useCodeForOptionSet,
-        @Nonnull List<Option> options,
-        @Nonnull String dataElement,
-        @Nonnull RuleValueType dataElementType,
-        @Nonnull String programStage
-) implements RuleVariableDataElement {
-
-    @Nonnull
-    public static RuleVariableNewestStageEvent create(@Nonnull String name, @Nonnull String dataElement,
-                                                      @Nonnull String programStage, @Nonnull RuleValueType dataElementType, boolean useCodeForOptionSet, List<Option> options) {
-        return new RuleVariableNewestStageEvent(name, useCodeForOptionSet, options, dataElement,
-                dataElementType, programStage);
-    }
-
-    @Override
-    public Map<String, RuleVariableValue> createValues(RuleVariableValueMapBuilder builder,
-                                                       Map<String, List<RuleDataValue>> allEventValues,
-                                                       Map<String, RuleAttributeValue> currentEnrollmentValues,
-                                                       Map<String, RuleDataValue> currentEventValues) {
-        Map<String, RuleVariableValue> valueMap = new HashMap<>();
-        List<RuleDataValue> stageRuleDataValues = new ArrayList<>();
-        List<RuleDataValue> sourceRuleDataValues = allEventValues.get(this.dataElement());
-        if (sourceRuleDataValues != null && !sourceRuleDataValues.isEmpty()) {
-
-            // filter data values based on program stage
-            for (RuleDataValue ruleDataValue : sourceRuleDataValues) {
-                if (this.programStage().equals(ruleDataValue.programStage())) {
-                    stageRuleDataValues.add(ruleDataValue);
-                }
-            }
-        }
-
-        if (stageRuleDataValues.isEmpty()) {
-            valueMap.put(this.name(), RuleVariableValue.create(this.dataElementType()));
-        } else {
-            RuleVariableValue variableValue;
-
-            RuleDataValue value = stageRuleDataValues.get(0);
-
-            String optionValue = this.useCodeForOptionSet() ? value.value() : getOptionName(value.value());
-
-            variableValue = RuleVariableValue.create(optionValue,
-                    this.dataElementType(), values(stageRuleDataValues),
-                    getLastUpdateDate(stageRuleDataValues));
-
-            valueMap.put(this.name(), variableValue);
-        }
-
-        return valueMap;
-    }
-}
diff --git a/src/main/java/org/hisp/dhis/rules/models/RuleVariableNewestStageEvent.kt b/src/main/java/org/hisp/dhis/rules/models/RuleVariableNewestStageEvent.kt
new file mode 100644
index 00000000..70405b4d
--- /dev/null
+++ b/src/main/java/org/hisp/dhis/rules/models/RuleVariableNewestStageEvent.kt
@@ -0,0 +1,59 @@
+package org.hisp.dhis.rules.models
+
+import org.hisp.dhis.rules.*
+import javax.annotation.Nonnull
+
+class RuleVariableNewestStageEvent(
+    val name: String,
+    val useCodeForOptionSet: Boolean,
+    val options: List<Option>,
+    val dataElement: String,
+    val dataElementType: RuleValueType,
+    val programStage: String
+) : RuleVariableDataElement {
+    override fun dataElement(): String {
+        return dataElement
+    }
+
+    override fun dataElementType(): RuleValueType {
+        return dataElementType
+    }
+
+    override fun options(): List<Option> {
+        return options
+    }
+
+    override fun createValues(
+        builder: RuleVariableValueMapBuilder,
+        allEventValues: Map<String, List<RuleDataValue>>,
+        currentEnrollmentValues: Map<String, RuleAttributeValue>,
+        currentEventValues: Map<String, RuleDataValue>
+    ): Map<String, RuleVariableValue> {
+        val valueMap: MutableMap<String, RuleVariableValue> = HashMap()
+        val stageRuleDataValues: MutableList<RuleDataValue> = ArrayList()
+        val sourceRuleDataValues = allEventValues[dataElement]
+        if (sourceRuleDataValues != null && !sourceRuleDataValues.isEmpty()) {
+
+            // filter data values based on program stage
+            for (ruleDataValue in sourceRuleDataValues) {
+                if (programStage == ruleDataValue.programStage) {
+                    stageRuleDataValues.add(ruleDataValue)
+                }
+            }
+        }
+        if (stageRuleDataValues.isEmpty()) {
+            valueMap[name] = RuleVariableValue.create(dataElementType)
+        } else {
+            val variableValue: RuleVariableValue
+            val value = stageRuleDataValues[0]
+            val optionValue = if (useCodeForOptionSet) value.value else getOptionName(value.value)!!
+            variableValue = RuleVariableValue.create(
+                optionValue,
+                dataElementType, values(stageRuleDataValues),
+                getLastUpdateDate(stageRuleDataValues)
+            )
+            valueMap[name] = variableValue
+        }
+        return valueMap
+    }
+}
diff --git a/src/main/java/org/hisp/dhis/rules/models/RuleVariablePreviousEvent.java b/src/main/java/org/hisp/dhis/rules/models/RuleVariablePreviousEvent.java
deleted file mode 100644
index 32d3d15c..00000000
--- a/src/main/java/org/hisp/dhis/rules/models/RuleVariablePreviousEvent.java
+++ /dev/null
@@ -1,60 +0,0 @@
-package org.hisp.dhis.rules.models;
-
-import org.hisp.dhis.rules.Option;
-import org.hisp.dhis.rules.RuleVariableValue;
-import org.hisp.dhis.rules.RuleVariableValueMapBuilder;
-
-import javax.annotation.Nonnull;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-import static org.hisp.dhis.rules.UtilsKt.getLastUpdateDateForPrevious;
-import static org.hisp.dhis.rules.UtilsKt.values;
-
-public record RuleVariablePreviousEvent(
-        @Nonnull String name,
-        boolean useCodeForOptionSet,
-        @Nonnull List<Option> options,
-        @Nonnull String dataElement,
-        @Nonnull RuleValueType dataElementType
-) implements RuleVariableDataElement {
-
-    @Nonnull
-    public static RuleVariablePreviousEvent create(@Nonnull String name,
-                                                   @Nonnull String dataElement, @Nonnull RuleValueType valueType, boolean useCodeForOptionSet, List<Option> options) {
-        return new RuleVariablePreviousEvent(name, useCodeForOptionSet, options, dataElement, valueType);
-    }
-
-    @Override
-    public Map<String, RuleVariableValue> createValues(RuleVariableValueMapBuilder builder,
-                                                       Map<String, List<RuleDataValue>> allEventValues,
-                                                       Map<String, RuleAttributeValue> currentEnrollmentValues,
-                                                       Map<String, RuleDataValue> currentEventValues) {
-        Map<String, RuleVariableValue> valueMap = new HashMap<>();
-
-        RuleVariableValue variableValue = null;
-        List<RuleDataValue> ruleDataValues = allEventValues.get(this.dataElement());
-        if (builder.ruleEvent != null && ruleDataValues != null && !ruleDataValues.isEmpty()) {
-            for (RuleDataValue ruleDataValue : ruleDataValues) {
-                // We found preceding value to the current currentEventValues,
-                // which is assumed to be best candidate.
-                if (builder.ruleEvent.eventDate().compareTo(ruleDataValue.eventDate()) > 0) {
-                    String optionValue = this.useCodeForOptionSet() ? ruleDataValue.value() : getOptionName(ruleDataValue.value());
-
-                    variableValue = RuleVariableValue.create(optionValue, this.dataElementType(),
-                            values(ruleDataValues),
-                            getLastUpdateDateForPrevious(ruleDataValues, builder.ruleEvent));
-                    break;
-                }
-            }
-        }
-
-        if (variableValue == null) {
-            variableValue = RuleVariableValue.create(this.dataElementType());
-        }
-
-        valueMap.put(this.name(), variableValue);
-        return valueMap;
-    }
-}
diff --git a/src/main/java/org/hisp/dhis/rules/models/RuleVariablePreviousEvent.kt b/src/main/java/org/hisp/dhis/rules/models/RuleVariablePreviousEvent.kt
new file mode 100644
index 00000000..ec259ebd
--- /dev/null
+++ b/src/main/java/org/hisp/dhis/rules/models/RuleVariablePreviousEvent.kt
@@ -0,0 +1,56 @@
+package org.hisp.dhis.rules.models
+
+import org.hisp.dhis.rules.*
+import javax.annotation.Nonnull
+
+class RuleVariablePreviousEvent(
+    val name: String,
+    val useCodeForOptionSet: Boolean,
+    val options: List<Option>,
+    val dataElement: String,
+    val dataElementType: RuleValueType
+) : RuleVariableDataElement {
+    override fun dataElement(): String {
+        return dataElement
+    }
+
+    override fun dataElementType(): RuleValueType {
+        return dataElementType
+    }
+
+    override fun options(): List<Option> {
+        return options
+    }
+
+    override fun createValues(
+        builder: RuleVariableValueMapBuilder,
+        allEventValues: Map<String, List<RuleDataValue>>,
+        currentEnrollmentValues: Map<String, RuleAttributeValue>,
+        currentEventValues: Map<String, RuleDataValue>
+    ): Map<String, RuleVariableValue> {
+        val valueMap: MutableMap<String, RuleVariableValue> = HashMap()
+        var variableValue: RuleVariableValue? = null
+        val ruleDataValues = allEventValues[dataElement]
+        if (builder.ruleEvent != null && ruleDataValues != null && !ruleDataValues.isEmpty()) {
+            for (ruleDataValue in ruleDataValues) {
+                // We found preceding value to the current currentEventValues,
+                // which is assumed to be best candidate.
+                if (builder.ruleEvent!!.eventDate().compareTo(ruleDataValue.eventDate) > 0) {
+                    val optionValue =
+                        if (useCodeForOptionSet) ruleDataValue.value else getOptionName(ruleDataValue.value)!!
+                    variableValue = RuleVariableValue.create(
+                        optionValue, dataElementType,
+                        values(ruleDataValues),
+                        getLastUpdateDateForPrevious(ruleDataValues, builder.ruleEvent!!)
+                    )
+                    break
+                }
+            }
+        }
+        if (variableValue == null) {
+            variableValue = RuleVariableValue.create(dataElementType)
+        }
+        valueMap[name] = variableValue
+        return valueMap
+    }
+}
diff --git a/src/test/java/org/hisp/dhis/rules/RuleEngineFunctionTest.kt b/src/test/java/org/hisp/dhis/rules/RuleEngineFunctionTest.kt
index ed46df06..354ce4f3 100644
--- a/src/test/java/org/hisp/dhis/rules/RuleEngineFunctionTest.kt
+++ b/src/test/java/org/hisp/dhis/rules/RuleEngineFunctionTest.kt
@@ -51,20 +51,20 @@ class RuleEngineFunctionTest {
         val ruleEvent = RuleEvent(
             "test_event", "test_program_stage", "",
             RuleEvent.Status.ACTIVE, Date(), Date(),  null, "",
-            null, java.util.List.of(
+            null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_one", "condition")
             )
         )
         val ruleNotFailingEvent = RuleEvent(
             "test_not_failing_event", "test_program_stage", "",
             RuleEvent.Status.ACTIVE, yesterday, yesterday,  null, "",
-            null, java.util.List.of(
+            null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_one", "condition")
             )
         )
         val ruleEngine = RuleEngineTestUtils.getRuleEngine(
-            java.util.List.of(failingRule), ruleEnrollment,
-            java.util.List.of(ruleEvent, ruleNotFailingEvent)
+            listOf(failingRule), ruleEnrollment,
+            listOf(ruleEvent, ruleNotFailingEvent)
         )
         val ruleEffects = ruleEngine.evaluate()
         assertEquals(3, ruleEffects.size)
@@ -88,15 +88,15 @@ class RuleEngineFunctionTest {
         val ruleAction: RuleAction = RuleActionText.createForFeedback(
             "test_action_content", "d2:hasValue(#{test_variable})"
         )
-        val ruleVariable: RuleVariable = RuleVariableCurrentEvent.create(
-            "test_variable", "test_data_element_one", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariable: RuleVariable = RuleVariableCurrentEvent(
+            "test_variable", true, emptyList(),"test_data_element_one", RuleValueType.TEXT
         )
-        val rule: Rule = Rule("true", java.util.List.of(ruleAction), "", "")
-        val ruleEngine = RuleEngineTestUtils.getRuleEngine(rule, java.util.List.of(ruleVariable))
+        val rule: Rule = Rule("true", listOf(ruleAction), "", "")
+        val ruleEngine = RuleEngineTestUtils.getRuleEngine(rule, listOf(ruleVariable))
         val ruleEvent = RuleEvent(
             "test_event", "test_program_stage", "",
             RuleEvent.Status.ACTIVE, Date(), Date(),  null, "",
-            null, java.util.List.of(
+            null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_one", "test_value")
             )
         )
@@ -110,19 +110,18 @@ class RuleEngineFunctionTest {
     fun optionSetNameShouldBeUsed() {
         val option1 = Option("name1", "code1")
         val option2 = Option("name2", "code2")
-        val options = java.util.List.of(option1, option2)
+        val options = listOf(option1, option2)
         val ruleAction: RuleAction = RuleActionText.createForFeedback(
             "test_action_content", "#{test_variable}"
         )
-        val ruleVariable: RuleVariable = RuleVariableNewestEvent.create(
-            "test_variable", "test_data_element", RuleValueType.TEXT, USE_NAME_FOR_OPTION_SET, options
-        )
-        val rule: Rule = Rule("true", java.util.List.of(ruleAction), "", "")
-        val ruleEngine = RuleEngineTestUtils.getRuleEngine(rule, java.util.List.of(ruleVariable))
+        val ruleVariable: RuleVariable = RuleVariableNewestEvent("test_variable",
+            USE_NAME_FOR_OPTION_SET, options, "test_data_element", RuleValueType.TEXT)
+        val rule = Rule("true", listOf(ruleAction), "", "")
+        val ruleEngine = RuleEngineTestUtils.getRuleEngine(rule, listOf(ruleVariable))
         val ruleEvent = RuleEvent(
             "test_event", "test_program_stage", "",
             RuleEvent.Status.ACTIVE, Date(), Date(),  null, "",
-            null, java.util.List.of(
+            null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element", option1.code)
             )
         )
@@ -136,19 +135,19 @@ class RuleEngineFunctionTest {
     fun optionSetCodeShouldBeUsed() {
         val option1 = Option("name1", "code1")
         val option2 = Option("name2", "code2")
-        val options = java.util.List.of(option1, option2)
+        val options = listOf(option1, option2)
         val ruleAction: RuleAction = RuleActionText.createForFeedback(
             "test_action_content", "#{test_variable}"
         )
-        val ruleVariable: RuleVariable = RuleVariableCurrentEvent.create(
-            "test_variable", "test_data_element", RuleValueType.TEXT, USE_CODE_FOR_OPTION_SET, options
+        val ruleVariable: RuleVariable = RuleVariableCurrentEvent(
+            "test_variable", USE_CODE_FOR_OPTION_SET, options, "test_data_element", RuleValueType.TEXT
         )
-        val rule: Rule = Rule("true", java.util.List.of(ruleAction), "", "")
-        val ruleEngine = RuleEngineTestUtils.getRuleEngine(rule, java.util.List.of(ruleVariable))
+        val rule: Rule = Rule("true", listOf(ruleAction), "", "")
+        val ruleEngine = RuleEngineTestUtils.getRuleEngine(rule, listOf(ruleVariable))
         val ruleEvent = RuleEvent(
             "test_event", "test_program_stage", "",
             RuleEvent.Status.ACTIVE, Date(), Date(),  null, "",
-            null, java.util.List.of(
+            null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element", option2.code)
             )
         )
@@ -164,15 +163,15 @@ class RuleEngineFunctionTest {
         val ruleAction: RuleAction = RuleActionText.createForFeedback(
             "test_action_content", "d2:hasValue('test_variable')"
         )
-        val ruleVariable: RuleVariable = RuleVariableCurrentEvent.create(
-            "test_variable", "test_data_element", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariable: RuleVariable = RuleVariableCurrentEvent(
+            "test_variable", true, ArrayList(),"test_data_element", RuleValueType.TEXT
         )
-        val rule: Rule = Rule("true", java.util.List.of(ruleAction), "", "")
-        val ruleEngine = RuleEngineTestUtils.getRuleEngine(rule, java.util.List.of(ruleVariable))
+        val rule: Rule = Rule("true", listOf(ruleAction), "", "")
+        val ruleEngine = RuleEngineTestUtils.getRuleEngine(rule, listOf(ruleVariable))
         val ruleEvent = RuleEvent(
             "test_event", "test_program_stage", "",
             RuleEvent.Status.ACTIVE, Date(), Date(),  null, "",
-            null, java.util.List.of(
+            null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element", "test_value")
             )
         )
@@ -187,15 +186,15 @@ class RuleEngineFunctionTest {
         val ruleAction: RuleAction = RuleActionText.createForFeedback(
             "test_action_content", "d2:hasValue(#{test_variable})"
         )
-        val ruleVariable: RuleVariable = RuleVariableCurrentEvent.create(
-            "test_variable", "test_data_element", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariable: RuleVariable = RuleVariableCurrentEvent(
+            "test_variable", true, ArrayList(), "test_data_element", RuleValueType.TEXT
         )
-        val rule: Rule = Rule("true", java.util.List.of(ruleAction), "", "")
-        val ruleEngine = RuleEngineTestUtils.getRuleEngine(rule, java.util.List.of(ruleVariable))
+        val rule: Rule = Rule("true", listOf(ruleAction), "", "")
+        val ruleEngine = RuleEngineTestUtils.getRuleEngine(rule, listOf(ruleVariable))
         val ruleEvent = RuleEvent(
             "test_event", "test_program_stage", "",
             RuleEvent.Status.ACTIVE, Date(), Date(),  null, "",
-            null, java.util.List.of(
+            null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_one", "condition")
             )
         )
@@ -210,14 +209,13 @@ class RuleEngineFunctionTest {
         val ruleAction: RuleAction = RuleActionText.createForFeedback(
             "test_action_content", "V{program_stage_name}"
         )
-        val ruleVariable: RuleVariable = RuleVariableCurrentEvent
-            .create("variable", "test_data_element", RuleValueType.TEXT, true, ArrayList())
-        val rule: Rule = Rule("true", java.util.List.of(ruleAction), "", "")
-        val ruleEngine = RuleEngineTestUtils.getRuleEngine(rule, java.util.List.of(ruleVariable))
+        val ruleVariable: RuleVariable = RuleVariableCurrentEvent("variable", true, ArrayList(), "test_data_element", RuleValueType.TEXT)
+        val rule: Rule = Rule("true", listOf(ruleAction), "", "")
+        val ruleEngine = RuleEngineTestUtils.getRuleEngine(rule, listOf(ruleVariable))
         val ruleEvent = RuleEvent(
             "test_event", "test_program_stage_id", "test_program_stage_name",
             RuleEvent.Status.ACTIVE, Date(), Date(),  null, "",
-            null, java.util.List.of(
+            null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_one", "condition")
             )
         )
@@ -232,17 +230,17 @@ class RuleEngineFunctionTest {
         val ruleAction: RuleAction = RuleActionText.createForFeedback(
             "test_action_content", "d2:daysBetween(#{test_var_one}, #{test_var_two})"
         )
-        val ruleVariableOne: RuleVariable = RuleVariableCurrentEvent.create(
-            "test_var_one", "test_data_element_one", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariableOne: RuleVariable = RuleVariableCurrentEvent(
+            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.TEXT
         )
-        val ruleVariableTwo: RuleVariable = RuleVariableCurrentEvent.create(
-            "test_var_two", "test_data_element_two", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariableTwo: RuleVariable = RuleVariableCurrentEvent(
+            "test_var_two", true, ArrayList(), "test_data_element_two", RuleValueType.TEXT
         )
-        val rule: Rule = Rule("true", java.util.List.of(ruleAction), "", "")
-        val ruleEngine = RuleEngineTestUtils.getRuleEngine(rule, java.util.List.of(ruleVariableOne, ruleVariableTwo))
+        val rule: Rule = Rule("true", listOf(ruleAction), "", "")
+        val ruleEngine = RuleEngineTestUtils.getRuleEngine(rule, listOf(ruleVariableOne, ruleVariableTwo))
         val ruleEvent = RuleEvent(
             "test_event", "test_program_stage","",
-            RuleEvent.Status.ACTIVE, Date(), Date(), null, "", null, java.util.List.of(
+            RuleEvent.Status.ACTIVE, Date(), Date(), null, "", null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_one", "2017-01-01"),
                 RuleDataValue
                     .create(Date(), "test_program_stage", "test_data_element_two", "2017-02-01")
@@ -259,17 +257,17 @@ class RuleEngineFunctionTest {
         val ruleAction: RuleAction = RuleActionText.createForFeedback(
             "test_action_content", "d2:daysBetween(#{test_var_one}, '2018-01-01')"
         )
-        val ruleVariableOne: RuleVariable = RuleVariableCurrentEvent.create(
-            "test_var_one", "test_data_element_one", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariableOne: RuleVariable = RuleVariableCurrentEvent(
+            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.TEXT
         )
-        val ruleVariableTwo: RuleVariable = RuleVariableCurrentEvent.create(
-            "test_var_two", "test_data_element_two", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariableTwo: RuleVariable = RuleVariableCurrentEvent(
+            "test_var_two", true, ArrayList(), "test_data_element_two", RuleValueType.TEXT
         )
-        val rule: Rule = Rule("true", java.util.List.of(ruleAction), "", "")
-        val ruleEngine = RuleEngineTestUtils.getRuleEngine(rule, java.util.List.of(ruleVariableOne, ruleVariableTwo))
+        val rule: Rule = Rule("true", listOf(ruleAction), "", "")
+        val ruleEngine = RuleEngineTestUtils.getRuleEngine(rule, listOf(ruleVariableOne, ruleVariableTwo))
         val ruleEvent = RuleEvent(
             "test_event", "test_program_stage","",
-            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, java.util.List.of(
+            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_one", "2017-01-01"),
                 RuleDataValue
                     .create(Date(), "test_program_stage", "test_data_element_two", "2017-02-01")
@@ -289,14 +287,14 @@ class RuleEngineFunctionTest {
         val ruleAction: RuleAction = RuleActionText.createForFeedback(
             "test_action_content", "d2:inOrgUnitGroup(#{test_var_one})"
         )
-        val ruleVariableOne: RuleVariable = RuleVariableCurrentEvent.create(
-            "test_var_one", "test_data_element_one", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariableOne: RuleVariable = RuleVariableCurrentEvent(
+            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.TEXT
         )
-        val rule: Rule = Rule("true", java.util.List.of(ruleAction), "", "")
+        val rule: Rule = Rule("true", listOf(ruleAction), "", "")
         val ruleEngine = RuleEngine(RuleEngineContext(listOf(rule),listOf(ruleVariableOne),supplementaryData))
         val ruleEvent = RuleEvent(
             "test_event", "test_program_stage","",
-            RuleEvent.Status.ACTIVE, Date(), Date(), null, "location1", null, java.util.List.of(
+            RuleEvent.Status.ACTIVE, Date(), Date(), null, "location1", null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_one", "OU_GROUP_ID")
             )
         )
@@ -315,14 +313,14 @@ class RuleEngineFunctionTest {
         val ruleAction: RuleAction = RuleActionText.createForFeedback(
             "test_action_content", "d2:inOrgUnitGroup('OU_GROUP_ID')"
         )
-        val ruleVariableOne: RuleVariable = RuleVariableCurrentEvent.create(
-            "test_var_one", "test_data_element_one", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariableOne: RuleVariable = RuleVariableCurrentEvent(
+            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.TEXT
         )
-        val rule: Rule = Rule("true", java.util.List.of(ruleAction), "", "")
+        val rule: Rule = Rule("true", listOf(ruleAction), "", "")
         val ruleEngine = RuleEngine(RuleEngineContext(listOf(rule),listOf(ruleVariableOne),supplementaryData))
         val ruleEvent = RuleEvent(
             "test_event", "test_program_stage","",
-            RuleEvent.Status.ACTIVE, Date(), Date(), null, "location1", null, java.util.List.of(
+            RuleEvent.Status.ACTIVE, Date(), Date(), null, "location1", null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_one", "OU_GROUP_ID")
             )
         )
@@ -340,14 +338,14 @@ class RuleEngineFunctionTest {
         val ruleAction: RuleAction = RuleActionText.createForFeedback(
             "test_action_content", "d2:hasUserRole(#{test_var_one})"
         )
-        val ruleVariableOne: RuleVariable = RuleVariableCurrentEvent.create(
-            "test_var_one", "test_data_element_one", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariableOne: RuleVariable = RuleVariableCurrentEvent(
+            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.TEXT
         )
-        val rule: Rule = Rule("true", java.util.List.of(ruleAction), "", "")
+        val rule: Rule = Rule("true", listOf(ruleAction), "", "")
         val ruleEngine = RuleEngine(RuleEngineContext(listOf(rule),listOf(ruleVariableOne),supplementaryData))
         val ruleEvent = RuleEvent(
             "test_event", "test_program_stage","",
-            RuleEvent.Status.ACTIVE, Date(), Date(), null, "location1", null, java.util.List.of(
+            RuleEvent.Status.ACTIVE, Date(), Date(), null, "location1", null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_one", "role1")
             )
         )
@@ -366,14 +364,14 @@ class RuleEngineFunctionTest {
         val ruleAction: RuleAction = RuleActionText.createForFeedback(
             "test_action_content", "d2:hasUserRole('role1')"
         )
-        val ruleVariableOne: RuleVariable = RuleVariableCurrentEvent.create(
-            "test_var_one", "test_data_element_one", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariableOne: RuleVariable = RuleVariableCurrentEvent(
+            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.TEXT
         )
-        val rule: Rule = Rule("true", java.util.List.of(ruleAction), "", "")
+        val rule: Rule = Rule("true", listOf(ruleAction), "", "")
         val ruleEngine = RuleEngine(RuleEngineContext(listOf(rule),listOf(ruleVariableOne),supplementaryData))
         val ruleEvent = RuleEvent(
             "test_event", "test_program_stage","",
-            RuleEvent.Status.ACTIVE, Date(), Date(), null, "location1", null, java.util.List.of(
+            RuleEvent.Status.ACTIVE, Date(), Date(), null, "location1", null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_one", "role1")
             )
         )
@@ -388,17 +386,17 @@ class RuleEngineFunctionTest {
         val ruleAction: RuleAction = RuleActionText.createForFeedback(
             "test_action_content", "d2:addDays(#{test_var_one}, #{test_var_two})"
         )
-        val ruleVariableOne: RuleVariable = RuleVariableCurrentEvent.create(
-            "test_var_one", "test_data_element_one", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariableOne: RuleVariable = RuleVariableCurrentEvent(
+            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.TEXT
         )
-        val ruleVariableTwo: RuleVariable = RuleVariableCurrentEvent.create(
-            "test_var_two", "test_data_element_two", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariableTwo: RuleVariable = RuleVariableCurrentEvent(
+            "test_var_two", true, ArrayList(), "test_data_element_two", RuleValueType.TEXT
         )
-        val rule: Rule = Rule("true", java.util.List.of(ruleAction), "", "")
-        val ruleEngine = RuleEngineTestUtils.getRuleEngine(rule, java.util.List.of(ruleVariableOne, ruleVariableTwo))
+        val rule: Rule = Rule("true", listOf(ruleAction), "", "")
+        val ruleEngine = RuleEngineTestUtils.getRuleEngine(rule, listOf(ruleVariableOne, ruleVariableTwo))
         val ruleEvent = RuleEvent(
             "test_event", "test_program_stage","",
-            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, java.util.List.of(
+            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_one", "2017-01-01"),
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_two", "2")
             )
@@ -409,7 +407,7 @@ class RuleEngineFunctionTest {
         assertEquals(ruleEffects[0].data(), "2017-01-03")
         val ruleEvent2 = RuleEvent(
             "test_event", "test_program_stage","",
-            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, java.util.List.of(
+            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_one", "2017-01-03"),
                 RuleDataValue
                     .create(Date(), "test_program_stage", "test_data_element_two", "-2")
@@ -426,26 +424,26 @@ class RuleEngineFunctionTest {
         val ruleAction: RuleAction = RuleActionText.createForFeedback(
             "test_action_content", "d2:countIfValue(#{test_var_one}, 'condition')"
         )
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent.create(
-            "test_var_one", "test_data_element_one", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
+            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.TEXT
         )
-        val rule: Rule = Rule("true", java.util.List.of(ruleAction), "", "")
-        val ruleEngineBuilder = RuleEngineTestUtils.getRuleEngine(rule, java.util.List.of(ruleVariableOne))
+        val rule: Rule = Rule("true", listOf(ruleAction), "", "")
+        val ruleEngineBuilder = RuleEngineTestUtils.getRuleEngine(rule, listOf(ruleVariableOne))
         val ruleEvent = RuleEvent(
             "test_event", "test_program_stage","",
-            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, java.util.List.of(
+            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_one", "condition")
             )
         )
         val ruleEvent2 = RuleEvent(
             "test_event2", "test_program_stage2","",
-            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, java.util.List.of(
+            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_one", "condition2")
             )
         )
         val ruleEvent3 = RuleEvent(
             "test_event3", "test_program_stage3","",
-            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, java.util.List.of(
+            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_one", "condition")
             )
         )
@@ -461,26 +459,26 @@ class RuleEngineFunctionTest {
         val ruleAction: RuleAction = RuleActionText.createForFeedback(
             "test_action_content", "d2:countIfValue('test_var_one', 'condition')"
         )
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent.create(
-            "test_var_one", "test_data_element_one", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
+            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.TEXT
         )
-        val rule: Rule = Rule("true", java.util.List.of(ruleAction), "", "")
-        val ruleEngineBuilder = RuleEngineTestUtils.getRuleEngine(rule, java.util.List.of(ruleVariableOne))
+        val rule: Rule = Rule("true", listOf(ruleAction), "", "")
+        val ruleEngineBuilder = RuleEngineTestUtils.getRuleEngine(rule, listOf(ruleVariableOne))
         val ruleEvent = RuleEvent(
             "test_event", "test_program_stage","",
-            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, java.util.List.of(
+            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_one", "condition")
             )
         )
         val ruleEvent2 = RuleEvent(
             "test_event2", "test_program_stage2","",
-            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, java.util.List.of(
+            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_one", "condition2")
             )
         )
         val ruleEvent3 = RuleEvent(
             "test_event3", "test_program_stage3","",
-            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, java.util.List.of(
+            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_one", "condition")
             )
         )
@@ -495,35 +493,35 @@ class RuleEngineFunctionTest {
         val ruleAction: RuleAction = RuleActionText.createForFeedback(
             "test_action_content", "d2:count(#{test_var_one})"
         )
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent.create(
-            "test_var_one", "test_data_element_one", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
+            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.TEXT
         )
-        val ruleVariableTwo: RuleVariable = RuleVariableNewestEvent.create(
-            "test_var_two", "test_data_element_two", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariableTwo: RuleVariable = RuleVariableNewestEvent(
+            "test_var_two", true, ArrayList(), "test_data_element_two", RuleValueType.TEXT
         )
-        val rule: Rule = Rule("true", java.util.List.of(ruleAction), "", "")
-        val ruleEngineBuilder = RuleEngineTestUtils.getRuleEngine(rule, java.util.List.of(ruleVariableOne))
+        val rule: Rule = Rule("true", listOf(ruleAction), "", "")
+        val ruleEngineBuilder = RuleEngineTestUtils.getRuleEngine(rule, listOf(ruleVariableOne))
         val ruleEvent = RuleEvent(
             "test_event", "test_program_stage","",
-            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, java.util.List.of(
+            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_one", "condition")
             )
         )
         val ruleEvent2 = RuleEvent(
             "test_event2", "test_program_stage2","",
-            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, java.util.List.of(
+            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_one", "condition2")
             )
         )
         val ruleEvent3 = RuleEvent(
             "test_event3", "test_program_stage3","",
-            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, java.util.List.of(
+            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_one", "condition")
             )
         )
         val ruleEvent4 = RuleEvent(
             "test_event3", "test_program_stage3","",
-            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, java.util.List.of(
+            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_two", "condition")
             )
         )
@@ -538,23 +536,23 @@ class RuleEngineFunctionTest {
         val ruleAction: RuleAction = RuleActionText.createForFeedback(
             "test_action_content", "d2:count(#{test_var_one})"
         )
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent.create(
-            "test_var_one", "test_data_element_one", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
+            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.TEXT
         )
         val rule: Rule = Rule(
             "d2:hasValue(V{current_date}) && d2:count(#{test_var_one}) > 0",
-            java.util.List.of(ruleAction), "", ""
+            listOf(ruleAction), "", ""
         )
-        val ruleEngineBuilder = RuleEngineTestUtils.getRuleEngine(rule, java.util.List.of(ruleVariableOne))
+        val ruleEngineBuilder = RuleEngineTestUtils.getRuleEngine(rule, listOf(ruleVariableOne))
         val ruleEvent = RuleEvent(
             "test_event", "test_program_stage","",
-            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, java.util.List.of(
+            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_one", "condition")
             )
         )
         val ruleEvent2 = RuleEvent(
             "test_event2", "test_program_stage2","",
-            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, java.util.List.of(
+            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_one", "condition2")
             )
         )
@@ -569,23 +567,23 @@ class RuleEngineFunctionTest {
         val ruleAction: RuleAction = RuleActionText.createForFeedback(
             "test_action_content", "d2:count(#{test_var_one})"
         )
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent.create(
-            "test_var_one", "test_data_element_one", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
+            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.TEXT
         )
         val rule: Rule = Rule(
             "d2:hasValue(V{current_date}) || d2:count(#{test_var_one}) > 0",
-            java.util.List.of(ruleAction), "", ""
+            listOf(ruleAction), "", ""
         )
-        val ruleEngineBuilder = RuleEngineTestUtils.getRuleEngine(rule, java.util.List.of(ruleVariableOne))
+        val ruleEngineBuilder = RuleEngineTestUtils.getRuleEngine(rule, listOf(ruleVariableOne))
         val ruleEvent = RuleEvent(
             "test_event", "test_program_stage","",
-            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, java.util.List.of(
+            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_one", "condition")
             )
         )
         val ruleEvent2 = RuleEvent(
             "test_event2", "test_program_stage2","",
-            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, java.util.List.of(
+            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_one", "condition2")
             )
         )
@@ -601,35 +599,35 @@ class RuleEngineFunctionTest {
         val ruleAction: RuleAction = RuleActionText.createForFeedback(
             "test_action_content", "d2:count('test_var_one')"
         )
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent.create(
-            "test_var_one", "test_data_element_one", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
+            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.TEXT
         )
-        val ruleVariableTwo: RuleVariable = RuleVariableNewestEvent.create(
-            "test_var_two", "test_data_element_two", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariableTwo: RuleVariable = RuleVariableNewestEvent(
+            "test_var_two", true, ArrayList(), "test_data_element_two", RuleValueType.TEXT
         )
-        val rule: Rule = Rule("true", java.util.List.of(ruleAction), "", "")
-        val ruleEngineBuilder = RuleEngineTestUtils.getRuleEngine(rule, java.util.List.of(ruleVariableOne))
+        val rule: Rule = Rule("true", listOf(ruleAction), "", "")
+        val ruleEngineBuilder = RuleEngineTestUtils.getRuleEngine(rule, listOf(ruleVariableOne))
         val ruleEvent = RuleEvent(
             "test_event", "test_program_stage","",
-            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, java.util.List.of(
+            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_one", "condition")
             )
         )
         val ruleEvent2 = RuleEvent(
             "test_event2", "test_program_stage2","",
-            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, java.util.List.of(
+            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_one", "condition2")
             )
         )
         val ruleEvent3 = RuleEvent(
             "test_event3", "test_program_stage3","",
-            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, java.util.List.of(
+            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_one", "condition")
             )
         )
         val ruleEvent4 = RuleEvent(
             "test_event3", "test_program_stage3","",
-            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, java.util.List.of(
+            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_two", "condition")
             )
         )
@@ -644,14 +642,14 @@ class RuleEngineFunctionTest {
         val ruleAction1: RuleAction = RuleActionText.createForFeedback(
             "test_action_content", "d2:round(#{test_var_one})"
         )
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent.create(
-            "test_var_one", "test_data_element_one", RuleValueType.NUMERIC, true, ArrayList()
+        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
+            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.NUMERIC
         )
-        val rule: Rule = Rule("true", java.util.List.of(ruleAction1), "", "")
-        val ruleEngineBuilder = RuleEngineTestUtils.getRuleEngine(rule, java.util.List.of(ruleVariableOne))
+        val rule: Rule = Rule("true", listOf(ruleAction1), "", "")
+        val ruleEngineBuilder = RuleEngineTestUtils.getRuleEngine(rule, listOf(ruleVariableOne))
         val ruleEvent = RuleEvent(
             "test_event", "test_program_stage","",
-            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, java.util.List.of(
+            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_one", "2.6")
             )
         )
@@ -666,14 +664,14 @@ class RuleEngineFunctionTest {
         val ruleAction: RuleAction = RuleActionText.createForFeedback(
             "test_action_content", "d2:modulus(#{test_var_one}, 2)"
         )
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent.create(
-            "test_var_one", "test_data_element_one", RuleValueType.NUMERIC, true, ArrayList()
+        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
+            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.NUMERIC
         )
-        val rule: Rule = Rule("true", java.util.List.of(ruleAction), "", "")
-        val ruleEngineBuilder = RuleEngineTestUtils.getRuleEngine(rule, java.util.List.of(ruleVariableOne))
+        val rule: Rule = Rule("true", listOf(ruleAction), "", "")
+        val ruleEngineBuilder = RuleEngineTestUtils.getRuleEngine(rule, listOf(ruleVariableOne))
         val ruleEvent = RuleEvent(
             "test_event", "test_program_stage","",
-            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, java.util.List.of(
+            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_one", "2.6")
             )
         )
@@ -688,14 +686,14 @@ class RuleEngineFunctionTest {
         val ruleAction: RuleAction = RuleActionText.createForFeedback(
             "test_action_content", "d2:substring(#{test_var_one}, 1, 3)"
         )
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent.create(
-            "test_var_one", "test_data_element_one", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
+            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.TEXT
         )
-        val rule: Rule = Rule("true", java.util.List.of(ruleAction), "", "")
-        val ruleEngineBuilder = RuleEngineTestUtils.getRuleEngine(rule, java.util.List.of(ruleVariableOne))
+        val rule: Rule = Rule("true", listOf(ruleAction), "", "")
+        val ruleEngineBuilder = RuleEngineTestUtils.getRuleEngine(rule, listOf(ruleVariableOne))
         val ruleEvent = RuleEvent(
             "test_event", "test_program_stage","",
-            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, java.util.List.of(
+            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_one", "ABCD")
             )
         )
@@ -710,20 +708,20 @@ class RuleEngineFunctionTest {
         val ruleAction: RuleAction = RuleActionText.createForFeedback(
             "test_action_content", "d2:weeksBetween(#{test_var_one}, #{test_var_two})"
         )
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent.create(
-            "test_var_one", "test_data_element_one", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
+            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.TEXT
         )
-        val ruleVariableTwo: RuleVariable = RuleVariableNewestEvent.create(
-            "test_var_two", "test_data_element_two", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariableTwo: RuleVariable = RuleVariableNewestEvent(
+            "test_var_two", true, ArrayList(), "test_data_element_two", RuleValueType.TEXT
         )
-        val rule: Rule = Rule("true", java.util.List.of(ruleAction), "", "")
+        val rule: Rule = Rule("true", listOf(ruleAction), "", "")
         val ruleEngineBuilder = RuleEngineTestUtils.getRuleEngine(
             rule,
-            java.util.List.of(ruleVariableOne, ruleVariableTwo)
+            listOf(ruleVariableOne, ruleVariableTwo)
         )
         val ruleEvent = RuleEvent(
             "test_event", "test_program_stage","",
-            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, java.util.List.of(
+            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_one", "2018-01-01"),
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_two", "2018-02-01")
             )
@@ -739,20 +737,20 @@ class RuleEngineFunctionTest {
         val ruleAction: RuleAction = RuleActionText.createForFeedback(
             "test_action_content", "d2:monthsBetween(#{test_var_one}, #{test_var_two})"
         )
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent.create(
-            "test_var_one", "test_data_element_one", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
+            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.TEXT
         )
-        val ruleVariableTwo: RuleVariable = RuleVariableNewestEvent.create(
-            "test_var_two", "test_data_element_two", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariableTwo: RuleVariable = RuleVariableNewestEvent(
+            "test_var_two", true, ArrayList(), "test_data_element_two", RuleValueType.TEXT
         )
-        val rule: Rule = Rule("true", java.util.List.of(ruleAction), "", "")
+        val rule: Rule = Rule("true", listOf(ruleAction), "", "")
         val ruleEngineBuilder = RuleEngineTestUtils.getRuleEngine(
             rule,
-            java.util.List.of(ruleVariableOne, ruleVariableTwo)
+            listOf(ruleVariableOne, ruleVariableTwo)
         )
         val ruleEvent = RuleEvent(
             "test_event", "test_program_stage","",
-            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, java.util.List.of(
+            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_one", "2018-01-01"),
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_two", "2018-09-01")
             )
@@ -768,22 +766,22 @@ class RuleEngineFunctionTest {
         val ruleAction: RuleAction = RuleActionText.createForFeedback(
             "test_action_content", "d2:yearsBetween(#{test_var_one}, #{test_var_two})"
         )
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent.create(
-            "test_var_one", "test_data_element_one", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
+            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.TEXT
         )
-        val ruleVariableTwo: RuleVariable = RuleVariableNewestEvent.create(
-            "test_var_two", "test_data_element_two", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariableTwo: RuleVariable = RuleVariableNewestEvent(
+            "test_var_two", true, ArrayList(), "test_data_element_two", RuleValueType.TEXT
         )
-        val rule: Rule = Rule("d2:yearsBetween('2016-01-01', '2018-09-01') == 2", java.util.List.of(ruleAction), "",
+        val rule: Rule = Rule("d2:yearsBetween('2016-01-01', '2018-09-01') == 2", listOf(ruleAction), "",
                 ""
             )
         val ruleEngineBuilder = RuleEngineTestUtils.getRuleEngine(
             rule,
-            java.util.List.of(ruleVariableOne, ruleVariableTwo)
+            listOf(ruleVariableOne, ruleVariableTwo)
         )
         val ruleEvent = RuleEvent(
             "test_event", "test_program_stage","",
-            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, java.util.List.of(
+            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_one", "2016-01-01"),
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_two", "2018-09-01")
             )
@@ -799,19 +797,19 @@ class RuleEngineFunctionTest {
         val ruleAction: RuleAction = RuleActionText.createForFeedback(
             "test_action_content", "d2:zpvc( '1', '0', '-1' )"
         )
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent.create(
-            "test_var_one", "test_data_element_one", RuleValueType.NUMERIC, true, ArrayList()
+        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
+            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.NUMERIC
         )
-        val ruleVariableTwo: RuleVariable = RuleVariableNewestEvent.create(
-            "test_var_two", "test_data_element_two", RuleValueType.NUMERIC, true, ArrayList()
+        val ruleVariableTwo: RuleVariable = RuleVariableNewestEvent(
+            "test_var_two", true, ArrayList(), "test_data_element_two", RuleValueType.NUMERIC
         )
-        val ruleVariableThree: RuleVariable = RuleVariableNewestEvent.create(
-            "test_var_three", "test_data_element_two", RuleValueType.NUMERIC, true, ArrayList()
+        val ruleVariableThree: RuleVariable = RuleVariableNewestEvent(
+            "test_var_three", true, ArrayList(), "test_data_element_two", RuleValueType.NUMERIC
         )
         val rule: Rule = Rule("true", listOf(ruleAction), "", "")
         val ruleEngineBuilder = RuleEngineTestUtils.getRuleEngine(
             rule,
-            java.util.List.of(ruleVariableOne, ruleVariableTwo)
+            listOf(ruleVariableOne, ruleVariableTwo)
         )
         val ruleEvent = RuleEvent(
             "test_event", "test_program_stage","",
@@ -861,26 +859,26 @@ class RuleEngineFunctionTest {
         val ruleAction: RuleAction = RuleActionText.createForFeedback(
             "test_action_content", "d2:countIfZeroPos(#{test_var_one})"
         )
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent.create(
-            "test_var_one", "test_data_element_one", RuleValueType.NUMERIC, true, ArrayList()
+        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
+            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.NUMERIC
         )
         val rule: Rule = Rule("true", listOf(ruleAction), "", "")
-        val ruleEngineBuilder = RuleEngineTestUtils.getRuleEngine(rule, java.util.List.of(ruleVariableOne))
+        val ruleEngineBuilder = RuleEngineTestUtils.getRuleEngine(rule, listOf(ruleVariableOne))
         val ruleEvent = RuleEvent(
             "test_event", "test_program_stage","",
-            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, java.util.List.of(
+            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_one", "0")
             )
         )
         val ruleEvent1 = RuleEvent(
             "test_event1", "test_program_stage","",
-            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, java.util.List.of(
+            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_one", "1")
             )
         )
         val ruleEvent2 = RuleEvent(
             "test_event1", "test_program_stage","",
-            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, java.util.List.of(
+            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_one", "-3")
             )
         )
@@ -897,26 +895,26 @@ class RuleEngineFunctionTest {
         val ruleAction: RuleAction = RuleActionText.createForFeedback(
             "test_action_content", "d2:countIfZeroPos('test_var_one')"
         )
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent.create(
-            "test_var_one", "test_data_element_one", RuleValueType.NUMERIC, true, ArrayList()
+        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
+            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.NUMERIC
         )
         val rule: Rule = Rule("true", listOf(ruleAction), "", "")
-        val ruleEngineBuilder = RuleEngineTestUtils.getRuleEngine(rule, java.util.List.of(ruleVariableOne))
+        val ruleEngineBuilder = RuleEngineTestUtils.getRuleEngine(rule, listOf(ruleVariableOne))
         val ruleEvent = RuleEvent(
             "test_event", "test_program_stage","",
-            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, java.util.List.of(
+            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_one", "0")
             )
         )
         val ruleEvent1 = RuleEvent(
             "test_event1", "test_program_stage","",
-            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, java.util.List.of(
+            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_one", "1")
             )
         )
         val ruleEvent2 = RuleEvent(
             "test_event1", "test_program_stage","",
-            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, java.util.List.of(
+            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_one", "-3")
             )
         )
@@ -932,14 +930,14 @@ class RuleEngineFunctionTest {
         val ruleAction: RuleAction = RuleActionText.createForFeedback(
             "test_action_content", "d2:left(#{test_var_one}, 4)"
         )
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent.create(
-            "test_var_one", "test_data_element_one", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
+            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.TEXT
         )
         val rule: Rule = Rule("true", listOf(ruleAction), "", "")
-        val ruleEngineBuilder = RuleEngineTestUtils.getRuleEngine(rule, java.util.List.of(ruleVariableOne))
+        val ruleEngineBuilder = RuleEngineTestUtils.getRuleEngine(rule, listOf(ruleVariableOne))
         val ruleEvent = RuleEvent(
             "test_event", "test_program_stage","",
-            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, java.util.List.of(
+            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_one", "yyyy-mm-dd")
             )
         )
@@ -954,14 +952,14 @@ class RuleEngineFunctionTest {
         val ruleAction: RuleAction = RuleActionText.createForFeedback(
             "test_action_content", "d2:right(#{test_var_one}, 2)"
         )
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent.create(
-            "test_var_one", "test_data_element_one", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
+            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.TEXT
         )
         val rule: Rule = Rule("true", listOf(ruleAction), "", "")
-        val ruleEngineBuilder = RuleEngineTestUtils.getRuleEngine(rule, java.util.List.of(ruleVariableOne))
+        val ruleEngineBuilder = RuleEngineTestUtils.getRuleEngine(rule, listOf(ruleVariableOne))
         val ruleEvent = RuleEvent(
             "test_event", "test_program_stage","",
-            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, java.util.List.of(
+            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_one", "yyyy-mm-dd")
             )
         )
@@ -976,14 +974,14 @@ class RuleEngineFunctionTest {
         val ruleAction: RuleAction = RuleActionText.createForFeedback(
             "test_action_content", "d2:concatenate(#{test_var_one}, '+days')"
         )
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent.create(
-            "test_var_one", "test_data_element_one", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
+            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.TEXT
         )
         val rule: Rule = Rule("true", listOf(ruleAction), "", "")
-        val ruleEngineBuilder = RuleEngineTestUtils.getRuleEngine(rule, java.util.List.of(ruleVariableOne))
+        val ruleEngineBuilder = RuleEngineTestUtils.getRuleEngine(rule, listOf(ruleVariableOne))
         val ruleEvent = RuleEvent(
             "test_event", "test_program_stage","",
-            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, java.util.List.of(
+            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_one", "weeks")
             )
         )
@@ -998,14 +996,14 @@ class RuleEngineFunctionTest {
         val ruleAction: RuleAction = RuleActionText.createForFeedback(
             "test_action_content", "d2:validatePattern(#{test_var_one}, '.*555.*')"
         )
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent.create(
-            "test_var_one", "test_data_element_one", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
+            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.TEXT
         )
         val rule: Rule = Rule("true", listOf(ruleAction), "", "")
-        val ruleEngineBuilder = RuleEngineTestUtils.getRuleEngine(rule, java.util.List.of(ruleVariableOne))
+        val ruleEngineBuilder = RuleEngineTestUtils.getRuleEngine(rule, listOf(ruleVariableOne))
         val ruleEvent = RuleEvent(
             "test_event", "test_program_stage","",
-            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, java.util.List.of(
+            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_one", "44455545454")
             )
         )
@@ -1015,7 +1013,7 @@ class RuleEngineFunctionTest {
         assertEquals("true", ruleEffects[0].data())
         val ruleEvent2 = RuleEvent(
             "test_event", "test_program_stage","",
-            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, java.util.List.of(
+            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_one", "444887777")
             )
         )
@@ -1030,14 +1028,14 @@ class RuleEngineFunctionTest {
         val ruleAction: RuleAction = RuleActionText.createForFeedback(
             "test_action_content", "d2:length(#{test_var_one})"
         )
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent.create(
-            "test_var_one", "test_data_element_one", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
+            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.TEXT
         )
-        val rule: Rule = Rule("true", java.util.List.of(ruleAction), "", "")
-        val ruleEngineBuilder = RuleEngineTestUtils.getRuleEngine(rule, java.util.List.of(ruleVariableOne))
+        val rule: Rule = Rule("true", listOf(ruleAction), "", "")
+        val ruleEngineBuilder = RuleEngineTestUtils.getRuleEngine(rule, listOf(ruleVariableOne))
         val ruleEvent = RuleEvent(
             "test_event", "test_program_stage","",
-            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, java.util.List.of(
+            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_one", "testString")
             )
         )
@@ -1052,14 +1050,14 @@ class RuleEngineFunctionTest {
         val ruleAction: RuleAction = RuleActionText.createForFeedback(
             "test_action_content", "d2:split(#{test_var_one},'-',2)"
         )
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent.create(
-            "test_var_one", "test_data_element_one", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
+            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.TEXT
         )
-        val rule: Rule = Rule("true", java.util.List.of(ruleAction), "", "")
-        val ruleEngineBuilder = RuleEngineTestUtils.getRuleEngine(rule, java.util.List.of(ruleVariableOne))
+        val rule: Rule = Rule("true", listOf(ruleAction), "", "")
+        val ruleEngineBuilder = RuleEngineTestUtils.getRuleEngine(rule, listOf(ruleVariableOne))
         val ruleEvent = RuleEvent(
             "test_event", "test_program_stage","",
-            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, java.util.List.of(
+            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, listOf(
                 RuleDataValue
                     .create(Date(), "test_program_stage", "test_data_element_one", "test-String-for-split")
             )
@@ -1076,23 +1074,23 @@ class RuleEngineFunctionTest {
             "test_action_content", "d2:floor(#{test_var_one} + d2:ceil(#{test_var_three})) " +
                     "/ 5 * d2:ceil(#{test_var_two})"
         )
-        val ruleVariableOne: RuleVariable = RuleVariableCurrentEvent.create(
-            "test_var_one", "test_data_element_one", RuleValueType.NUMERIC, true, ArrayList()
+        val ruleVariableOne: RuleVariable = RuleVariableCurrentEvent(
+            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.NUMERIC
         )
-        val ruleVariableTwo: RuleVariable = RuleVariableCurrentEvent.create(
-            "test_var_two", "test_data_element_two", RuleValueType.NUMERIC, true, ArrayList()
+        val ruleVariableTwo: RuleVariable = RuleVariableCurrentEvent(
+            "test_var_two", true, ArrayList(), "test_data_element_two", RuleValueType.NUMERIC
         )
-        val ruleVariableThree: RuleVariable = RuleVariableCurrentEvent.create(
-            "test_var_three", "test_data_element_three", RuleValueType.NUMERIC, true, ArrayList()
+        val ruleVariableThree: RuleVariable = RuleVariableCurrentEvent(
+            "test_var_three", true, ArrayList(), "test_data_element_three", RuleValueType.NUMERIC
         )
-        val rule: Rule = Rule("true", java.util.List.of(ruleAction), "", "")
+        val rule: Rule = Rule("true", listOf(ruleAction), "", "")
         val ruleEngine = RuleEngineTestUtils.getRuleEngine(
             rule,
-            java.util.List.of(ruleVariableOne, ruleVariableTwo, ruleVariableThree)
+            listOf(ruleVariableOne, ruleVariableTwo, ruleVariableThree)
         )
         val ruleEvent = RuleEvent(
             "test_event", "test_program_stage","",
-            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, java.util.List.of(
+            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_one", "19.9"),
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_two", "0.9"),
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_three", "10.6")
@@ -1109,22 +1107,22 @@ class RuleEngineFunctionTest {
         val ruleAction: RuleAction = RuleActionText.createForFeedback(
             "test_action_content", "true"
         )
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent.create(
-            "test_var_one", "test_data_element_one", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
+            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.TEXT
         )
-        val ruleVariableTwo: RuleVariable = RuleVariableNewestEvent.create(
-            "test_var_two", "test_data_element_two", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariableTwo: RuleVariable = RuleVariableNewestEvent(
+            "test_var_two", true, ArrayList(), "test_data_element_two", RuleValueType.TEXT
         )
-        val rule: Rule = Rule("d2:zScoreWFA(1,#{test_var_one},#{test_var_two}) == 0", java.util.List.of(ruleAction),
+        val rule: Rule = Rule("d2:zScoreWFA(1,#{test_var_one},#{test_var_two}) == 0", listOf(ruleAction),
                 "", ""
             )
         val ruleEngineBuilder = RuleEngineTestUtils.getRuleEngine(
             rule,
-            java.util.List.of(ruleVariableOne, ruleVariableTwo)
+            listOf(ruleVariableOne, ruleVariableTwo)
         )
         val ruleEvent = RuleEvent(
             "test_event", "test_program_stage","",
-            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, java.util.List.of(
+            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_one", "4.5"),
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_two", "male")
             )
@@ -1139,22 +1137,22 @@ class RuleEngineFunctionTest {
         val ruleAction: RuleAction = RuleActionText.createForFeedback(
             "test_action_content", "true"
         )
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent.create(
-            "test_var_one", "test_data_element_one", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
+            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.TEXT
         )
-        val ruleVariableTwo: RuleVariable = RuleVariableNewestEvent.create(
-            "test_var_two", "test_data_element_two", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariableTwo: RuleVariable = RuleVariableNewestEvent(
+            "test_var_two", true, ArrayList(), "test_data_element_two", RuleValueType.TEXT
         )
-        val rule: Rule = Rule("d2:zScoreHFA(12,#{test_var_one},#{test_var_two}) == -3", java.util.List.of(ruleAction),
+        val rule: Rule = Rule("d2:zScoreHFA(12,#{test_var_one},#{test_var_two}) == -3", listOf(ruleAction),
                 "", ""
             )
         val ruleEngineBuilder = RuleEngineTestUtils.getRuleEngine(
             rule,
-            java.util.List.of(ruleVariableOne, ruleVariableTwo)
+            listOf(ruleVariableOne, ruleVariableTwo)
         )
         val ruleEvent = RuleEvent(
             "test_event", "test_program_stage","",
-            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, java.util.List.of(
+            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_one", "66.3"),
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_two", "1")
             )
@@ -1169,22 +1167,22 @@ class RuleEngineFunctionTest {
         val ruleAction: RuleAction = RuleActionText.createForFeedback(
             "test_action_content", "true"
         )
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent.create(
-            "test_var_one", "test_data_element_one", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
+            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.TEXT
         )
-        val ruleVariableTwo: RuleVariable = RuleVariableNewestEvent.create(
-            "test_var_two", "test_data_element_two", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariableTwo: RuleVariable = RuleVariableNewestEvent(
+            "test_var_two", true, ArrayList(), "test_data_element_two", RuleValueType.TEXT
         )
-        val rule: Rule = Rule("d2:zScoreHFA(10,#{test_var_one},#{test_var_two}) == -2", java.util.List.of(ruleAction),
+        val rule: Rule = Rule("d2:zScoreHFA(10,#{test_var_one},#{test_var_two}) == -2", listOf(ruleAction),
                 "", ""
             )
         val ruleEngineBuilder = RuleEngineTestUtils.getRuleEngine(
             rule,
-            java.util.List.of(ruleVariableOne, ruleVariableTwo)
+            listOf(ruleVariableOne, ruleVariableTwo)
         )
         val ruleEvent = RuleEvent(
             "test_event", "test_program_stage","",
-            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, java.util.List.of(
+            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_one", "68.7"),
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_two", "male")
             )
@@ -1199,22 +1197,22 @@ class RuleEngineFunctionTest {
         val ruleAction: RuleAction = RuleActionText.createForFeedback(
             "test_action_content", "true"
         )
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent.create(
-            "test_var_one", "test_data_element_one", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
+            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.TEXT
         )
-        val ruleVariableTwo: RuleVariable = RuleVariableNewestEvent.create(
-            "test_var_two", "test_data_element_two", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariableTwo: RuleVariable = RuleVariableNewestEvent(
+            "test_var_two", true, ArrayList(), "test_data_element_two", RuleValueType.TEXT
         )
-        val rule: Rule = Rule("d2:zScoreWFH(52,#{test_var_one},A{test_var_two}) < 2", java.util.List.of(ruleAction),
+        val rule: Rule = Rule("d2:zScoreWFH(52,#{test_var_one},A{test_var_two}) < 2", listOf(ruleAction),
                 "", ""
             )
         val ruleEngineBuilder = RuleEngineTestUtils.getRuleEngine(
             rule,
-            java.util.List.of(ruleVariableOne, ruleVariableTwo)
+            listOf(ruleVariableOne, ruleVariableTwo)
         )
         val ruleEvent = RuleEvent(
             "test_event", "test_program_stage","",
-            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, java.util.List.of(
+            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_one", "3"),
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_two", "male")
             )
@@ -1229,22 +1227,22 @@ class RuleEngineFunctionTest {
         val ruleAction: RuleAction = RuleActionText.createForFeedback(
             "test_action_content", "d2:zScoreWFH(81.5,9.6,'female') == 2"
         )
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent.create(
-            "test_var_one", "test_data_element_one", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
+            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.TEXT
         )
-        val ruleVariableTwo: RuleVariable = RuleVariableNewestEvent.create(
-            "test_var_two", "test_data_element_two", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariableTwo: RuleVariable = RuleVariableNewestEvent(
+            "test_var_two", true, ArrayList(), "test_data_element_two", RuleValueType.TEXT
         )
-        val rule: Rule = Rule("d2:zScoreWFH(81.5,#{test_var_one},#{test_var_two}) == 2", java.util.List.of(ruleAction),
+        val rule: Rule = Rule("d2:zScoreWFH(81.5,#{test_var_one},#{test_var_two}) == 2", listOf(ruleAction),
                 "", ""
             )
         val ruleEngineBuilder = RuleEngineTestUtils.getRuleEngine(
             rule,
-            java.util.List.of(ruleVariableOne, ruleVariableTwo)
+            listOf(ruleVariableOne, ruleVariableTwo)
         )
         val ruleEvent = RuleEvent(
             "test_event", "test_program_stage","",
-            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, java.util.List.of(
+            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_one", "12.5"),
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_two", "1")
             )
@@ -1259,34 +1257,34 @@ class RuleEngineFunctionTest {
         val ruleAction: RuleAction = RuleActionText.createForFeedback(
             "test_action_content", "true"
         )
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent.create(
-            "test_var_one", "test_data_element_one", RuleValueType.NUMERIC, true, ArrayList()
+        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
+            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.NUMERIC
         )
-        val ruleVariableTwo: RuleVariable = RuleVariableNewestEvent.create(
-            "test_var_two", "test_data_element_two", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariableTwo: RuleVariable = RuleVariableNewestEvent(
+            "test_var_two", true, ArrayList(), "test_data_element_two", RuleValueType.TEXT
         )
-        val rule: Rule = Rule("d2:maxValue(#{test_var_one}) == 8.0", java.util.List.of(ruleAction), "", "")
+        val rule: Rule = Rule("d2:maxValue(#{test_var_one}) == 8.0", listOf(ruleAction), "", "")
         val ruleEngineBuilder = RuleEngineTestUtils.getRuleEngine(
             rule,
-            java.util.List.of(ruleVariableOne, ruleVariableTwo)
+            listOf(ruleVariableOne, ruleVariableTwo)
         )
         val ruleEvent1 = RuleEvent(
             "test_event1", "test_program_stage1","",
-            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, java.util.List.of(
+            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_one", "5"),
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_two", "male")
             )
         )
         val ruleEvent2 = RuleEvent(
             "test_event2", "test_program_stage2","",
-            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, java.util.List.of(
+            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_one", "7"),
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_two", "male")
             )
         )
         val ruleEvent3 = RuleEvent(
             "test_event3", "test_program_stage3","",
-            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, java.util.List.of(
+            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_one", "8"),
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_two", "male")
             )
@@ -1303,34 +1301,34 @@ class RuleEngineFunctionTest {
         val ruleAction: RuleAction = RuleActionText.createForFeedback(
             "test_action_content", "true"
         )
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent.create(
-            "test_var_one", "test_data_element_one", RuleValueType.NUMERIC, true, ArrayList()
+        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
+            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.NUMERIC
         )
-        val ruleVariableTwo: RuleVariable = RuleVariableNewestEvent.create(
-            "test_var_two", "test_data_element_two", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariableTwo: RuleVariable = RuleVariableNewestEvent(
+            "test_var_two", true, ArrayList(), "test_data_element_two", RuleValueType.TEXT
         )
-        val rule: Rule = Rule("d2:maxValue('test_var_one') == 8.0", java.util.List.of(ruleAction), "", "")
+        val rule: Rule = Rule("d2:maxValue('test_var_one') == 8.0", listOf(ruleAction), "", "")
         val ruleEngineBuilder = RuleEngineTestUtils.getRuleEngine(
             rule,
-            java.util.List.of(ruleVariableOne, ruleVariableTwo)
+            listOf(ruleVariableOne, ruleVariableTwo)
         )
         val ruleEvent1 = RuleEvent(
             "test_event1", "test_program_stage1","",
-            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, java.util.List.of(
+            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_one", "5"),
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_two", "male")
             )
         )
         val ruleEvent2 = RuleEvent(
             "test_event2", "test_program_stage2","",
-            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, java.util.List.of(
+            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_one", "7"),
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_two", "male")
             )
         )
         val ruleEvent3 = RuleEvent(
             "test_event3", "test_program_stage3","",
-            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, java.util.List.of(
+            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_one", "8"),
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_two", "male")
             )
@@ -1346,34 +1344,34 @@ class RuleEngineFunctionTest {
         val ruleAction: RuleAction = RuleActionText.createForFeedback(
             "test_action_content", "d2:minValue(#{test_var_one})"
         )
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent.create(
-            "test_var_one", "test_data_element_one", RuleValueType.NUMERIC, true, ArrayList()
+        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
+            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.NUMERIC
         )
-        val ruleVariableTwo: RuleVariable = RuleVariableNewestEvent.create(
-            "test_var_two", "test_data_element_two", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariableTwo: RuleVariable = RuleVariableNewestEvent(
+            "test_var_two", true, ArrayList(), "test_data_element_two", RuleValueType.TEXT
         )
-        val rule: Rule = Rule("true", java.util.List.of(ruleAction), "", "")
+        val rule: Rule = Rule("true", listOf(ruleAction), "", "")
         val ruleEngineBuilder = RuleEngineTestUtils.getRuleEngine(
             rule,
-            java.util.List.of(ruleVariableOne, ruleVariableTwo)
+            listOf(ruleVariableOne, ruleVariableTwo)
         )
         val ruleEvent1 = RuleEvent(
             "test_event1", "test_program_stage1","",
-            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, java.util.List.of(
+            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_one", "5"),
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_two", "male")
             )
         )
         val ruleEvent2 = RuleEvent(
             "test_event2", "test_program_stage2","",
-            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, java.util.List.of(
+            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_one", "7"),
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_two", "male")
             )
         )
         val ruleEvent3 = RuleEvent(
             "test_event3", "test_program_stage3","",
-            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, java.util.List.of(
+            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_one", "8"),
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_two", "male")
             )
@@ -1390,34 +1388,34 @@ class RuleEngineFunctionTest {
         val ruleAction: RuleAction = RuleActionText.createForFeedback(
             "test_action_content", "d2:minValue('test_var_one')"
         )
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent.create(
-            "test_var_one", "test_data_element_one", RuleValueType.NUMERIC, true, ArrayList()
+        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
+            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.NUMERIC
         )
-        val ruleVariableTwo: RuleVariable = RuleVariableNewestEvent.create(
-            "test_var_two", "test_data_element_two", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariableTwo: RuleVariable = RuleVariableNewestEvent(
+            "test_var_two", true, ArrayList(), "test_data_element_two", RuleValueType.TEXT
         )
-        val rule: Rule = Rule("true", java.util.List.of(ruleAction), "", "")
+        val rule: Rule = Rule("true", listOf(ruleAction), "", "")
         val ruleEngineBuilder = RuleEngineTestUtils.getRuleEngine(
             rule,
-            java.util.List.of(ruleVariableOne, ruleVariableTwo)
+            listOf(ruleVariableOne, ruleVariableTwo)
         )
         val ruleEvent1 = RuleEvent(
             "test_event1", "test_program_stage1","",
-            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, java.util.List.of(
+            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_one", "5"),
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_two", "male")
             )
         )
         val ruleEvent2 = RuleEvent(
             "test_event2", "test_program_stage2","",
-            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, java.util.List.of(
+            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_one", "7"),
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_two", "male")
             )
         )
         val ruleEvent3 = RuleEvent(
             "test_event3", "test_program_stage3","",
-            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, java.util.List.of(
+            RuleEvent.Status.ACTIVE, Date(), Date (), null, "", null, listOf(
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_one", "8"),
                 RuleDataValue.create(Date(), "test_program_stage", "test_data_element_two", "male")
             )
@@ -1441,26 +1439,26 @@ class RuleEngineFunctionTest {
         val ruleAction: RuleAction = RuleActionText.createForFeedback(
             "test_action_content", "d2:lastEventDate('test_var_one')"
         )
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent.create(
-            "test_var_one", "test_data_element_one", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
+            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.TEXT
         )
         val rule: Rule = Rule("true", listOf(ruleAction), "test_rule", "")
-        val ruleEngineBuilder = RuleEngineTestUtils.getRuleEngine(rule, java.util.List.of(ruleVariableOne))
+        val ruleEngineBuilder = RuleEngineTestUtils.getRuleEngine(rule, listOf(ruleVariableOne))
         val ruleEvent1 = RuleEvent(
             "test_event1", "test_program_stage1","",RuleEvent.Status.ACTIVE, dayBeforeYesterday, Date(), 
-            null, "", null, java.util.List.of(
+            null, "", null, listOf(
                 RuleDataValue.create(dayBeforeYesterday, "test_program_stage1", "test_data_element_one", "value1")
             )
         )
         val ruleEvent2 = RuleEvent(
             "test_event2", "test_program_stage2","",
-            RuleEvent.Status.ACTIVE, yesterday, Date (), null, "", null, java.util.List.of(
+            RuleEvent.Status.ACTIVE, yesterday, Date (), null, "", null, listOf(
                 RuleDataValue.create(yesterday, "test_program_stage2", "test_data_element_one", "value2")
             )
         )
         val ruleEvent3 = RuleEvent(
             "test_event3", "test_program_stage3","",
-            RuleEvent.Status.ACTIVE, dayAfterTomorrow, dayAfterTomorrow, null, "", null, java.util.List.of(
+            RuleEvent.Status.ACTIVE, dayAfterTomorrow, dayAfterTomorrow, null, "", null, listOf(
                 RuleDataValue.create(dayAfterTomorrow, "test_program_stage3", "test_data_element_one", "value3")
             )
         )
diff --git a/src/test/java/org/hisp/dhis/rules/RuleEngineTest.kt b/src/test/java/org/hisp/dhis/rules/RuleEngineTest.kt
index 5416bf41..fca6c071 100644
--- a/src/test/java/org/hisp/dhis/rules/RuleEngineTest.kt
+++ b/src/test/java/org/hisp/dhis/rules/RuleEngineTest.kt
@@ -3,11 +3,9 @@ package org.hisp.dhis.rules
 import io.mockk.mockk
 import org.hisp.dhis.rules.models.Rule
 import org.hisp.dhis.rules.models.RuleEvent
-import org.hisp.dhis.rules.util.MockRuleVariable
+import org.hisp.dhis.rules.models.RuleVariable
 import kotlin.test.Test
-import kotlin.test.assertEquals
 import java.util.*
-import java.util.List
 import java.util.concurrent.CountDownLatch
 import java.util.concurrent.TimeUnit
 import kotlin.collections.ArrayList
@@ -17,7 +15,7 @@ import kotlin.test.assertTrue
 internal class RuleEngineTest {
 
     private val ruleEngineContext: RuleEngineContext = RuleEngineContext(
-        listOf(Rule("true", listOf())),listOf(MockRuleVariable()))
+        listOf(Rule("true", listOf())),listOf(mockk<RuleVariable>()))
 
     @Test(expected = IllegalStateException::class)
     fun evaluateShouldThrowIfEventIsAlreadyInContext() {
diff --git a/src/test/java/org/hisp/dhis/rules/RuleEngineValueTypesTest.kt b/src/test/java/org/hisp/dhis/rules/RuleEngineValueTypesTest.kt
index 4d389249..b8b64c44 100644
--- a/src/test/java/org/hisp/dhis/rules/RuleEngineValueTypesTest.kt
+++ b/src/test/java/org/hisp/dhis/rules/RuleEngineValueTypesTest.kt
@@ -11,8 +11,7 @@ class RuleEngineValueTypesTest {
         val ruleAction: RuleAction = RuleActionText
             .createForFeedback("test_action_content", "#{test_variable}")
         val rule: Rule = Rule("true", java.util.List.of(ruleAction), "", "")
-        val ruleVariable: RuleVariable = RuleVariableCurrentEvent
-            .create("test_variable", "test_data_element", RuleValueType.BOOLEAN, true, ArrayList())
+        val ruleVariable: RuleVariable = RuleVariableCurrentEvent("test_variable", true, ArrayList(), "test_data_element", RuleValueType.BOOLEAN)
         val ruleEngine = getRuleEngine(rule, java.util.List.of(ruleVariable))
         val ruleEvent = RuleEvent(
             "test_event", "test_program_stage", "",
@@ -29,8 +28,7 @@ class RuleEngineValueTypesTest {
         val ruleAction: RuleAction = RuleActionText
             .createForFeedback("test_action_content", "#{test_variable}")
         val rule: Rule = Rule("true", java.util.List.of(ruleAction), "", "")
-        val ruleVariable: RuleVariable = RuleVariableCurrentEvent
-            .create("test_variable", "test_data_element", RuleValueType.NUMERIC, true, ArrayList())
+        val ruleVariable: RuleVariable = RuleVariableCurrentEvent("test_variable", true, ArrayList(), "test_data_element", RuleValueType.NUMERIC)
         val ruleEngine = getRuleEngine(rule, java.util.List.of(ruleVariable))
         val ruleEvent = RuleEvent(
             "test_event", "test_program_stage", "",
@@ -47,8 +45,7 @@ class RuleEngineValueTypesTest {
         val ruleAction: RuleAction = RuleActionText
             .createForFeedback("test_action_content", "#{test_variable}")
         val rule: Rule = Rule("true", java.util.List.of(ruleAction), "", "")
-        val ruleVariable: RuleVariable = RuleVariableCurrentEvent
-            .create("test_variable", "test_data_element", RuleValueType.TEXT, true, ArrayList())
+        val ruleVariable: RuleVariable = RuleVariableCurrentEvent("test_variable", true, ArrayList(), "test_data_element", RuleValueType.TEXT)
         val ruleEngine = getRuleEngine(rule, java.util.List.of(ruleVariable))
         val ruleEvent = RuleEvent(
             "test_event", "test_program_stage","",
diff --git a/src/test/java/org/hisp/dhis/rules/RuleEngineVariableNameTest.kt b/src/test/java/org/hisp/dhis/rules/RuleEngineVariableNameTest.kt
index f936dd4d..32e1772f 100644
--- a/src/test/java/org/hisp/dhis/rules/RuleEngineVariableNameTest.kt
+++ b/src/test/java/org/hisp/dhis/rules/RuleEngineVariableNameTest.kt
@@ -39,26 +39,26 @@ class RuleEngineVariableNameTest {
         val ruleAction10: RuleAction = RuleActionText.createForFeedback(
             "test_action_content", "d2:round(A{" + VARIABLE_NAME + "})"
         )
-        val ruleVariable1: RuleVariable = RuleVariableNewestEvent.create(
-            UID01, "test_data_element1", RuleValueType.NUMERIC, true, ArrayList()
+        val ruleVariable1: RuleVariable = RuleVariableNewestEvent(
+            UID01, true, ArrayList(), "test_data_element1", RuleValueType.NUMERIC
         )
-        val ruleVariable2: RuleVariable = RuleVariableNewestEvent.create(
-            VARIABLE_NAME, "test_data_element2", RuleValueType.NUMERIC, true, ArrayList()
+        val ruleVariable2: RuleVariable = RuleVariableNewestEvent(
+            VARIABLE_NAME, true, ArrayList(), "test_data_element2", RuleValueType.NUMERIC
         )
-        val ruleVariable3: RuleVariable = RuleVariableNewestEvent.create(
-            UID0, "test_data_element3", RuleValueType.NUMERIC, true, ArrayList()
+        val ruleVariable3: RuleVariable = RuleVariableNewestEvent(
+            UID0, true, ArrayList(), "test_data_element3", RuleValueType.NUMERIC
         )
-        val ruleVariable4: RuleVariable = RuleVariableNewestEvent.create(
-            UID0WILD, "test_data_element4", RuleValueType.NUMERIC, true, ArrayList()
+        val ruleVariable4: RuleVariable = RuleVariableNewestEvent(
+            UID0WILD, true, ArrayList(), "test_data_element4", RuleValueType.NUMERIC
         )
-        val ruleVariable5: RuleVariable = RuleVariableNewestEvent.create(
-            UID01WILD, "test_data_element5", RuleValueType.NUMERIC, true, ArrayList()
+        val ruleVariable5: RuleVariable = RuleVariableNewestEvent(
+            UID01WILD, true, ArrayList(), "test_data_element5", RuleValueType.NUMERIC
         )
-        val ruleVariable6: RuleVariable = RuleVariableNewestEvent.create(
-            UID012, "test_data_element6", RuleValueType.NUMERIC, true, ArrayList()
+        val ruleVariable6: RuleVariable = RuleVariableNewestEvent(
+            UID012, true, ArrayList(), "test_data_element6", RuleValueType.NUMERIC
         )
-        val ruleVariable7: RuleVariable = RuleVariableNewestEvent.create(
-            UID0WILD2, "test_data_element7", RuleValueType.NUMERIC, true, ArrayList()
+        val ruleVariable7: RuleVariable = RuleVariableNewestEvent(
+            UID0WILD2, true, ArrayList(), "test_data_element7", RuleValueType.NUMERIC
         )
         val actions = of(
             ruleAction1, ruleAction2, ruleAction3, ruleAction4, ruleAction5, ruleAction6, ruleAction7,
@@ -120,8 +120,8 @@ class RuleEngineVariableNameTest {
         val ruleAction: RuleAction = RuleActionText.createForFeedback(
             "test_action_content", "d2:hasValue(#{" + UID01 + "})"
         )
-        val ruleVariable: RuleVariable = RuleVariableCurrentEvent.create(
-            UID01, "test_data_element", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariable: RuleVariable = RuleVariableCurrentEvent(
+            UID01, true, ArrayList(), "test_data_element", RuleValueType.TEXT
         )
         val rule: Rule = Rule("true", of(ruleAction), "", "")
         val ruleEngine = getRuleEngine(rule, of(ruleVariable))
@@ -144,8 +144,8 @@ class RuleEngineVariableNameTest {
         val ruleAction: RuleAction = RuleActionText.createForFeedback(
             "test_action_content", "d2:hasValue(#{" + VARIABLE_NAME + "})"
         )
-        val ruleVariable: RuleVariable = RuleVariableCurrentEvent.create(
-            VARIABLE_NAME, "test_data_element", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariable: RuleVariable = RuleVariableCurrentEvent(
+            VARIABLE_NAME, true, ArrayList(), "test_data_element", RuleValueType.TEXT
         )
         val rule: Rule = Rule("true", of(ruleAction), "", "")
         val ruleEngine = getRuleEngine(rule, of(ruleVariable))
@@ -168,8 +168,8 @@ class RuleEngineVariableNameTest {
         val ruleAction: RuleAction = RuleActionText.createForFeedback(
             "test_action_content", "d2:countIfValue(#{" + VARIABLE_NAME + "}, 'condition')"
         )
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent.create(
-            VARIABLE_NAME, "test_data_element_one", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
+            VARIABLE_NAME, true, ArrayList(), "test_data_element_one", RuleValueType.TEXT
         )
         val rule: Rule = Rule("true", of(ruleAction), "", "")
         val ruleEngine = getRuleEngine(rule, of(ruleVariableOne))
@@ -202,8 +202,8 @@ class RuleEngineVariableNameTest {
         val ruleAction: RuleAction = RuleActionText.createForFeedback(
             "test_action_content", "d2:countIfValue(#{" + UID01 + "}, 'condition')"
         )
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent.create(
-            UID01, "test_data_element_one", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
+            UID01, true, ArrayList(), "test_data_element_one", RuleValueType.TEXT
         )
         val rule: Rule = Rule("true", of(ruleAction), "", "")
         val ruleEngine = getRuleEngine(rule, of(ruleVariableOne))
@@ -236,11 +236,11 @@ class RuleEngineVariableNameTest {
         val ruleAction: RuleAction = RuleActionText.createForFeedback(
             "test_action_content", "d2:count(#{" + VARIABLE_NAME + "})"
         )
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent.create(
-            VARIABLE_NAME, "test_data_element_one", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
+            VARIABLE_NAME, true, ArrayList(), "test_data_element_one", RuleValueType.TEXT
         )
-        val ruleVariableTwo: RuleVariable = RuleVariableNewestEvent.create(
-            "test_var_two", "test_data_element_two", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariableTwo: RuleVariable = RuleVariableNewestEvent(
+            "test_var_two", true, ArrayList(), "test_data_element_two", RuleValueType.TEXT
         )
         val rule: Rule = Rule("true", of(ruleAction), "", "")
         val ruleEngine = getRuleEngine(rule, of(ruleVariableOne))
@@ -279,11 +279,8 @@ class RuleEngineVariableNameTest {
         val ruleAction: RuleAction = RuleActionText.createForFeedback(
             "test_action_content", "d2:count(#{" + UID01 + "})"
         )
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent.create(
-            UID01, "test_data_element_one", RuleValueType.TEXT, true, ArrayList()
-        )
-        val ruleVariableTwo: RuleVariable = RuleVariableNewestEvent.create(
-            "test_var_two", "test_data_element_two", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
+            UID01, true, ArrayList(), "test_data_element_one", RuleValueType.TEXT
         )
         val rule: Rule = Rule("true", of(ruleAction), "", "")
         val ruleEngine = getRuleEngine(rule, of(ruleVariableOne))
@@ -322,8 +319,8 @@ class RuleEngineVariableNameTest {
         val ruleAction: RuleAction = RuleActionText.createForFeedback(
             "test_action_content", "d2:countIfZeroPos(#{" + VARIABLE_NAME + "})"
         )
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent.create(
-            VARIABLE_NAME, "test_data_element_one", RuleValueType.NUMERIC, true, ArrayList()
+        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
+            VARIABLE_NAME, true, ArrayList(), "test_data_element_one", RuleValueType.NUMERIC
         )
         val rule: Rule = Rule("true", of(ruleAction), "", "")
         val ruleEngine = getRuleEngine(rule, of(ruleVariableOne))
@@ -357,8 +354,8 @@ class RuleEngineVariableNameTest {
         val ruleAction: RuleAction = RuleActionText.createForFeedback(
             "test_action_content", "d2:countIfZeroPos(#{" + UID01 + "})"
         )
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent.create(
-            UID01, "test_data_element_one", RuleValueType.NUMERIC, true, ArrayList()
+        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
+            UID01, true, ArrayList(), "test_data_element_one", RuleValueType.NUMERIC
         )
         val rule: Rule = Rule("true", of(ruleAction), "", "")
         val ruleEngine = getRuleEngine(rule, of(ruleVariableOne))
@@ -392,11 +389,11 @@ class RuleEngineVariableNameTest {
         val ruleAction: RuleAction = RuleActionText.createForFeedback(
             "test_action_content", "true"
         )
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent.create(
-            VARIABLE_NAME, "test_data_element_one", RuleValueType.NUMERIC, true, ArrayList()
+        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
+            VARIABLE_NAME, true, ArrayList(), "test_data_element_one", RuleValueType.NUMERIC
         )
-        val ruleVariableTwo: RuleVariable = RuleVariableNewestEvent.create(
-            "test_var_two", "test_data_element_two", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariableTwo: RuleVariable = RuleVariableNewestEvent(
+            "test_var_two", true, ArrayList(), "test_data_element_two", RuleValueType.TEXT
         )
         val rule: Rule = Rule("d2:maxValue(#{" + VARIABLE_NAME + "}) == 8.0", of(ruleAction), "", "")
         val ruleEngine = getRuleEngine(
@@ -435,11 +432,11 @@ class RuleEngineVariableNameTest {
         val ruleAction: RuleAction = RuleActionText.createForFeedback(
             "test_action_content", "true"
         )
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent.create(
-            UID01, "test_data_element_one", RuleValueType.NUMERIC, true, ArrayList()
+        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
+            UID01, true, ArrayList(), "test_data_element_one", RuleValueType.NUMERIC
         )
-        val ruleVariableTwo: RuleVariable = RuleVariableNewestEvent.create(
-            "test_var_two", "test_data_element_two", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariableTwo: RuleVariable = RuleVariableNewestEvent(
+            "test_var_two", true, ArrayList(), "test_data_element_two", RuleValueType.TEXT
         )
         val rule: Rule = Rule("d2:maxValue(#{" + UID01 + "}) == 8.0", of(ruleAction), "", "")
         val ruleEngine = getRuleEngine(
@@ -478,11 +475,11 @@ class RuleEngineVariableNameTest {
         val ruleAction: RuleAction = RuleActionText.createForFeedback(
             "test_action_content", "d2:minValue(#{" + VARIABLE_NAME + "})"
         )
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent.create(
-            VARIABLE_NAME, "test_data_element_one", RuleValueType.NUMERIC, true, ArrayList()
+        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
+            VARIABLE_NAME, true, ArrayList(), "test_data_element_one", RuleValueType.NUMERIC
         )
-        val ruleVariableTwo: RuleVariable = RuleVariableNewestEvent.create(
-            "test_var_two", "test_data_element_two", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariableTwo: RuleVariable = RuleVariableNewestEvent(
+            "test_var_two", true, ArrayList(), "test_data_element_two", RuleValueType.TEXT
         )
         val rule: Rule = Rule("true", of(ruleAction), "", "")
         val ruleEngine = getRuleEngine(
@@ -522,11 +519,11 @@ class RuleEngineVariableNameTest {
         val ruleAction: RuleAction = RuleActionText.createForFeedback(
             "test_action_content", "d2:minValue(#{" + UID01 + "})"
         )
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent.create(
-            UID01, "test_data_element_one", RuleValueType.NUMERIC, true, ArrayList()
+        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
+            UID01, true, ArrayList(), "test_data_element_one", RuleValueType.NUMERIC
         )
-        val ruleVariableTwo: RuleVariable = RuleVariableNewestEvent.create(
-            "test_var_two", "test_data_element_two", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariableTwo: RuleVariable = RuleVariableNewestEvent(
+            "test_var_two", true, ArrayList(), "test_data_element_two", RuleValueType.TEXT
         )
         val rule: Rule = Rule("true", of(ruleAction), "", "")
         val ruleEngine = getRuleEngine(
diff --git a/src/test/java/org/hisp/dhis/rules/RuleVariableValueMapBuilderTest.kt b/src/test/java/org/hisp/dhis/rules/RuleVariableValueMapBuilderTest.kt
index 512fa0d9..732afbb1 100644
--- a/src/test/java/org/hisp/dhis/rules/RuleVariableValueMapBuilderTest.kt
+++ b/src/test/java/org/hisp/dhis/rules/RuleVariableValueMapBuilderTest.kt
@@ -22,8 +22,8 @@ class RuleVariableValueMapBuilderTest {
 
     @Test
     fun currentEventVariableShouldContainNullValueForEnrollmentEvaluation() {
-        val ruleVariableOne: RuleVariable = RuleVariableCurrentEvent.create(
-            "test_variable_one", "test_dataelement_one", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariableOne: RuleVariable = RuleVariableCurrentEvent(
+            "test_variable_one", true, ArrayList(), "test_dataelement_one", RuleValueType.TEXT
         )
         val eventDate = dateFormat!!.parse("2015-01-01")
 
@@ -61,11 +61,11 @@ class RuleVariableValueMapBuilderTest {
     @Test
     @Throws(ParseException::class)
     fun currentEventVariableShouldContainValuesFromCurrentEvent() {
-        val ruleVariableOne: RuleVariable = RuleVariableCurrentEvent.create(
-            "test_variable_one", "test_dataelement_one", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariableOne: RuleVariable = RuleVariableCurrentEvent(
+            "test_variable_one", true, ArrayList(), "test_dataelement_one", RuleValueType.TEXT
         )
-        val ruleVariableTwo: RuleVariable = RuleVariableCurrentEvent.create(
-            "test_variable_two", "test_dataelement_two", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariableTwo: RuleVariable = RuleVariableCurrentEvent(
+            "test_variable_two", true, ArrayList(), "test_dataelement_two", RuleValueType.TEXT
         )
         val eventDate = dateFormat!!.parse("2015-01-01")
         val dueDate = dateFormat!!.parse("2016-01-01")
@@ -153,11 +153,11 @@ class RuleVariableValueMapBuilderTest {
     @Test
     @Throws(ParseException::class)
     fun newestEventProgramVariableShouldContainValueFromNewestContextEvent() {
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent.create(
-            "test_variable_one", "test_dataelement_one", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
+            "test_variable_one", true, ArrayList(), "test_dataelement_one", RuleValueType.TEXT
         )
-        val ruleVariableTwo: RuleVariable = RuleVariableNewestEvent.create(
-            "test_variable_two", "test_dataelement_two", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariableTwo: RuleVariable = RuleVariableNewestEvent(
+            "test_variable_two", true, ArrayList(), "test_dataelement_two", RuleValueType.TEXT
         )
         val oldestEventDate = dateFormat!!.parse("2013-01-01")
         val newestEventDate = dateFormat!!.parse("2017-01-01")
@@ -237,11 +237,11 @@ class RuleVariableValueMapBuilderTest {
     @Test
     @Throws(ParseException::class)
     fun newestEventProgramVariableShouldReturnValuesFromCurrentEventWhenIfNewest() {
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent.create(
-            "test_variable_one", "test_dataelement_one", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
+            "test_variable_one", true, ArrayList(), "test_dataelement_one", RuleValueType.TEXT
         )
-        val ruleVariableTwo: RuleVariable = RuleVariableNewestEvent.create(
-            "test_variable_two", "test_dataelement_two", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariableTwo: RuleVariable = RuleVariableNewestEvent(
+            "test_variable_two", true, ArrayList(), "test_dataelement_two", RuleValueType.TEXT
         )
         val dateEventOne = dateFormat!!.parse("2013-01-01")
         val dateEventTwo = dateFormat!!.parse("2014-01-01")
@@ -325,9 +325,9 @@ class RuleVariableValueMapBuilderTest {
     @Test
     @Throws(ParseException::class)
     fun newestEventProgramStageVariableShouldContainValueFromNewestContextEvent() {
-        val ruleVariable: RuleVariable = RuleVariableNewestStageEvent.create(
-            "test_variable",
-            "test_dataelement", "test_program_stage_one", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariable: RuleVariable = RuleVariableNewestStageEvent(
+            "test_variable", true, ArrayList(),
+            "test_dataelement", RuleValueType.TEXT, "test_program_stage_one"
         )
         val dateEventOne = dateFormat!!.parse("2014-02-03")
         val dateEventTwo = dateFormat!!.parse("2014-03-03")
@@ -399,9 +399,9 @@ class RuleVariableValueMapBuilderTest {
     @Test
     @Throws(ParseException::class)
     fun newestEventProgramStageVariableShouldNotContainAnyValues() {
-        val ruleVariable: RuleVariable = RuleVariableNewestStageEvent.create(
-            "test_variable",
-            "test_dataelement", "test_program_stage_one", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariable: RuleVariable = RuleVariableNewestStageEvent(
+            "test_variable", true, ArrayList(),
+            "test_dataelement", RuleValueType.TEXT, "test_program_stage_one"
         )
         val dateEventOne = dateFormat!!.parse("2014-03-03")
         val dateEventTwo = dateFormat!!.parse("2015-02-03")
@@ -458,9 +458,9 @@ class RuleVariableValueMapBuilderTest {
     @Test
     @Throws(ParseException::class)
     fun previousEventVariableShouldContainValuesFromPreviousEvent() {
-        val ruleVariable: RuleVariable = RuleVariablePreviousEvent.create(
-            "test_variable",
-            "test_dataelement", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariable: RuleVariable = RuleVariablePreviousEvent(
+            "test_variable", true, ArrayList(),
+            "test_dataelement", RuleValueType.TEXT
         )
         val dateEventOne = dateFormat!!.parse("2014-02-03")
         val dateEventTwo = dateFormat!!.parse("2014-03-03")
@@ -532,13 +532,13 @@ class RuleVariableValueMapBuilderTest {
     @Test
     @Throws(ParseException::class)
     fun attributeVariableShouldContainValuesFromContextEnrollment() {
-        val ruleVariableOne: RuleVariable = RuleVariableAttribute.create(
-            "test_variable_one",
-            "test_attribute_one", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariableOne: RuleVariable = RuleVariableAttribute(
+            "test_variable_one", true, ArrayList(),
+            "test_attribute_one", RuleValueType.TEXT
         )
-        val ruleVariableTwo: RuleVariable = RuleVariableAttribute.create(
-            "test_variable_two",
-            "test_attribute_two", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariableTwo: RuleVariable = RuleVariableAttribute(
+            "test_variable_two", true, ArrayList(),
+            "test_attribute_two", RuleValueType.TEXT
         )
         val eventDate = dateFormat!!.parse("2015-01-01")
         val enrollmentDate = dateFormat!!.parse("2014-03-01")
@@ -634,17 +634,17 @@ class RuleVariableValueMapBuilderTest {
     @Test
     @Throws(ParseException::class)
     fun ruleEnrollmentValuesShouldBePropagatedToMapCorrectly() {
-        val ruleVariableOne: RuleVariable = RuleVariableAttribute.create(
-            "test_variable_one",
-            "test_attribute_one", RuleValueType.NUMERIC, true, ArrayList()
+        val ruleVariableOne: RuleVariable = RuleVariableAttribute(
+            "test_variable_one", true, ArrayList(),
+            "test_attribute_one", RuleValueType.NUMERIC
         )
-        val ruleVariableTwo: RuleVariable = RuleVariableAttribute.create(
-            "test_variable_two",
-            "test_attribute_two", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariableTwo: RuleVariable = RuleVariableAttribute(
+            "test_variable_two", true, ArrayList(),
+            "test_attribute_two", RuleValueType.TEXT
         )
-        val ruleVariableThree: RuleVariable = RuleVariableCurrentEvent.create(
-            "test_variable_three",
-            "test_dataelement_one", RuleValueType.BOOLEAN, true, ArrayList()
+        val ruleVariableThree: RuleVariable = RuleVariableCurrentEvent(
+            "test_variable_three", true, ArrayList(),
+            "test_dataelement_one", RuleValueType.BOOLEAN
         )
         val currentDate = dateFormat!!.format(Date())
         val enrollmentDate = dateFormat!!.parse("2017-02-02")
@@ -696,17 +696,17 @@ class RuleVariableValueMapBuilderTest {
     @Test
     @Throws(ParseException::class)
     fun MultipleMapBuilderShoulCreateCorrectMapForEnrollmentAndEvents() {
-        val ruleVariableOne: RuleVariable = RuleVariableAttribute.create(
-            "test_variable_one",
-            "test_attribute_one", RuleValueType.NUMERIC, true, ArrayList()
+        val ruleVariableOne: RuleVariable = RuleVariableAttribute(
+            "test_variable_one", true, ArrayList(),
+            "test_attribute_one", RuleValueType.NUMERIC
         )
-        val ruleVariableTwo: RuleVariable = RuleVariableAttribute.create(
-            "test_variable_two",
-            "test_attribute_two", RuleValueType.TEXT, true, ArrayList()
+        val ruleVariableTwo: RuleVariable = RuleVariableAttribute(
+            "test_variable_two", true, ArrayList(),
+            "test_attribute_two", RuleValueType.TEXT
         )
-        val ruleVariableThree: RuleVariable = RuleVariableCurrentEvent.create(
-            "test_variable_three",
-            "test_dataelement_one", RuleValueType.BOOLEAN, true, ArrayList()
+        val ruleVariableThree: RuleVariable = RuleVariableCurrentEvent(
+            "test_variable_three", true, ArrayList(),
+            "test_dataelement_one", RuleValueType.BOOLEAN
         )
         val currentDate = dateFormat!!.format(Date())
         val enrollmentDate = dateFormat!!.parse("2017-02-02")
diff --git a/src/test/java/org/hisp/dhis/rules/VariableValueTypeTest.kt b/src/test/java/org/hisp/dhis/rules/VariableValueTypeTest.kt
index c0489fb4..82c6b138 100644
--- a/src/test/java/org/hisp/dhis/rules/VariableValueTypeTest.kt
+++ b/src/test/java/org/hisp/dhis/rules/VariableValueTypeTest.kt
@@ -38,10 +38,8 @@ class VariableValueTypeTest {
         val ruleAction: RuleAction = RuleActionText
             .createForFeedback("test_action_content", "#{test_variable}")
         val rule = Rule("#{test_variable} > #{test_variable2}", listOf(ruleAction), "", "")
-        val ruleVariable: RuleVariable = RuleVariableCurrentEvent
-            .create("test_variable", "test_data_element", RuleValueType.NUMERIC, true, ArrayList())
-        val ruleVariable2: RuleVariable = RuleVariableCurrentEvent
-            .create("test_variable2", "test_data_element2", RuleValueType.NUMERIC, true, ArrayList())
+        val ruleVariable: RuleVariable = RuleVariableCurrentEvent("test_variable", true, ArrayList(), "test_data_element", RuleValueType.NUMERIC)
+        val ruleVariable2: RuleVariable = RuleVariableCurrentEvent("test_variable2", true, ArrayList(), "test_data_element2", RuleValueType.NUMERIC)
         val ruleEngine = getRuleEngine(rule, listOf(ruleVariable, ruleVariable2))
         val ruleEvent = RuleEvent(
             "test_event", "test_program_stage", "",
@@ -62,10 +60,8 @@ class VariableValueTypeTest {
         val ruleAction: RuleAction = RuleActionText
             .createForFeedback("test_action_content", "#{test_variable}")
         val rule = Rule("#{test_variable} > #{test_variable2}", listOf(ruleAction), "", "")
-        val ruleVariable: RuleVariable = RuleVariableCurrentEvent
-            .create("test_variable", "test_data_element", RuleValueType.TEXT, true, ArrayList())
-        val ruleVariable2: RuleVariable = RuleVariableCurrentEvent
-            .create("test_variable2", "test_data_element2", RuleValueType.TEXT, true, ArrayList())
+        val ruleVariable: RuleVariable = RuleVariableCurrentEvent("test_variable", true, ArrayList(), "test_data_element", RuleValueType.TEXT)
+        val ruleVariable2: RuleVariable = RuleVariableCurrentEvent("test_variable2", true, ArrayList(), "test_data_element2", RuleValueType.TEXT)
         val ruleEngine = getRuleEngine(rule, listOf(ruleVariable, ruleVariable2))
         val ruleEvent = RuleEvent(
             "test_event", "test_program_stage", "",
diff --git a/src/test/java/org/hisp/dhis/rules/models/CalculatedValueTest.kt b/src/test/java/org/hisp/dhis/rules/models/CalculatedValueTest.kt
index 1f248202..32bc13eb 100644
--- a/src/test/java/org/hisp/dhis/rules/models/CalculatedValueTest.kt
+++ b/src/test/java/org/hisp/dhis/rules/models/CalculatedValueTest.kt
@@ -116,8 +116,7 @@ class CalculatedValueTest {
     }
 
     private fun getRuleEngine(rules: List<Rule>): RuleEngine {
-        val ruleVariable: RuleVariable = RuleVariableCalculatedValue
-            .create("test_calculated_value", "", RuleValueType.TEXT, true, ArrayList())
+        val ruleVariable: RuleVariable = RuleVariableCalculatedValue("test_calculated_value", true, ArrayList(), "", RuleValueType.TEXT)
         return RuleEngine(RuleEngineContext(rules, listOf(ruleVariable)))
     }
 }
diff --git a/src/test/java/org/hisp/dhis/rules/models/RuleAttributeValueTest.java b/src/test/java/org/hisp/dhis/rules/models/RuleAttributeValueTest.java
deleted file mode 100644
index 761adbb4..00000000
--- a/src/test/java/org/hisp/dhis/rules/models/RuleAttributeValueTest.java
+++ /dev/null
@@ -1,21 +0,0 @@
-package org.hisp.dhis.rules.models;
-
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-
-import static org.junit.Assert.assertEquals;
-
-@RunWith( JUnit4.class )
-public class RuleAttributeValueTest
-{
-    @Test
-    public void propertiesShouldBePropagatedCorrectly()
-    {
-        RuleAttributeValue ruleAttributeValue = RuleAttributeValue
-            .create( "test_tracked_entity_attribute", "test_value" );
-
-        assertEquals( "test_tracked_entity_attribute" , ruleAttributeValue.trackedEntityAttribute() );
-        assertEquals( "test_value" , ruleAttributeValue.value() );
-    }
-}
diff --git a/src/test/java/org/hisp/dhis/rules/models/RuleAttributeValueTest.kt b/src/test/java/org/hisp/dhis/rules/models/RuleAttributeValueTest.kt
new file mode 100644
index 00000000..c67230b5
--- /dev/null
+++ b/src/test/java/org/hisp/dhis/rules/models/RuleAttributeValueTest.kt
@@ -0,0 +1,14 @@
+package org.hisp.dhis.rules.models
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class RuleAttributeValueTest {
+    @Test
+    fun propertiesShouldBePropagatedCorrectly() {
+        val ruleAttributeValue = RuleAttributeValue
+            .create("test_tracked_entity_attribute", "test_value")
+        assertEquals("test_tracked_entity_attribute", ruleAttributeValue.trackedEntityAttribute)
+        assertEquals("test_value", ruleAttributeValue.value)
+    }
+}
diff --git a/src/test/java/org/hisp/dhis/rules/models/RuleEnrollmentTest.kt b/src/test/java/org/hisp/dhis/rules/models/RuleEnrollmentTest.kt
index 0fdc6e94..ad8aea63 100644
--- a/src/test/java/org/hisp/dhis/rules/models/RuleEnrollmentTest.kt
+++ b/src/test/java/org/hisp/dhis/rules/models/RuleEnrollmentTest.kt
@@ -1,8 +1,6 @@
 package org.hisp.dhis.rules.models
 
 import java.util.*
-import kotlin.collections.ArrayList
-import kotlin.collections.MutableList
 import kotlin.test.Test
 import kotlin.test.assertEquals
 
diff --git a/src/test/java/org/hisp/dhis/rules/models/RuleVariableAttributeTest.java b/src/test/java/org/hisp/dhis/rules/models/RuleVariableAttributeTest.java
deleted file mode 100644
index d09efe7c..00000000
--- a/src/test/java/org/hisp/dhis/rules/models/RuleVariableAttributeTest.java
+++ /dev/null
@@ -1,24 +0,0 @@
-package org.hisp.dhis.rules.models;
-
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-
-import java.util.ArrayList;
-
-import static org.junit.Assert.assertEquals;
-
-@RunWith( JUnit4.class )
-public class RuleVariableAttributeTest
-{
-    @Test
-    public void createShouldPropagatePropertiesCorrectly()
-    {
-        RuleVariableAttribute ruleVariableAttribute = RuleVariableAttribute.create(
-            "test_variable", "test_attribute", RuleValueType.NUMERIC, true, new ArrayList<>());
-
-        assertEquals( "test_variable" , ruleVariableAttribute.name() );
-        assertEquals( "test_attribute" , ruleVariableAttribute.trackedEntityAttribute() );
-        assertEquals( RuleValueType.NUMERIC , ruleVariableAttribute.trackedEntityAttributeType() );
-    }
-}
diff --git a/src/test/java/org/hisp/dhis/rules/models/RuleVariableAttributeTest.kt b/src/test/java/org/hisp/dhis/rules/models/RuleVariableAttributeTest.kt
new file mode 100644
index 00000000..d13c7894
--- /dev/null
+++ b/src/test/java/org/hisp/dhis/rules/models/RuleVariableAttributeTest.kt
@@ -0,0 +1,16 @@
+package org.hisp.dhis.rules.models
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class RuleVariableAttributeTest {
+    @Test
+    fun createShouldPropagatePropertiesCorrectly() {
+        val ruleVariableAttribute = RuleVariableAttribute(
+            "test_variable", true, java.util.ArrayList(), "test_attribute", RuleValueType.NUMERIC
+        )
+        assertEquals("test_variable", ruleVariableAttribute.name)
+        assertEquals("test_attribute", ruleVariableAttribute.trackedEntityAttribute)
+        assertEquals(RuleValueType.NUMERIC, ruleVariableAttribute.trackedEntityAttributeType)
+    }
+}
diff --git a/src/test/java/org/hisp/dhis/rules/models/RuleVariableCurrentEventTest.java b/src/test/java/org/hisp/dhis/rules/models/RuleVariableCurrentEventTest.java
deleted file mode 100644
index dc7e32ac..00000000
--- a/src/test/java/org/hisp/dhis/rules/models/RuleVariableCurrentEventTest.java
+++ /dev/null
@@ -1,24 +0,0 @@
-package org.hisp.dhis.rules.models;
-
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-
-import java.util.ArrayList;
-
-import static org.junit.Assert.assertEquals;
-
-@RunWith( JUnit4.class )
-public class RuleVariableCurrentEventTest
-{
-    @Test
-    public void createShouldPropagatePropertiesCorrectly()
-    {
-        RuleVariableCurrentEvent ruleVariableCurrentEvent = RuleVariableCurrentEvent.create(
-            "test_variable", "test_dataelement", RuleValueType.NUMERIC, true, new ArrayList<>());
-
-        assertEquals( "test_variable" , ruleVariableCurrentEvent.name() );
-        assertEquals( "test_dataelement" , ruleVariableCurrentEvent.dataElement() );
-        assertEquals( RuleValueType.NUMERIC , ruleVariableCurrentEvent.dataElementType() );
-    }
-}
diff --git a/src/test/java/org/hisp/dhis/rules/models/RuleVariableCurrentEventTest.kt b/src/test/java/org/hisp/dhis/rules/models/RuleVariableCurrentEventTest.kt
new file mode 100644
index 00000000..16081f56
--- /dev/null
+++ b/src/test/java/org/hisp/dhis/rules/models/RuleVariableCurrentEventTest.kt
@@ -0,0 +1,16 @@
+package org.hisp.dhis.rules.models
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class RuleVariableCurrentEventTest {
+    @Test
+    fun createShouldPropagatePropertiesCorrectly() {
+        val ruleVariableCurrentEvent = RuleVariableCurrentEvent(
+            "test_variable", true, ArrayList(), "test_dataelement", RuleValueType.NUMERIC
+        )
+        assertEquals("test_variable", ruleVariableCurrentEvent.name)
+        assertEquals("test_dataelement", ruleVariableCurrentEvent.dataElement)
+        assertEquals(RuleValueType.NUMERIC, ruleVariableCurrentEvent.dataElementType)
+    }
+}
diff --git a/src/test/java/org/hisp/dhis/rules/models/RuleVariableNewestEventTest.java b/src/test/java/org/hisp/dhis/rules/models/RuleVariableNewestEventTest.java
deleted file mode 100644
index 4372a261..00000000
--- a/src/test/java/org/hisp/dhis/rules/models/RuleVariableNewestEventTest.java
+++ /dev/null
@@ -1,24 +0,0 @@
-package org.hisp.dhis.rules.models;
-
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-
-import java.util.ArrayList;
-
-import static org.junit.Assert.assertEquals;
-
-@RunWith( JUnit4.class )
-public class RuleVariableNewestEventTest
-{
-    @Test
-    public void createShouldPropagatePropertiesCorrectly()
-    {
-        RuleVariableNewestEvent ruleVariableNewestEvent = RuleVariableNewestEvent.create(
-            "test_variable", "test_dataelement", RuleValueType.NUMERIC, true, new ArrayList<>());
-
-        assertEquals( "test_variable" , ruleVariableNewestEvent.name() );
-        assertEquals( "test_dataelement" , ruleVariableNewestEvent.dataElement() );
-        assertEquals( RuleValueType.NUMERIC , ruleVariableNewestEvent.dataElementType() );
-    }
-}
diff --git a/src/test/java/org/hisp/dhis/rules/models/RuleVariableNewestEventTest.kt b/src/test/java/org/hisp/dhis/rules/models/RuleVariableNewestEventTest.kt
new file mode 100644
index 00000000..6ec9fae8
--- /dev/null
+++ b/src/test/java/org/hisp/dhis/rules/models/RuleVariableNewestEventTest.kt
@@ -0,0 +1,15 @@
+package org.hisp.dhis.rules.models
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+class RuleVariableNewestEventTest {
+    @Test
+    fun createShouldPropagatePropertiesCorrectly() {
+        val ruleVariableNewestEvent = RuleVariableNewestEvent(
+            "test_variable", true, ArrayList(), "test_dataelement", RuleValueType.NUMERIC
+        )
+        assertEquals("test_variable", ruleVariableNewestEvent.name)
+        assertEquals("test_dataelement", ruleVariableNewestEvent.dataElement)
+        assertEquals(RuleValueType.NUMERIC, ruleVariableNewestEvent.dataElementType)
+    }
+}
diff --git a/src/test/java/org/hisp/dhis/rules/models/RuleVariableNewestStageEventTest.java b/src/test/java/org/hisp/dhis/rules/models/RuleVariableNewestStageEventTest.java
deleted file mode 100644
index 81a5ac4e..00000000
--- a/src/test/java/org/hisp/dhis/rules/models/RuleVariableNewestStageEventTest.java
+++ /dev/null
@@ -1,25 +0,0 @@
-package org.hisp.dhis.rules.models;
-
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-
-import java.util.ArrayList;
-
-import static org.junit.Assert.assertEquals;
-
-@RunWith( JUnit4.class )
-public class RuleVariableNewestStageEventTest
-{
-    @Test
-    public void createShouldPropagatePropertiesCorrectly()
-    {
-        RuleVariableNewestStageEvent ruleVariablePreviousEvent = RuleVariableNewestStageEvent.create(
-            "test_variable", "test_dataelement", "test_programstage", RuleValueType.NUMERIC, true, new ArrayList<>());
-
-        assertEquals( "test_variable" , ruleVariablePreviousEvent.name() );
-        assertEquals( "test_dataelement" , ruleVariablePreviousEvent.dataElement() );
-        assertEquals( "test_programstage" , ruleVariablePreviousEvent.programStage() );
-        assertEquals( RuleValueType.NUMERIC , ruleVariablePreviousEvent.dataElementType() );
-    }
-}
diff --git a/src/test/java/org/hisp/dhis/rules/models/RuleVariableNewestStageEventTest.kt b/src/test/java/org/hisp/dhis/rules/models/RuleVariableNewestStageEventTest.kt
new file mode 100644
index 00000000..b9e9fb40
--- /dev/null
+++ b/src/test/java/org/hisp/dhis/rules/models/RuleVariableNewestStageEventTest.kt
@@ -0,0 +1,16 @@
+package org.hisp.dhis.rules.models
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+class RuleVariableNewestStageEventTest {
+    @Test
+    fun createShouldPropagatePropertiesCorrectly() {
+        val ruleVariablePreviousEvent = RuleVariableNewestStageEvent(
+            "test_variable", true, ArrayList(), "test_dataelement", RuleValueType.NUMERIC, "test_programstage"
+        )
+        assertEquals("test_variable", ruleVariablePreviousEvent.name)
+        assertEquals("test_dataelement", ruleVariablePreviousEvent.dataElement)
+        assertEquals("test_programstage", ruleVariablePreviousEvent.programStage)
+        assertEquals(RuleValueType.NUMERIC, ruleVariablePreviousEvent.dataElementType)
+    }
+}
diff --git a/src/test/java/org/hisp/dhis/rules/models/RuleVariablePreviousEventTest.java b/src/test/java/org/hisp/dhis/rules/models/RuleVariablePreviousEventTest.java
deleted file mode 100644
index 118dc8fb..00000000
--- a/src/test/java/org/hisp/dhis/rules/models/RuleVariablePreviousEventTest.java
+++ /dev/null
@@ -1,24 +0,0 @@
-package org.hisp.dhis.rules.models;
-
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-
-import java.util.ArrayList;
-
-import static org.junit.Assert.assertEquals;
-
-@RunWith( JUnit4.class )
-public class RuleVariablePreviousEventTest
-{
-    @Test
-    public void createShouldPropagatePropertiesCorrectly()
-    {
-        RuleVariablePreviousEvent ruleVariablePreviousEvent = RuleVariablePreviousEvent.create(
-            "test_variable", "test_dataelement", RuleValueType.NUMERIC, true, new ArrayList<>());
-
-        assertEquals( "test_variable" , ruleVariablePreviousEvent.name() );
-        assertEquals( "test_dataelement" , ruleVariablePreviousEvent.dataElement() );
-        assertEquals( RuleValueType.NUMERIC , ruleVariablePreviousEvent.dataElementType() );
-    }
-}
diff --git a/src/test/java/org/hisp/dhis/rules/models/RuleVariablePreviousEventTest.kt b/src/test/java/org/hisp/dhis/rules/models/RuleVariablePreviousEventTest.kt
new file mode 100644
index 00000000..a48242e8
--- /dev/null
+++ b/src/test/java/org/hisp/dhis/rules/models/RuleVariablePreviousEventTest.kt
@@ -0,0 +1,16 @@
+package org.hisp.dhis.rules.models
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class RuleVariablePreviousEventTest {
+    @Test
+    fun createShouldPropagatePropertiesCorrectly() {
+        val ruleVariablePreviousEvent = RuleVariablePreviousEvent(
+            "test_variable", true, ArrayList(), "test_dataelement", RuleValueType.NUMERIC
+        )
+        assertEquals("test_variable", ruleVariablePreviousEvent.name)
+        assertEquals("test_dataelement", ruleVariablePreviousEvent.dataElement)
+        assertEquals(RuleValueType.NUMERIC, ruleVariablePreviousEvent.dataElementType)
+    }
+}
diff --git a/src/test/java/org/hisp/dhis/rules/util/MockRuleVariable.java b/src/test/java/org/hisp/dhis/rules/util/MockRuleVariable.java
deleted file mode 100644
index a9a8c53d..00000000
--- a/src/test/java/org/hisp/dhis/rules/util/MockRuleVariable.java
+++ /dev/null
@@ -1,36 +0,0 @@
-package org.hisp.dhis.rules.util;
-
-import org.hisp.dhis.rules.Option;
-import org.hisp.dhis.rules.RuleVariableValue;
-import org.hisp.dhis.rules.RuleVariableValueMapBuilder;
-import org.hisp.dhis.rules.models.RuleAttributeValue;
-import org.hisp.dhis.rules.models.RuleDataValue;
-import org.hisp.dhis.rules.models.RuleVariable;
-
-import javax.annotation.Nonnull;
-import java.util.List;
-import java.util.Map;
-
-public class MockRuleVariable implements RuleVariable {
-    @Nonnull
-    @Override
-    public String name() {
-        return null;
-    }
-
-    @Override
-    public boolean useCodeForOptionSet() {
-        return false;
-    }
-
-    @Nonnull
-    @Override
-    public List<Option> options() {
-        return null;
-    }
-
-    @Override
-    public Map<String, RuleVariableValue> createValues(RuleVariableValueMapBuilder builder, Map<String, List<RuleDataValue>> allEventValues, Map<String, RuleAttributeValue> currentEnrollmentValues, Map<String, RuleDataValue> currentEventValues) {
-        return Map.of();
-    }
-}