How to resolve Unchecked call to 'mapByPage(Function, List>)' as a member of raw type 'android.arch.paging.PositionalDataSource'

Question

I'm investigating the use of android.arch.paging.PagedList within my current Android application.

My datasource is mapping between my database and UI model objects.

It all works as expected, however my DataSource.Factory create() method has the following warnings:-

Unchecked call to 'mapByPage(Function<List<T>, List<V>>)' as a member of raw type 'android.arch.paging.PositionalDataSource'
Unchecked assignment: 'android.arch.paging.PositionalDataSource' to 'android.arch.paging.DataSource<java.lang.Long, example.ui.ModelUI'>'.
Reason 'new ModelUIDataSource' has raw type, so result of mapByPage is erased

The classes in question are:-

public abstract class BaseDataSource<T> extends PositionalDataSource<ModelDO> {
    private static final String TAG = "BaseDataSource";

    @WorkerThread
    public abstract int countItems();

    @WorkerThread
    public abstract List<ModelDO> loadRange(final int startPosition, final int count);

    @Override
    public final void loadInitial(@NonNull final LoadInitialParams params, @NonNull final LoadInitialCallback<ModelDO> callback) {
        final int totalCount = countItems();

        if (totalCount == 0) {
            callback.onResult(Collections.emptyList(), 0, 0);
            return;
        }

        final int firstLoadPosition = computeInitialLoadPosition(params, totalCount);
        final int firstLoadSize = computeInitialLoadSize(params, firstLoadPosition, totalCount);

        final List<ModelDO> list = loadRange(firstLoadPosition, firstLoadSize);

        if (list != null && list.size() == firstLoadSize) {
            callback.onResult(list, firstLoadPosition, totalCount);
        } else {
            invalidate();
        }
    }

    @Override
    public final void loadRange(@NonNull final LoadRangeParams params, @NonNull final LoadRangeCallback<ModelDO> callback) {
        final List<ModelDO> list = loadRange(params.startPosition, params.loadSize);

        if (list == null) {
            invalidate();
        } else {
            callback.onResult(list);
        }
    }
}


public class ModelDataSource<T> extends BaseDataSource<ModelDO> {

    private static final String TAG = "ModelDataSource";

    private final Realm workerRealm;
    private final RealmResults<ModelDO> liveResults;

    private final RealmChangeListener<RealmResults<ModelDO>> realmChangeListener = results -> {
        if (results.isLoaded()) {
            invalidate();
        }
    };

    // WORKER THREAD
    ModelDataSource() {
        this.workerRealm = DatabaseController.getRealm();
        this.liveResults = DatabaseController.fetchShortListedResults(this.workerRealm);

        if (!liveResults.isLoaded()) {
            liveResults.load();
        }

        this.liveResults.addChangeListener(realmChangeListener);
    }

    @WorkerThread
    public int countItems() {
        if (workerRealm.isClosed() || !liveResults.isValid()) {
            Log.i(TAG, "RESULTS ARE NOT VALID, OR REALM IS CLOSED.");
            return 0;
        }
        return liveResults.size();
    }

    @Override
    public boolean isInvalid() {
        workerRealm.refresh();
        return super.isInvalid();
    }

    @WorkerThread
    @Override
    public List<ModelDO> loadRange(final int startPosition, final int count) {
        final int countItems = countItems();

        if (countItems == 0) {
            return Collections.emptyList();
        }

        final List<ModelDO> list = new ArrayList<>(count);

        for (int i = startPosition; i < startPosition + count && i < countItems; i++) {
            list.add(workerRealm.copyFromRealm(liveResults.get(i)));
        }

        return Collections.unmodifiableList(list);
    }
}


public class ModelDataSourceFactory<T> extends DataSource.Factory<Long, ModelUI> {
    private static final String TAG = "ModelDataSource";

    @Override
    public DataSource<Long, ModelUI> create() {
        return new ModelDataSource().mapByPage(new Function<List<ModelDO>, List<ModelUI>>() {
            @Override
            public List<ModelUI> apply(final List<ModelDO> input) {
                final List<ModelUI> output = new ArrayList<>();

                for (final ModelDO modelDO : input) {
                    final ModelUI modelUI = constructModelUI(modelDO);
                    output.add(modelUI);
                }
                return output;
            }
        });
    }
}

What refactoring is required to remove these warnings?

I am not asking "What is a raw type".

I cannot see where in the above classes I am using "Raw Types" or why I am seeing these warnings.