Are these two types the same types of not?

I'm so confused about this template I wrote, It's supposed to 'auto' deduce a pointer type that I pass in, but the compiler doesn't seem to think that two types are the same, whereas I do, and typeid() is on my side.

#include <iostream>

template <auto* static_ptr_to_object>
struct Handle
{
    // static_ptr_to_object should be a pointer to a Whale<char>
    // Both of the following typedefs should result in types of Whale<char>
    // When I cout typeid() of these types it prints out the same types
    // However std::is_same_v returns false

    using pointee_type1 = std::remove_pointer_t<decltype(static_ptr_to_object)>;
    using pointee_type2 = decltype(*static_ptr_to_object); // The two are the same types

    void showTypes()
    {
        //static_assert(std::is_same_v<pointee_type1, pointee_type2>);
        // Uncommenting this line will make the static assert fail

        std::cout << "Type of 'pointee_type1' = " << typeid(pointee_type1).name() << "\n";
        std::cout << "Type of 'pointee_type2' = " << typeid(pointee_type2).name() << "\n";

        if (typeid(pointee_type1) == typeid(pointee_type2))
            std::cout << "Types are the same\n";
        else std::cout << "Types are not the same\n";

    }

    bool b1 = std::is_integral_v<decltype(pointee_type1::member)>;
    // Uncommenting the below line will make compilation fail

    //bool b2 = std::is_integral_v<decltype(pointee_type2::member)>;
    // pointee_type2 must be a class or namespace when followed by ::
    // pointee_type2 left of '::' must be a class or namespace name
    

};

template <typename T>
struct Whale
{
    T member;
};

Whale<char> whale;

int main()
{
    Handle<&whale> handleToWhale;
    handleToWhale.showTypes();
}

So I think the two types are the same, and typeid() operator says they are the same, yet std::is_same returns false, and based on the compiler error message it doesn't recognise that pointee_type2 is a class type because it doesn't recognise the :: operator for it.

Edit: My understanding about dereferencing pointers was wrong, this question relates to how a pointer dereference will return a reference type in some cases.