binary tree node counter

[SomthingICanRemeber]

Hello, i'm very new to this and i'm sorry if this is formatted incorrectly.
Anyway, I am trying to add a function to an already built code, that counts the nodes in a binary tree. I have built the function but i am getting a "size_aux was not declared in the scope." which is very frustrating as to why it wont compile. I am not allowed to change any of the original code. I have what i added denoted with ****
I very much appreciate any help.

//*************HEADER FILE******************
#include <iostream>

namespace hardendavebintree {
	class binarytree {
		private:
			struct node {
				int data;
				node* left;
				node* right;
			};
			node* rootptr;
			friend void remove_max(node*& rootptr, int& max);
			friend void del_aux(node*& rootptr, 
							   int num, bool& found);
			friend int find_aux(const node* rootptr, 
							    int num, bool& found);
			friend void insert_aux(node*& rootptr, int num);
			friend void print_aux(node* rootptr);
//***********************MY CODE***************************
			friend size_type size_aux(node* rootptr);
//***********************MY CODE***************************
		public:
			typedef std::size_t size_type;
			binarytree();
			void print();
			void insert(int num);
			int find(int num, bool& found);
			void del(int num, bool& found);
//***********************MY CODE***************************
                        size_type size();
//***********************MY CODE***************************
	};
}





//*****************************.CPP FILE************************
#include "binarytree.h"
#include <iostream>
using namespace std;

namespace hardendavebintree {
	binarytree::binarytree(){
		rootptr = NULL;
	}
//***********************MY CODE***************************
    binarytree::size_type binarytree::size()
    {
        return size_aux(rootptr);    
    }



    binarytree::size_type size_aux(binarytree::node* rootptr)
    {
        binarytree::size_type amount = 0;
        
        if(rootptr != NULL)
        {
            amount = 1 + size_aux(rootptr -> left) + size_aux(rootptr -> right);
        }
        
        return amount;
    }
//***********************MY CODE***************************

	void binarytree::print() {
		print_aux(rootptr);
	}

	void print_aux(binarytree::node* rootptr){
		if (rootptr != NULL) {
			print_aux(rootptr -> left);
			cout << rootptr -> data << " ";
			print_aux(rootptr -> right);
		}
	}

	void binarytree::insert(int num){
		insert_aux(rootptr, num);
	}

	void insert_aux(binarytree::node*& rootptr, int num){
		if (rootptr == NULL){
			rootptr = new binarytree::node;
			rootptr -> data = num;
			rootptr -> left = NULL;
			rootptr -> right = NULL;
		} else if (num <= rootptr -> data) {
			insert_aux(rootptr -> left, num);
		} else {
			insert_aux(rootptr -> right, num);
		}
	}

	int binarytree::find(int num, bool& found) {
		return find_aux(rootptr, num, found);
	}


	int find_aux(const binarytree::node* rootptr, int num, bool& found){
		if (rootptr == NULL) {
			found = false;
			return 0;
		} else if (rootptr -> data == num) {
			found = true;
			return rootptr -> data;
		} else if (num < rootptr -> data) {
			return find_aux(rootptr -> left, num, found);
		} else {
			return find_aux(rootptr -> right, num, found);
		}
	}



	void binarytree::del(int num, bool& found) {
		del_aux(rootptr, num, found);
	}


	void del_aux(binarytree::node*& rootptr, int num, bool& found){
		if (rootptr == NULL) {
			found = false;
		} else if (num < rootptr -> data) {
			del_aux(rootptr -> left, num, found);
		} else if (num > rootptr -> data) {
			del_aux(rootptr -> right, num, found);
		} else if (rootptr -> left == NULL) {
			binarytree::node* tempptr = rootptr;
			rootptr = rootptr -> right;
			delete tempptr;
			found = true;
		} else {
			int max;
			remove_max(rootptr -> left, max);
			rootptr -> data = max;
			found = true;
		}
	}


	void remove_max(binarytree::node*& rootptr, int& max){
		if (rootptr -> right == NULL) {
			max = rootptr -> data;
			binarytree::node* tempptr = rootptr;
			rootptr = rootptr -> left;
			delete tempptr;
		} else {
			remove_max(rootptr -> right, max);
		}
	}











/*
	void remove_max(binarytree::node*& rootptr, int& max){
		if (rootptr -> right == NULL){
			max = rootptr -> data;
			binarytree::node* tempptr = rootptr;
			rootptr = rootptr -> left;
			delete tempptr;
		} else {
			remove_max(rootptr -> right, max);
		}
	}
*/
}






//***************************CLIENT FILE****************************
#include <iostream>
#include <string>
#include "binarytree.h"
using namespace std;
using namespace hardendavebintree;

int main() {
	binarytree list;
	int num;
	bool found;

	cout << "enter number to insert (negative to quit): ";
	cin >> num;
	while (num >= 0){
		list.insert(num);
		cout << "enter number to insert (negative to quit): ";
		cin >> num;
	}

	list.print();
	cout << endl;

	cout << "enter number to find (negative to quit): ";
	cin >> num;
	while (num >= 0){
		int result = list.find(num, found);
		if (found) {
			cout << "found. The data is " << result << endl;
		} else {
			cout << "not found." << endl;
		}

		cout << "enter number to find (negative to quit): ";
		cin >> num;
	}



	cout << "enter number to delete (negative to quit): ";
	cin >> num;
	while (num >= 0){
		list.del(num, found);
		if (found) {
			cout << "found. The list is now ";
			list.print();
			cout << endl;
		} else {
			cout << "not found." << endl;
		}

		cout << "enter number to delete (negative to quit): ";
		cin >> num;
	}

}

[SomthingICanRemeber]

I apologize, i forgot to include the error message.

LINE: 21|error: 'size_type' does not name a type|

LINE: 11|error: 'size_aux' was not declared in this scope|

LINE: 6|error: 'struct hardendavebintree::binarytree::node' is private|

LINE: 16|error: within this context|

||=== Build finished: 4 errors, 1 warnings (0 minutes, 0 seconds) ===|

[heebleworp]

Line 21: change friend size_type size_aux(node* rootptr);
to friend std::size_t size_aux(node* rootptr);
As the typedef is not in effect yet.