Problems overloading index operator

[l337SAWCE]

So to sum it all up, I'm a bit stuck. I'm making a bucket hash style HashTable class that is an array of pointers to single linked nodes. I'm a bit perplexed as to how I should retrieve the values of the nodes from the array.
When I try to retrieve values using an index I get that Value, Key, and Next are not members of HashTable. I am not sure how to structure the index operator. By declaring it as a HashTable type function, doesn't that also declare the return type? How should I go about just returning the Node, not a HashTable object?
Any insight would be greatly appreciated, I feel as though I may be overlooking some small details. Thanks!

template<typename DATA_TYPE>
class HashTable
{
public:
	//DEFAULT && INIT CONSTRUCTOR
	HashTable(int size = DEFAULT_SIZE, int load = 0)
	{
		Size = size;
		Load = load;
		Data = new Node<DATA_TYPE>[Size];
	}

	//DESTRUCTOR
	~HashTable()
	{
		delete[] Data;
	}

	// INDEX OPERATOR
	HashTable& operator[] (int index) const
	{
		if( (index < 0) || (index >= Size) )
			throw; //create exception to throw

		return Data;
	}

// ...

	// encapsulated array to be filled with pointers to linked list nodes
	Node<DATA_TYPE>* Data;
	int Size, Load;

};

//Node struct in separate, included header

// Nodes for linked list
template<typename DATA_TYPE> 
struct Node
{
	Node(DATA_TYPE value = NULL, string key = DEFAULT_KEY, Node* next = NULL)
	{
		Value = value;
		Key=key;
		Next = next;
	}

	DATA_TYPE Value;
	string Key;
	Node* Next;
};

[MiiNiPaa]

You tells compiler, you will return HashTable& and you are returning Node<DATA_TYPE>*

[l337SAWCE]

That's what I had figured, but when I change the function type to Node& it will not work as an operator for HashTable. Is there any way around this?

EDIT:
I see, I forgot to pass the <DATA_TYPE> through when I declared the index operator, so seeing as there was no member strictly "Node" it wouldn't compile. Thanks!

[MiiNiPaa]

Node* HashTable::operator[] (int index) isn't works?