What does it mean No viable conversion from Node to Node?

I am tryint to build a binary search tree and this is the error I get for the add in the implementation of the BST class function:

Node class:

template <class ItemType>

class Node

{

private:

ItemType item;

Node *right;

Node *left;

public:

Node();

Node(const ItemType& aNum);

void setItem(const ItemType& aNum);

ItemType getItem() const;

bool isLeaf() const;

void setRight(Node* rightPtr);

void setLeft(Node* leftPtr);

Node* getRight() const;

Node* getLeft() const;

};

template <class ItemType>

Node::Node()

{

right = nullptr;

left = nullptr;

} //end default constructor

template <class ItemType>

Node::Node(const ItemType& aNum): item(aNum), right(nullptr), left(nullptr)

{

} //end 2nd constructor

template <class ItemType>

void Node::setItem(const ItemType& aNum)

{

item = aNum;

}

template <class ItemType>

void Node::setRight(Node* rightNodePtr)

{

right = rightNodePtr;

}

template <class ItemType>

void Node::setLeft(Node* leftNodePtr)

{

left = leftNodePtr;

}

template <class ItemType>

ItemType Node::getItem() const

{

return item;

}

template <class ItemType>

Node* Node::getRight() const

{

return right;

}

template <class ItemType>

Node* Node::getLeft() const

{

return right;

}

template <class ItemType>

class BST

{

private:

Node* rootPtr;

protected:

int getHeightHelper(Node *subTreePtr) const;

Node* placeNode(Node* subTreePtr, Node* newNodePtr);

void remove(Node* subTreePtr, const ItemType& target, bool& isSuccessful);

void inorder(void visit(ItemType&), Node* treePtr) const;

public:

BST();

BST(const ItemType& rootItem);

BST(const ItemType& rootItem,

const Node* leftTreePtr,

const Node* rightTreePtr);

bool isEmpty() const;

int getHeight() const;

bool add(const ItemType& newData);

void remove(const ItemType& data);

void inOrderTraverse(void visit(ItemType&));

void displayInOrder();

void inOrder(Node* p);

};

template <class ItemType>

BST::BST()

{

rootPtr = nullptr;

}

template <class ItemType>

BST::BST(const ItemType& rootItem)

{

rootPtr = rootItem;

}

template <class ItemType>

bool BST::add(const ItemType& newData)

{

Node* newNodePtr = Node(newData);

rootPtr = placeNode(rootPtr, newNodePtr );

return true;

}

template <class ItemType>

Node* BST::placeNode(Node* subTreePtr, Node* newNodePtr)

{

Node*tempPtr;

if(subTreePtr == nullptr)

return newNodePtr;

else if(subTreePtr->getItem() > newNodePtr->getItem())

{

tempPtr = placeNode(subTreePtr->getLeft(), newNodePtr);

subTreePtr->setLeft(tempPtr);

}

else

{

tempPtr = placeNode(subTreePtr->getRight(), newNodePtr);

subTreePtr->setRight(tempPtr);

}

return subTreePtr;

}

int main()

{

BST<int> tree;

for (int i = 1; i<=5; i++)

{

int random = rand() %100;

tree.add(random);

}

tree.displayInOrder();

return 0;

}