diff --git a/query/src/main/java/com/quarkworks/android/realmtypesafequery/RealmTypeSafeQuery.java b/query/src/main/java/com/quarkworks/android/realmtypesafequery/RealmTypeSafeQuery.java
deleted file mode 100644
index bfe1b6e..0000000
--- a/query/src/main/java/com/quarkworks/android/realmtypesafequery/RealmTypeSafeQuery.java
+++ /dev/null
@@ -1,465 +0,0 @@
-package com.quarkworks.android.realmtypesafequery;
-
-import android.support.annotation.NonNull;
-import android.support.annotation.Nullable;
-
-import com.quarkworks.android.realmtypesafequery.fields.RealmAggregatableField;
-import com.quarkworks.android.realmtypesafequery.fields.RealmDistinctableField;
-import com.quarkworks.android.realmtypesafequery.fields.RealmEquatableField;
-import com.quarkworks.android.realmtypesafequery.fields.RealmField;
-import com.quarkworks.android.realmtypesafequery.fields.RealmMinMaxField;
-import com.quarkworks.android.realmtypesafequery.fields.RealmNullableField;
-import com.quarkworks.android.realmtypesafequery.fields.RealmStringField;
-import com.quarkworks.android.realmtypesafequery.fields.RealmComparableField;
-import com.quarkworks.android.realmtypesafequery.fields.RealmEmptyableField;
-import com.quarkworks.android.realmtypesafequery.fields.RealmInableField;
-import com.quarkworks.android.realmtypesafequery.fields.RealmSortableField;
-
-import java.util.List;
-
-import io.realm.Case;
-import io.realm.Realm;
-import io.realm.RealmCollection;
-import io.realm.RealmModel;
-import io.realm.RealmQuery;
-import io.realm.RealmResults;
-import io.realm.Sort;
-
-@SuppressWarnings({"unused", "WeakerAccess", "UnusedReturnValue"})
-public class RealmTypeSafeQuery<Model extends RealmModel> {
-
-    /*
-        Static Constructors
-     */
-
-    @NonNull
-    public static Builder with(@NonNull Realm realm) {
-        return new Builder(realm);
-    }
-
-    /*
-        Intermediary builder class
-     */
-
-    public static final class Builder {
-        @NonNull
-        private final Realm realm;
-
-        private Builder(@NonNull Realm realm) {
-            this.realm = realm;
-        }
-
-        @NonNull
-        public <M extends RealmModel> RealmTypeSafeQuery<M> where(@NonNull Class<M> clazz) {
-            return new RealmTypeSafeQuery<>(clazz, realm);
-        }
-    }
-
-    @NonNull
-    public static <M extends RealmModel> RealmTypeSafeQuery<M> where(@NonNull Class<M> clazz, @NonNull Realm realm) {
-        return new RealmTypeSafeQuery<>(clazz, realm);
-    }
-
-    /*
-         Quick Queries
-     */
-
-    @Nullable
-    public static <M extends RealmModel, V> M findFirst(@NonNull Realm realm, @NonNull RealmEquatableField<M, V> field, @Nullable V value) {
-        return RealmTypeSafeQuery.with(realm).where(field.getModelClass())
-                .equalTo(field, value).findFirst();
-    }
-
-    @Nullable
-    public static <M extends RealmModel, V, F extends RealmEquatableField<M, V> & RealmSortableField<M>> M findFirst(@NonNull Realm realm, @NonNull F field, @Nullable V value, @NonNull Sort sortOrder) {
-        return RealmTypeSafeQuery.with(realm).where(field.getModelClass()).equalTo(field, value)
-                .sort(field, sortOrder).findFirst();
-    }
-
-    @NonNull
-    public static <M extends RealmModel, V> RealmResults<M> findAll(@NonNull Realm realm, @NonNull RealmEquatableField<M, V> field, @Nullable V value) {
-        return new RealmTypeSafeQuery<>(field.getModelClass(), realm)
-                .equalTo(field, value).findAll();
-    }
-
-    @NonNull
-    public static <M extends RealmModel, V, F extends RealmEquatableField<M, V> & RealmSortableField<M>> RealmResults<M> findAll(@NonNull Realm realm, @NonNull F field, @Nullable V value, @NonNull Sort sortOrder) {
-        return RealmTypeSafeQuery.with(realm).where(field.getModelClass()).equalTo(field, value).sort(field, sortOrder).findAll();
-    }
-
-    @NonNull
-    private final RealmQuery<Model> realmQuery;
-
-    /*
-        Constructors
-     */
-
-    public RealmTypeSafeQuery(@NonNull RealmQuery<Model> realmQuery) {
-        this.realmQuery = realmQuery;
-    }
-
-    public RealmTypeSafeQuery(@NonNull Class<Model> modelClass, @NonNull Realm realm) {
-        realmQuery = realm.where(modelClass);
-    }
-
-    public RealmTypeSafeQuery(@NonNull RealmCollection<Model> realmCollection) {
-        realmQuery = realmCollection.where();
-    }
-
-    @NonNull
-    public RealmQuery<Model> getRealmQuery() {
-        return realmQuery;
-    }
-
-    public boolean isValid() {
-        return realmQuery.isValid();
-    }
-
-    /*
-        Null
-     */
-
-    @NonNull
-    public RealmTypeSafeQuery<Model> isNull(@NonNull RealmNullableField<Model> field) {
-        field.isNull(realmQuery);
-        return this;
-    }
-
-    @NonNull
-    public RealmTypeSafeQuery<Model> isNotNull(@NonNull RealmNullableField<Model> field) {
-        field.isNotNull(realmQuery);
-        return this;
-    }
-
-    /*
-        EqualTo
-     */
-
-    @NonNull
-    public <V> RealmTypeSafeQuery<Model> equalTo(@NonNull RealmEquatableField<Model, V> field, @Nullable V value) {
-        field.equalTo(realmQuery, value);
-        return this;
-    }
-
-    @NonNull
-    public <V> RealmTypeSafeQuery<Model> notEqualTo(@NonNull RealmEquatableField<Model, V> field, @Nullable V value) {
-        field.notEqualTo(realmQuery, value);
-        return this;
-    }
-
-    @NonNull
-    public final <V> RealmTypeSafeQuery<Model> in(@NonNull RealmInableField<Model, V> field, V[] values) {
-        field.in(realmQuery, values);
-        return this;
-    }
-
-    @NonNull
-    public final <V> RealmTypeSafeQuery<Model> in(@NonNull RealmInableField<Model, V> field, List<V> values) {
-        field.in(realmQuery, values);
-        return this;
-    }
-
-    /*
-        String
-    */
-
-    @NonNull
-    public RealmTypeSafeQuery<Model> equalTo(@NonNull RealmStringField<Model> field, @Nullable String value, @NonNull Case casing) {
-        field.equalTo(realmQuery, value, casing);
-        return this;
-    }
-
-    @NonNull
-    public RealmTypeSafeQuery<Model> notEqualTo(@NonNull RealmStringField<Model> field, @Nullable String value, @NonNull Case casing) {
-        field.notEqualTo(realmQuery, value, casing);
-        return this;
-    }
-
-    @NonNull
-    public RealmTypeSafeQuery<Model> beginsWith(@NonNull RealmStringField<Model> field, @Nullable String value) {
-        field.beginsWith(realmQuery, value);
-        return this;
-    }
-
-    @NonNull
-    public RealmTypeSafeQuery<Model> beginsWith(@NonNull RealmStringField<Model> field, @Nullable String value, @NonNull Case casing) {
-        field.beginsWith(realmQuery, value, casing);
-        return this;
-    }
-
-    @NonNull
-    public RealmTypeSafeQuery<Model> endsWith(@NonNull RealmStringField<Model> field, @Nullable String value) {
-        field.endsWith(realmQuery, value);
-        return this;
-    }
-
-    @NonNull
-    public RealmTypeSafeQuery<Model> endsWith(@NonNull RealmStringField<Model> field, @Nullable String value, @NonNull Case casing) {
-        field.endsWith(realmQuery, value, casing);
-        return this;
-    }
-
-    @NonNull
-    public RealmTypeSafeQuery<Model> contains(@NonNull RealmStringField<Model> field, @Nullable String value) {
-        field.contains(realmQuery, value);
-        return this;
-    }
-
-    @NonNull
-    public RealmTypeSafeQuery<Model> contains(@NonNull RealmStringField<Model> field, @Nullable String value, @NonNull Case casing) {
-        field.contains(realmQuery, value, casing);
-        return this;
-    }
-
-    @NonNull
-    public RealmTypeSafeQuery<Model> contains(@NonNull RealmStringField<Model> field, @Nullable String value, @NonNull String delimiter) {
-        field.contains(realmQuery, value, delimiter);
-        return this;
-    }
-
-    @NonNull
-    public RealmTypeSafeQuery<Model> contains(@NonNull RealmStringField<Model> field, @Nullable String value, @NonNull String delimiter, @NonNull Case casing) {
-        field.contains(realmQuery, value, delimiter, casing);
-        return this;
-    }
-
-    @NonNull
-    public RealmTypeSafeQuery<Model> like(@NonNull RealmStringField<Model> field, @Nullable String value) {
-        field.like(realmQuery, value);
-        return this;
-    }
-
-    @NonNull
-    public RealmTypeSafeQuery<Model> like(@NonNull RealmStringField<Model> field, @Nullable String value, @NonNull Case casing) {
-        field.like(realmQuery, value, casing);
-        return this;
-    }
-
-    /*
-        Comparison
-     */
-
-    @NonNull
-    public <V> RealmTypeSafeQuery<Model> greaterThan(@NonNull RealmComparableField<Model, V> field, @Nullable V value) {
-        field.greaterThan(realmQuery, value);
-        return this;
-    }
-
-    @NonNull
-    public <V> RealmTypeSafeQuery<Model> greaterThanOrEqualTo(@NonNull RealmComparableField<Model, V> field, @Nullable V value) {
-        field.greaterThanOrEqualTo(realmQuery, value);
-        return this;
-    }
-
-    @NonNull
-    public <V> RealmTypeSafeQuery<Model> lessThan(@NonNull RealmComparableField<Model, V> field, @Nullable V value) {
-        field.lessThan(realmQuery, value);
-        return this;
-    }
-
-    @NonNull
-    public <V> RealmTypeSafeQuery<Model> lessThanOrEqualTo(@NonNull RealmComparableField<Model, V> field, @Nullable V value) {
-        field.lessThanOrEqualTo(realmQuery, value);
-        return this;
-    }
-
-    @NonNull
-    public <V> RealmTypeSafeQuery<Model> between(@NonNull RealmComparableField<Model, V> field, @Nullable V start, @Nullable V end) {
-        field.between(realmQuery, start, end);
-        return this;
-    }
-
-    /*
-        Groups
-     */
-
-    public interface Group<Model extends RealmModel> {
-        void group(RealmTypeSafeQuery<Model> query);
-    }
-
-    @NonNull
-    public RealmTypeSafeQuery<Model> group(@NonNull RealmTypeSafeQuery.Group<Model> group) {
-        realmQuery.beginGroup();
-        group.group(this);
-        realmQuery.endGroup();
-        return this;
-    }
-
-    @NonNull
-    public RealmTypeSafeQuery<Model> beginGroup() {
-        realmQuery.beginGroup();
-        return this;
-    }
-
-    @NonNull
-    public RealmTypeSafeQuery<Model> endGroup() {
-        realmQuery.endGroup();
-        return this;
-    }
-
-    /*
-        Or
-     */
-
-    @NonNull
-    public RealmTypeSafeQuery<Model> or() {
-        realmQuery.or();
-        return this;
-    }
-
-    @NonNull
-    public RealmTypeSafeQuery<Model> or(@NonNull Group<Model> group) {
-        or().group(group);
-        return this;
-    }
-
-    /*
-        Not
-     */
-
-    @NonNull
-    public RealmTypeSafeQuery<Model> not() {
-        realmQuery.not();
-        return this;
-    }
-
-    @NonNull
-    public RealmTypeSafeQuery<Model> not(@NonNull Group<Model> group) {
-        not().group(group);
-        return this;
-    }
-
-    /*
-        Empty
-     */
-
-    @NonNull
-    public RealmTypeSafeQuery<Model> isEmpty(@NonNull RealmEmptyableField<Model> field) {
-        field.isEmpty(realmQuery);
-        return this;
-    }
-
-    @NonNull
-    public RealmTypeSafeQuery<Model> isNotEmpty(@NonNull RealmEmptyableField<Model> field) {
-        field.isNotEmpty(realmQuery);
-        return this;
-    }
-
-    /*
-        Distinct
-     */
-
-    @NonNull
-    public RealmQuery<Model> distinct(@NonNull RealmDistinctableField<Model> field) {
-        return field.distinct(realmQuery);
-    }
-
-    @NonNull
-    @SafeVarargs
-    public final RealmQuery<Model> distinct(@NonNull RealmDistinctableField<Model> firstField, @NonNull RealmDistinctableField<Model>... remainingFields) {
-        return firstField.distinct(realmQuery, remainingFields);
-    }
-
-    /*
-        Aggregate Functions
-     */
-
-    @NonNull
-    public <T> T sum(@NonNull RealmAggregatableField<Model, T> field) {
-        return field.sum(realmQuery);
-    }
-
-    public double average(@NonNull RealmAggregatableField<Model, ?> field) {
-        return field.average(realmQuery);
-    }
-
-    /*
-        Min Max
-     */
-
-    @Nullable
-    public <T> T min(@NonNull RealmMinMaxField<Model, T> field) {
-        return field.min(realmQuery);
-    }
-
-    @Nullable
-    public <T> T max(@NonNull RealmMinMaxField<Model, T> field) {
-        return field.max(realmQuery);
-    }
-
-    public long count() {
-        return realmQuery.count();
-    }
-
-    /*
-        Results
-     */
-
-    @NonNull
-    private static String[] fieldNames(@NonNull RealmField<?>[] fields) {
-        final String[] fieldNames = new String[fields.length];
-        for (int i = 0; i < fields.length; i++) {
-            fieldNames[i] = fields[i].getName();
-        }
-
-        return fieldNames;
-    }
-
-    @NonNull
-    public RealmResults<Model> findAll() {
-        return realmQuery.findAll();
-    }
-
-
-     /*
-        Find First
-     */
-
-    @Nullable
-    public Model findFirst() {
-        return realmQuery.findFirst();
-    }
-
-    /*
-        Async
-     */
-
-    @NonNull
-    public RealmResults<Model> findAllAsync() {
-        return realmQuery.findAllAsync();
-    }
-
-    @NonNull
-    public Model findFirstAsync() {
-        return realmQuery.findFirstAsync();
-    }
-
-
-    /*
-        Sort
-     */
-
-    @NonNull
-    public RealmTypeSafeQuery<Model> sort(@NonNull RealmSortableField<Model> field) {
-        field.sort(realmQuery);
-        return this;
-    }
-
-    @NonNull
-    public RealmTypeSafeQuery<Model> sort(@NonNull RealmSortableField<Model> field, @NonNull Sort sortOrder) {
-        field.sort(realmQuery, sortOrder);
-        return this;
-    }
-
-    @NonNull
-    public RealmTypeSafeQuery<Model> sort(@NonNull RealmSortableField<Model> field1, @NonNull Sort sortOrder1, @NonNull RealmSortableField<Model> field2, @NonNull Sort sortOrder2) {
-        field1.sort(realmQuery, sortOrder1, field2, sortOrder2);
-        return this;
-    }
-
-    @NonNull
-    public RealmTypeSafeQuery<Model> sort(@NonNull RealmSortableField<Model>[] fields, @NonNull Sort[] sortOrders) {
-        RealmSortableField.Companion.sort(realmQuery, fields, sortOrders);
-        return this;
-    }
-}
\ No newline at end of file
diff --git a/query/src/main/java/com/quarkworks/android/realmtypesafequery/constants/RealmDefaults.java b/query/src/main/java/com/quarkworks/android/realmtypesafequery/constants/RealmDefaults.java
deleted file mode 100644
index 477ae69..0000000
--- a/query/src/main/java/com/quarkworks/android/realmtypesafequery/constants/RealmDefaults.java
+++ /dev/null
@@ -1,20 +0,0 @@
-package com.quarkworks.android.realmtypesafequery.constants;
-
-import java.util.Date;
-
-@SuppressWarnings("unused")
-public class RealmDefaults {
-    public final static boolean BOOLEAN = false;
-    public final static byte BYTE = 0x0;
-    public final static short SHORT = 0;
-    public final static int INTEGER = 0;
-    public final static long LONG = 0L;
-
-    public final static float FLOAT = 0.0f;
-    public final static double DOUBLE = 0.0d;
-
-    public final static String STRING = "";
-    public final static Date DATE = new Date(0);
-
-    public final static byte[] BYTE_ARRAY = new byte[] {};
-}
\ No newline at end of file
diff --git a/query/src/main/kotlin/com/quarkworks/android/realmtypesafequery/RealmTypeSafeQuery.kt b/query/src/main/kotlin/com/quarkworks/android/realmtypesafequery/RealmTypeSafeQuery.kt
new file mode 100644
index 0000000..fcbb0bb
--- /dev/null
+++ b/query/src/main/kotlin/com/quarkworks/android/realmtypesafequery/RealmTypeSafeQuery.kt
@@ -0,0 +1,382 @@
+package com.quarkworks.android.realmtypesafequery
+
+import com.quarkworks.android.realmtypesafequery.fields.RealmAggregatableField
+import com.quarkworks.android.realmtypesafequery.fields.RealmComparableField
+import com.quarkworks.android.realmtypesafequery.fields.RealmDistinctableField
+import com.quarkworks.android.realmtypesafequery.fields.RealmEmptyableField
+import com.quarkworks.android.realmtypesafequery.fields.RealmEquatableField
+import com.quarkworks.android.realmtypesafequery.fields.RealmField
+import com.quarkworks.android.realmtypesafequery.fields.RealmInableField
+import com.quarkworks.android.realmtypesafequery.fields.RealmMinMaxField
+import com.quarkworks.android.realmtypesafequery.fields.RealmNullableField
+import com.quarkworks.android.realmtypesafequery.fields.RealmSortableField
+import com.quarkworks.android.realmtypesafequery.fields.RealmStringField
+import io.realm.Case
+import io.realm.Realm
+import io.realm.RealmCollection
+import io.realm.RealmModel
+import io.realm.RealmQuery
+import io.realm.RealmResults
+import io.realm.Sort
+
+/**
+ * @author berbschloe@quarkworks.co (Brandon Erbschloe)
+ * @author paul@quarkworks.co (Paul Gillis)
+ */
+@Suppress("unused")
+class RealmTypeSafeQuery<Model : RealmModel>(private val realmQuery: RealmQuery<Model>) {
+    /*
+     * Constructors
+     */
+    constructor(modelClass: Class<Model>, realm: Realm) : this(realm.where(modelClass))
+    constructor(realmCollection: RealmCollection<Model>) : this(realmCollection.where())
+
+    val isValid = realmQuery.isValid
+
+    companion object {
+
+        /*
+         * Static Constructors
+         */
+
+        @JvmStatic
+        fun with(realm: Realm) = Builder(realm)
+
+        @JvmStatic
+        fun <M : RealmModel> where(clazz: Class<M>, realm: Realm): RealmTypeSafeQuery<M> {
+            return RealmTypeSafeQuery(clazz, realm)
+        }
+
+        /*
+         * Quick Queries
+         */
+
+        @JvmStatic
+        fun <M : RealmModel, V> findFirst(realm: Realm, field: RealmEquatableField<M, V>, value: V?): M? {
+            return RealmTypeSafeQuery.with(realm).where(field.modelClass)
+                .equalTo(field, value).findFirst()
+        }
+
+        @JvmStatic
+        fun <M, V, F> findFirst(realm: Realm, field: F, value: V?, sortOrder: Sort): M?
+            where M : RealmModel, F : RealmSortableField<M>, F : RealmEquatableField<M, V>
+        {
+            return RealmTypeSafeQuery.with(realm)
+                .where(field.modelClass)
+                .equalTo(field, value)
+                .sort(field, sortOrder)
+                .findFirst()
+        }
+
+        @JvmStatic
+        fun <M : RealmModel, V> findAll(realm: Realm, field: RealmEquatableField<M, V>, value: V?): RealmResults<M> {
+            return RealmTypeSafeQuery(field.modelClass, realm)
+                .equalTo(field, value).findAll()
+        }
+
+        @JvmStatic
+        fun <M, V, F> findAll(realm: Realm, field: F, value: V?, sortOrder: Sort): RealmResults<M>
+            where M : RealmModel, F : RealmSortableField<M>, F : RealmEquatableField<M, V> {
+            return RealmTypeSafeQuery.with(realm)
+                .where(field.modelClass)
+                .equalTo(field, value)
+                .sort(field, sortOrder)
+                .findAll()
+        }
+
+        /*
+         * Results
+         */
+
+        @JvmStatic
+        private fun fieldNames(fields: Array<RealmField<*>>): Array<String> {
+            val fieldNames = Array(fields.size) { "" }
+            fields.forEachIndexed { index, realmField ->
+                fieldNames[index] = realmField.name
+            }
+
+            return fieldNames
+        }
+    }
+
+    /*
+     * Intermediary builder class
+     */
+
+    class Builder internal constructor(private val realm: Realm) {
+        fun <M : RealmModel> where(clazz: Class<M>): RealmTypeSafeQuery<M> {
+            return RealmTypeSafeQuery(clazz, realm)
+        }
+    }
+
+    /*
+     * Null
+     */
+
+    fun isNull(field: RealmNullableField<Model>): RealmTypeSafeQuery<Model> {
+        field.isNull(realmQuery)
+        return this
+    }
+
+    fun isNotNull(field: RealmNullableField<Model>): RealmTypeSafeQuery<Model> {
+        field.isNotNull(realmQuery)
+        return this
+    }
+
+    /*
+     * EqualTo
+     */
+
+    fun <V> equalTo(field: RealmEquatableField<Model, V>, value: V?): RealmTypeSafeQuery<Model> {
+        field.equalTo(realmQuery, value)
+        return this
+    }
+
+    fun <V> notEqualTo(field: RealmEquatableField<Model, V>, value: V?): RealmTypeSafeQuery<Model> {
+        field.notEqualTo(realmQuery, value)
+        return this
+    }
+
+    fun <V> `in`(field: RealmInableField<Model, V>, values: Array<V>): RealmTypeSafeQuery<Model> {
+        field.`in`(realmQuery, values)
+        return this
+    }
+
+    fun <V> `in`(field: RealmInableField<Model, V>, values: List<V>): RealmTypeSafeQuery<Model> {
+        field.`in`(realmQuery, values)
+        return this
+    }
+
+    /*
+     * String
+     */
+
+    fun equalTo(field: RealmStringField<Model>, value: String?, casing: Case): RealmTypeSafeQuery<Model> {
+        field.equalTo(realmQuery, value, casing)
+        return this
+    }
+
+    fun notEqualTo(field: RealmStringField<Model>, value: String?, casing: Case): RealmTypeSafeQuery<Model> {
+        field.notEqualTo(realmQuery, value, casing)
+        return this
+    }
+
+    fun beginsWith(field: RealmStringField<Model>, value: String?): RealmTypeSafeQuery<Model> {
+        field.beginsWith(realmQuery, value)
+        return this
+    }
+
+    fun beginsWith(field: RealmStringField<Model>, value: String?, casing: Case): RealmTypeSafeQuery<Model> {
+        field.beginsWith(realmQuery, value, casing)
+        return this
+    }
+
+    fun endsWith(field: RealmStringField<Model>, value: String?): RealmTypeSafeQuery<Model> {
+        field.endsWith(realmQuery, value)
+        return this
+    }
+
+    fun endsWith(field: RealmStringField<Model>, value: String?, casing: Case): RealmTypeSafeQuery<Model> {
+        field.endsWith(realmQuery, value, casing)
+        return this
+    }
+
+    fun contains(field: RealmStringField<Model>, value: String?): RealmTypeSafeQuery<Model> {
+        field.contains(realmQuery, value)
+        return this
+    }
+
+    fun contains(field: RealmStringField<Model>, value: String?, casing: Case): RealmTypeSafeQuery<Model> {
+        field.contains(realmQuery, value, casing)
+        return this
+    }
+
+    fun contains(field: RealmStringField<Model>, value: String?, delimiter: String): RealmTypeSafeQuery<Model> {
+        field.contains(realmQuery, value, delimiter)
+        return this
+    }
+
+    fun contains(field: RealmStringField<Model>, value: String?, delimiter: String, casing: Case): RealmTypeSafeQuery<Model> {
+        field.contains(realmQuery, value, delimiter, casing)
+        return this
+    }
+
+    fun like(field: RealmStringField<Model>, value: String?): RealmTypeSafeQuery<Model> {
+        field.like(realmQuery, value)
+        return this
+    }
+
+    fun like(field: RealmStringField<Model>, value: String?, casing: Case): RealmTypeSafeQuery<Model> {
+        field.like(realmQuery, value, casing)
+        return this
+    }
+
+    /*
+     * Comparison
+     */
+
+    fun <V> greaterThan(field: RealmComparableField<Model, V>, value: V?): RealmTypeSafeQuery<Model> {
+        field.greaterThan(realmQuery, value)
+        return this
+    }
+
+    fun <V> greaterThanOrEqualTo(field: RealmComparableField<Model, V>, value: V?): RealmTypeSafeQuery<Model> {
+        field.greaterThanOrEqualTo(realmQuery, value)
+        return this
+    }
+
+    fun <V> lessThan(field: RealmComparableField<Model, V>, value: V?): RealmTypeSafeQuery<Model> {
+        field.lessThan(realmQuery, value)
+        return this
+    }
+
+    fun <V> lessThanOrEqualTo(field: RealmComparableField<Model, V>, value: V?): RealmTypeSafeQuery<Model> {
+        field.lessThanOrEqualTo(realmQuery, value)
+        return this
+    }
+
+    fun <V> between(field: RealmComparableField<Model, V>, start: V?, end: V?): RealmTypeSafeQuery<Model> {
+        field.between(realmQuery, start, end)
+        return this
+    }
+
+    /*
+     * Groups
+     */
+
+    interface Group<Model : RealmModel> {
+        fun group(query: RealmTypeSafeQuery<Model>)
+    }
+
+    fun group(group: (RealmTypeSafeQuery<Model>) -> Unit): RealmTypeSafeQuery<Model> {
+        realmQuery.beginGroup()
+        group(this)
+        realmQuery.endGroup()
+        return this
+    }
+
+    fun group(group: RealmTypeSafeQuery.Group<Model>): RealmTypeSafeQuery<Model> = group(group::group)
+
+    fun beginGroup(): RealmTypeSafeQuery<Model> {
+        realmQuery.beginGroup()
+        return this
+    }
+
+    fun endGroup(): RealmTypeSafeQuery<Model> {
+        realmQuery.endGroup()
+        return this
+    }
+
+    /*
+     * Or
+     */
+
+    fun or(): RealmTypeSafeQuery<Model> {
+        realmQuery.or()
+        return this
+    }
+
+    fun or(group: Group<Model>): RealmTypeSafeQuery<Model> {
+        or().group(group)
+        return this
+    }
+
+    /*
+     * Not
+     */
+
+    operator fun not(): RealmTypeSafeQuery<Model> {
+        realmQuery.not()
+        return this
+    }
+
+    fun not(group: Group<Model>): RealmTypeSafeQuery<Model> {
+        not().group(group)
+        return this
+    }
+
+    /*
+     * Empty
+     */
+
+    fun isEmpty(field: RealmEmptyableField<Model>): RealmTypeSafeQuery<Model> {
+        field.isEmpty(realmQuery)
+        return this
+    }
+
+    fun isNotEmpty(field: RealmEmptyableField<Model>): RealmTypeSafeQuery<Model> {
+        field.isNotEmpty(realmQuery)
+        return this
+    }
+
+    /*
+     * Distinct
+     */
+
+    fun distinct(field: RealmDistinctableField<Model>): RealmQuery<Model> = field.distinct(realmQuery)
+
+    @SafeVarargs
+    fun distinct(firstField: RealmDistinctableField<Model>, vararg remainingFields: RealmDistinctableField<Model>): RealmQuery<Model> {
+        return firstField.distinct(realmQuery, *remainingFields)
+    }
+
+    /*
+     * Aggregate Functions
+     */
+
+    fun <T> sum(field: RealmAggregatableField<Model, T>): T = field.sum(realmQuery)
+
+    fun average(field: RealmAggregatableField<Model, *>): Double = field.average(realmQuery)
+
+    /*
+     * Min Max
+     */
+
+    fun <T> min(field: RealmMinMaxField<Model, T>): T? = field.min(realmQuery)
+
+    fun <T> max(field: RealmMinMaxField<Model, T>): T? = field.max(realmQuery)
+
+    fun count(): Long = realmQuery.count()
+
+    fun findAll(): RealmResults<Model> = realmQuery.findAll()
+
+
+    /*
+     * Find First
+     */
+
+    fun findFirst(): Model? = realmQuery.findFirst()
+
+    /*
+     * Async
+     */
+
+    fun findAllAsync(): RealmResults<Model> = realmQuery.findAllAsync()
+
+    fun findFirstAsync(): Model = realmQuery.findFirstAsync()
+
+
+    /*
+     * Sort
+     */
+
+    fun sort(field: RealmSortableField<Model>): RealmTypeSafeQuery<Model> {
+        field.sort(realmQuery)
+        return this
+    }
+
+    fun sort(field: RealmSortableField<Model>, sortOrder: Sort): RealmTypeSafeQuery<Model> {
+        field.sort(realmQuery, sortOrder)
+        return this
+    }
+
+    fun sort(field1: RealmSortableField<Model>, sortOrder1: Sort, field2: RealmSortableField<Model>, sortOrder2: Sort): RealmTypeSafeQuery<Model> {
+        field1.sort(realmQuery, sortOrder1, field2, sortOrder2)
+        return this
+    }
+
+    fun sort(fields: Array<RealmSortableField<Model>>, sortOrders: Array<Sort>): RealmTypeSafeQuery<Model> {
+        RealmSortableField.sort(realmQuery, fields, sortOrders)
+        return this
+    }
+}
\ No newline at end of file
diff --git a/query/src/main/kotlin/com/quarkworks/android/realmtypesafequery/constants/RealmDefaults.kt b/query/src/main/kotlin/com/quarkworks/android/realmtypesafequery/constants/RealmDefaults.kt
new file mode 100644
index 0000000..1f231fd
--- /dev/null
+++ b/query/src/main/kotlin/com/quarkworks/android/realmtypesafequery/constants/RealmDefaults.kt
@@ -0,0 +1,24 @@
+package com.quarkworks.android.realmtypesafequery.constants
+
+import java.util.Date
+
+/**
+ * @author berbschloe@quarkworks.co (Brandon Erbschloe)
+ * @author paul@quarkworks.co (Paul Gillis)
+ */
+@Suppress("unused")
+object RealmDefaults {
+    const val BOOLEAN = false
+    const val BYTE: Byte = 0x0
+    const val SHORT: Short = 0
+    const val INTEGER = 0
+    const val LONG = 0L
+
+    const val FLOAT = 0.0f
+    const val DOUBLE = 0.0
+
+    const val STRING = ""
+    @JvmStatic val DATE = Date(0)
+
+    @JvmStatic val BYTE_ARRAY = byteArrayOf()
+}
\ No newline at end of file