map proxy-iterator conflicts C++20 iterator concepts - c++

Question

I'm trying to write a wrapper class that interprets a std::vector<T> as a mapping of integers to Ts. As I want it to behave like a map, its iterators should dereference to (key, value) pairs. Since there are no such pairs in memory, the reference type of my corresponding iterator class is a bit unconventional:
using value_type = std::pair<Key, Value>;
using reference = std::pair<Key, Value&>;
For the corresponding const_iterator, this becomes
using value_type = std::pair<Key, const Value>;
using reference = std::pair<Key, const Value&>;
Now, however, my const_iterator no longer satisfies std::indirectly_readable (and, thus, std::forward_iterator and, thus, std::random_access_iterator) because
no type named 'type' in 'struct std::common_reference<std::pair<long unsigned int, const int&>&&, std::pair<long unsigned int, const int>&>'
(see https://godbolt.org/z/s89z56rY7) or the full code here:
#include <iostream>
#include <type_traits>
#include <vector>
#include <iterator>
using namespace std;
template<class Value, class VType, class RType>
struct _vector_map_iterator {
Value* _data = nullptr;
size_t index = 0;
using value_type = VType;
using reference = RType;
using difference_type = ptrdiff_t;
using iterator_category = std::random_access_iterator_tag;
reference operator*() const { return {index, *_data}; }
_vector_map_iterator& operator++() { ++index; return *this; }
_vector_map_iterator operator++(int) {_vector_map_iterator res = *this; ++(*this); return res; }
bool operator==(const _vector_map_iterator& other) const { return _data == other.data; }
};
template<class T>
using vmap_iterator = _vector_map_iterator<T, pair<size_t, T>, pair<size_t, T&>>;
template<class T>
using vmap_const_iterator = _vector_map_iterator<const T, pair<size_t, const T>, pair<size_t, const T&>>;
using I = vmap_const_iterator<int>;
//static_assert(std::common_reference_with<typename I::reference&&, typename I::value_type&>);
static_assert(forward_iterator<I>);
template<class Value>
struct vector_map {
vector<Value> _raw_data;
using iterator = vmap_iterator<Value>;
using const_iterator = vmap_const_iterator<Value>;
iterator begin() { return {_raw_data.data(), 0}; }
const_iterator begin() const { return {_raw_data.data(), 0}; }
vector_map(const initializer_list<Value>& lst): _raw_data(lst) {};
};
int main(){
const vector_map<int> int_map = {1,2,3};
const auto it = int_map.begin();
cout << (*it).first << ": " << (*it).second << '\n';
}
My question would be: is there a sensible (I specifically do not want to store key-value-pairs in the vector!) design for such an iterator class that also adheres to std::random_access_iterator?
EDIT: more details + full example