How would I define move constructor and move assignment operator for unique_ptr of custom data type?

class threadMsg_t {
private:
    string msg;
    int type;
public:
    threadMsg_t(const string& msg, int type) : msg(msg), type(type) {};
    threadMsg_t& operator=(threadMsg_t&& oldMsg)
    {
        msg = move(oldMsg.msg);
        type = move(oldMsg.type);
        return *this;
    }
    threadMsg_t(threadMsg_t&& oldMsg) {
        msg = move(oldMsg.msg);
        type = move(oldMsg.type);
    }
    int getType() { return type; }
    string getMsg() { return msg; }
};

using msgP_t = unique_ptr<threadMsg_t>;
static queue<msgP_t> q;
static condition_variable cv;
static mutex mtx;

static void postMsg(threadMsg_t* newMsg)
{
    unique_lock<mutex> lck(mtx);
    q.push(std::move(msgP_t{newMsg}));
    cv.notify_one();
}

class workerThread_t {
public:
    static void processMsg()
    {
        while(true)  {
            unique_lock<mutex> lck{mtx};
            if(q.empty()) {
                cout << "Waiting for the message!" << endl;
                cv.wait(lck, []() { return !(q).empty(); });
            }
            if(q.empty()) {
                continue;
            }
            auto msgP = move(q.front());
            threadMsg_t* msg = msgP.get();
            q.pop();
            cout << "Processed Message - " << msg->getMsg() << endl;
            lck.unlock();
        }
    }
    thread* getThread()
    {
        return m_workerThread;
    }
    workerThread_t() {
        m_workerThread = new thread(&processMsg);
    }
    ~workerThread_t()
    {
        delete(m_workerThread);
    }
private:
    thread* m_workerThread;
};

Code works fine. But wondering the behavior when I do move(unique_ptr object) inside postMsg(). Seems like its not invoking the move constructor defined. Not sure whether its possible to define constructor for unique_ptr. I know that its needed for a custom structure containing "string" and "int". How would it behave if I have a ptr inside the structure?