Consistently use camel case enum names.

Including in tests and implementation files.

25 files changed, 91 insertions, 91 deletions

diff --git a/auto_tests/bootstrap_test.c b/auto_tests/bootstrap_test.c
index 86cbf99e..d9de339e 100644
--- a/auto_tests/bootstrap_test.c
+++ b/auto_tests/bootstrap_test.c
@@ -32,7 +32,7 @@ int main(void)
         c_sleep(ITERATION_INTERVAL);
     } while (tox_self_get_connection_status(tox_udp) == TOX_CONNECTION_NONE);
 
-    const TOX_CONNECTION status = tox_self_get_connection_status(tox_udp);
+    const Tox_Connection status = tox_self_get_connection_status(tox_udp);
     ck_assert_msg(status == TOX_CONNECTION_UDP,
                   "expected connection status to be UDP, but got %d", status);
     printf("Connection (UDP): %d\n", tox_self_get_connection_status(tox_udp));
diff --git a/auto_tests/conference_double_invite_test.c b/auto_tests/conference_double_invite_test.c
index ba173a90..17124f1c 100644
--- a/auto_tests/conference_double_invite_test.c
+++ b/auto_tests/conference_double_invite_test.c
@@ -19,7 +19,7 @@ typedef struct State {
 #include "run_auto_test.h"
 
 static void handle_conference_invite(
-    Tox *tox, uint32_t friend_number, TOX_CONFERENCE_TYPE type,
+    Tox *tox, uint32_t friend_number, Tox_Conference_Type type,
     const uint8_t *cookie, size_t length, void *user_data)
 {
     State *state = (State *)user_data;
@@ -29,7 +29,7 @@ static void handle_conference_invite(
     fprintf(stderr, "tox%u joining conference\n", state->index);
 
     if (friend_number != -1) {
-        TOX_ERR_CONFERENCE_JOIN err;
+        Tox_Err_Conference_Join err;
         state->conference = tox_conference_join(tox, friend_number, cookie, length, &err);
         ck_assert_msg(err == TOX_ERR_CONFERENCE_JOIN_OK,
                       "attempting to join the conference returned with an error: %d", err);
@@ -46,7 +46,7 @@ static void conference_double_invite_test(Tox **toxes, State *state)
 
     {
         // Create new conference, tox0 is the founder.
-        TOX_ERR_CONFERENCE_NEW err;
+        Tox_Err_Conference_New err;
         state[0].conference = tox_conference_new(toxes[0], &err);
         state[0].joined = true;
         ck_assert_msg(err == TOX_ERR_CONFERENCE_NEW_OK,
@@ -56,7 +56,7 @@ static void conference_double_invite_test(Tox **toxes, State *state)
 
     {
         // Invite friend.
-        TOX_ERR_CONFERENCE_INVITE err;
+        Tox_Err_Conference_Invite err;
         tox_conference_invite(toxes[0], 0, state[0].conference, &err);
         ck_assert_msg(err == TOX_ERR_CONFERENCE_INVITE_OK,
                       "attempting to invite a friend returned with an error: %d", err);
diff --git a/auto_tests/conference_peer_nick_test.c b/auto_tests/conference_peer_nick_test.c
index d8d2d64b..9d10a8a9 100644
--- a/auto_tests/conference_peer_nick_test.c
+++ b/auto_tests/conference_peer_nick_test.c
@@ -20,7 +20,7 @@ typedef struct State {
 #include "run_auto_test.h"
 
 static void handle_conference_invite(
-    Tox *tox, uint32_t friend_number, TOX_CONFERENCE_TYPE type,
+    Tox *tox, uint32_t friend_number, Tox_Conference_Type type,
     const uint8_t *cookie, size_t length, void *user_data)
 {
     State *state = (State *)user_data;
@@ -29,7 +29,7 @@ static void handle_conference_invite(
             state->index, friend_number, type, (unsigned)length);
     fprintf(stderr, "tox%u joining conference\n", state->index);
 
-    TOX_ERR_CONFERENCE_JOIN err;
+    Tox_Err_Conference_Join err;
     state->conference = tox_conference_join(tox, friend_number, cookie, length, &err);
     ck_assert_msg(err == TOX_ERR_CONFERENCE_JOIN_OK,
                   "attempting to join the conference returned with an error: %d", err);
@@ -44,7 +44,7 @@ static void handle_peer_list_changed(Tox *tox, uint32_t conference_number, void
     fprintf(stderr, "handle_peer_list_changed(#%u, %u, _)\n",
             state->index, conference_number);
 
-    TOX_ERR_CONFERENCE_PEER_QUERY err;
+    Tox_Err_Conference_Peer_Query err;
     uint32_t const count = tox_conference_peer_count(tox, conference_number, &err);
     ck_assert_msg(err == TOX_ERR_CONFERENCE_PEER_QUERY_OK,
                   "failed to get conference peer count: err = %d", err);
@@ -57,7 +57,7 @@ static void rebuild_peer_list(Tox *tox)
     for (uint32_t conference_number = 0;
             conference_number < tox_conference_get_chatlist_size(tox);
             ++conference_number) {
-        TOX_ERR_CONFERENCE_PEER_QUERY err;
+        Tox_Err_Conference_Peer_Query err;
         uint32_t const count = tox_conference_peer_count(tox, conference_number, &err);
         ck_assert_msg(err == TOX_ERR_CONFERENCE_PEER_QUERY_OK,
                       "failed to get conference peer count for conference %u: err = %d", conference_number, err);
@@ -90,7 +90,7 @@ static void conference_peer_nick_test(Tox **toxes, State *state)
 
     {
         // Create new conference, tox0 is the founder.
-        TOX_ERR_CONFERENCE_NEW err;
+        Tox_Err_Conference_New err;
         state[0].conference = tox_conference_new(toxes[0], &err);
         state[0].joined = true;
         ck_assert_msg(err == TOX_ERR_CONFERENCE_NEW_OK,
@@ -100,7 +100,7 @@ static void conference_peer_nick_test(Tox **toxes, State *state)
 
     {
         // Invite friend.
-        TOX_ERR_CONFERENCE_INVITE err;
+        Tox_Err_Conference_Invite err;
         tox_conference_invite(toxes[0], 0, state[0].conference, &err);
         ck_assert_msg(err == TOX_ERR_CONFERENCE_INVITE_OK,
                       "attempting to invite a friend returned with an error: %d", err);
diff --git a/auto_tests/conference_simple_test.c b/auto_tests/conference_simple_test.c
index c9d24dad..dadd7d62 100644
--- a/auto_tests/conference_simple_test.c
+++ b/auto_tests/conference_simple_test.c
@@ -23,7 +23,7 @@ typedef struct State {
     uint32_t peers;
 } State;
 
-static void handle_self_connection_status(Tox *tox, TOX_CONNECTION connection_status, void *user_data)
+static void handle_self_connection_status(Tox *tox, Tox_Connection connection_status, void *user_data)
 {
     State *state = (State *)user_data;
 
@@ -31,7 +31,7 @@ static void handle_self_connection_status(Tox *tox, TOX_CONNECTION connection_st
     state->self_online = connection_status != TOX_CONNECTION_NONE;
 }
 
-static void handle_friend_connection_status(Tox *tox, uint32_t friend_number, TOX_CONNECTION connection_status,
+static void handle_friend_connection_status(Tox *tox, uint32_t friend_number, Tox_Connection connection_status,
         void *user_data)
 {
     State *state = (State *)user_data;
@@ -40,7 +40,7 @@ static void handle_friend_connection_status(Tox *tox, uint32_t friend_number, TO
     state->friend_online = connection_status != TOX_CONNECTION_NONE;
 }
 
-static void handle_conference_invite(Tox *tox, uint32_t friend_number, TOX_CONFERENCE_TYPE type, const uint8_t *cookie,
+static void handle_conference_invite(Tox *tox, uint32_t friend_number, Tox_Conference_Type type, const uint8_t *cookie,
                                      size_t length, void *user_data)
 {
     State *state = (State *)user_data;
@@ -50,7 +50,7 @@ static void handle_conference_invite(Tox *tox, uint32_t friend_number, TOX_CONFE
     fprintf(stderr, "tox%u joining conference\n", state->id);
 
     {
-        TOX_ERR_CONFERENCE_JOIN err;
+        Tox_Err_Conference_Join err;
         state->conference = tox_conference_join(tox, friend_number, cookie, length, &err);
         ck_assert_msg(err == TOX_ERR_CONFERENCE_JOIN_OK, "failed to join a conference: err = %d", err);
         fprintf(stderr, "tox%u Joined conference %u\n", state->id, state->conference);
@@ -59,7 +59,7 @@ static void handle_conference_invite(Tox *tox, uint32_t friend_number, TOX_CONFE
 }
 
 static void handle_conference_message(Tox *tox, uint32_t conference_number, uint32_t peer_number,
-                                      TOX_MESSAGE_TYPE type, const uint8_t *message, size_t length, void *user_data)
+                                      Tox_Message_Type type, const uint8_t *message, size_t length, void *user_data)
 {
     State *state = (State *)user_data;
 
@@ -77,7 +77,7 @@ static void handle_conference_peer_list_changed(Tox *tox, uint32_t conference_nu
     fprintf(stderr, "handle_conference_peer_list_changed(#%u, %u, _)\n",
             state->id, conference_number);
 
-    TOX_ERR_CONFERENCE_PEER_QUERY err;
+    Tox_Err_Conference_Peer_Query err;
     uint32_t count = tox_conference_peer_count(tox, conference_number, &err);
 
     if (err != TOX_ERR_CONFERENCE_PEER_QUERY_OK) {
@@ -95,7 +95,7 @@ static void handle_conference_connected(Tox *tox, uint32_t conference_number, vo
 
     // We're tox2, so now we invite tox3.
     if (state->id == 2 && !state->invited_next) {
-        TOX_ERR_CONFERENCE_INVITE err;
+        Tox_Err_Conference_Invite err;
         tox_conference_invite(tox, 1, state->conference, &err);
         ck_assert_msg(err == TOX_ERR_CONFERENCE_INVITE_OK, "tox2 failed to invite tox3: err = %d", err);
 
@@ -190,7 +190,7 @@ int main(void)
 
     {
         // Create new conference, tox1 is the founder.
-        TOX_ERR_CONFERENCE_NEW err;
+        Tox_Err_Conference_New err;
         state1.conference = tox_conference_new(tox1, &err);
         state1.joined = true;
         ck_assert_msg(err == TOX_ERR_CONFERENCE_NEW_OK, "failed to create a conference: err = %d", err);
@@ -199,7 +199,7 @@ int main(void)
 
     {
         // Invite friend.
-        TOX_ERR_CONFERENCE_INVITE err;
+        Tox_Err_Conference_Invite err;
         tox_conference_invite(tox1, 0, state1.conference, &err);
         ck_assert_msg(err == TOX_ERR_CONFERENCE_INVITE_OK, "failed to invite a friend: err = %d", err);
         state1.invited_next = true;
@@ -232,7 +232,7 @@ int main(void)
 
     {
         fprintf(stderr, "tox1 sends a message to the group: \"hello!\"\n");
-        TOX_ERR_CONFERENCE_SEND_MESSAGE err;
+        Tox_Err_Conference_Send_Message err;
         tox_conference_send_message(tox1, state1.conference, TOX_MESSAGE_TYPE_NORMAL,
                                     (const uint8_t *)"hello!", 7, &err);
 
diff --git a/auto_tests/conference_test.c b/auto_tests/conference_test.c
index 824592c6..647b649d 100644
--- a/auto_tests/conference_test.c
+++ b/auto_tests/conference_test.c
@@ -33,7 +33,7 @@ typedef struct State {
 #include "run_auto_test.h"
 
 static void handle_self_connection_status(
-    Tox *tox, TOX_CONNECTION connection_status, void *user_data)
+    Tox *tox, Tox_Connection connection_status, void *user_data)
 {
     const State *state = (State *)user_data;
 
@@ -45,7 +45,7 @@ static void handle_self_connection_status(
 }
 
 static void handle_friend_connection_status(
-    Tox *tox, uint32_t friendnumber, TOX_CONNECTION connection_status, void *user_data)
+    Tox *tox, uint32_t friendnumber, Tox_Connection connection_status, void *user_data)
 {
     const State *state = (State *)user_data;
 
@@ -57,13 +57,13 @@ static void handle_friend_connection_status(
 }
 
 static void handle_conference_invite(
-    Tox *tox, uint32_t friendnumber, TOX_CONFERENCE_TYPE type,
+    Tox *tox, uint32_t friendnumber, Tox_Conference_Type type,
     const uint8_t *data, size_t length, void *user_data)
 {
     const State *state = (State *)user_data;
     ck_assert_msg(type == TOX_CONFERENCE_TYPE_TEXT, "tox #%u: wrong conference type: %d", state->index, type);
 
-    TOX_ERR_CONFERENCE_JOIN err;
+    Tox_Err_Conference_Join err;
     uint32_t g_num = tox_conference_join(tox, friendnumber, data, length, &err);
 
     ck_assert_msg(err == TOX_ERR_CONFERENCE_JOIN_OK, "tox #%u: error joining group: %d", state->index, err);
@@ -84,7 +84,7 @@ static void handle_conference_connected(
         return;
     }
 
-    TOX_ERR_CONFERENCE_INVITE err;
+    Tox_Err_Conference_Invite err;
     tox_conference_invite(tox, 1, 0, &err);
     ck_assert_msg(err == TOX_ERR_CONFERENCE_INVITE_OK, "tox #%u failed to invite next friend: err = %d", state->index, err);
     printf("tox #%u: invited next friend\n", state->index);
@@ -94,7 +94,7 @@ static void handle_conference_connected(
 static uint16_t num_recv;
 
 static void handle_conference_message(
-    Tox *tox, uint32_t groupnumber, uint32_t peernumber, TOX_MESSAGE_TYPE type,
+    Tox *tox, uint32_t groupnumber, uint32_t peernumber, Tox_Message_Type type,
     const uint8_t *message, size_t length, void *user_data)
 {
     if (length == (sizeof(GROUP_MESSAGE) - 1) && memcmp(message, GROUP_MESSAGE, sizeof(GROUP_MESSAGE) - 1) == 0) {
@@ -211,7 +211,7 @@ static void run_conference_tests(Tox **toxes, State *state)
         iterate_all_wait(NUM_GROUP_TOX, toxes, state, ITERATION_INTERVAL);
     }
 
-    TOX_ERR_CONFERENCE_SEND_MESSAGE err;
+    Tox_Err_Conference_Send_Message err;
     ck_assert_msg(
         tox_conference_send_message(
             toxes[random_u32() % NUM_GROUP_TOX], 0, TOX_MESSAGE_TYPE_NORMAL, (const uint8_t *)GROUP_MESSAGE,
@@ -301,7 +301,7 @@ static void test_many_group(Tox **toxes, State *state)
         iterate_all_wait(NUM_GROUP_TOX, toxes, state, ITERATION_INTERVAL);
 
         for (uint16_t i = 0; i < NUM_GROUP_TOX; ++i) {
-            TOX_ERR_CONFERENCE_PEER_QUERY err;
+            Tox_Err_Conference_Peer_Query err;
             uint32_t peer_count = tox_conference_peer_count(toxes[i], 0, &err);
 
             if (err != TOX_ERR_CONFERENCE_PEER_QUERY_OK) {
diff --git a/auto_tests/conference_two_test.c b/auto_tests/conference_two_test.c
index c6c3aa03..00c2d940 100644
--- a/auto_tests/conference_two_test.c
+++ b/auto_tests/conference_two_test.c
@@ -18,7 +18,7 @@ int main(void)
     Tox *tox1 = tox_new_log(nullptr, nullptr, &id);
 
     // Create two conferences and then exit.
-    TOX_ERR_CONFERENCE_NEW err;
+    Tox_Err_Conference_New err;
     tox_conference_new(tox1, &err);
     ck_assert_msg(err == TOX_ERR_CONFERENCE_NEW_OK, "failed to create conference 1: %d", err);
     tox_conference_new(tox1, &err);
diff --git a/auto_tests/encryptsave_test.c b/auto_tests/encryptsave_test.c
index bf7988e2..906bf3f8 100644
--- a/auto_tests/encryptsave_test.c
+++ b/auto_tests/encryptsave_test.c
@@ -70,7 +70,7 @@ static void test_save_friend(void)
     tox_get_savedata(tox1, data);
     size_t size2 = size + TOX_PASS_ENCRYPTION_EXTRA_LENGTH;
     VLA(uint8_t, enc_data, size2);
-    TOX_ERR_ENCRYPTION error1;
+    Tox_Err_Encryption error1;
     bool ret = tox_pass_encrypt(data, size, (const uint8_t *)"correcthorsebatterystaple", 25, enc_data, &error1);
     ck_assert_msg(ret, "failed to encrypted save: %d", error1);
     ck_assert_msg(tox_is_data_encrypted(enc_data), "magic number missing");
@@ -79,13 +79,13 @@ static void test_save_friend(void)
     tox_options_set_savedata_type(options, TOX_SAVEDATA_TYPE_TOX_SAVE);
     tox_options_set_savedata_data(options, enc_data, size2);
 
-    TOX_ERR_NEW err2;
+    Tox_Err_New err2;
     Tox *tox3 = tox_new_log(options, &err2, nullptr);
     ck_assert_msg(err2 == TOX_ERR_NEW_LOAD_ENCRYPTED, "wrong error! %d. should fail with %d", err2,
                   TOX_ERR_NEW_LOAD_ENCRYPTED);
     ck_assert_msg(tox3 == nullptr, "tox_new with error should return NULL");
     VLA(uint8_t, dec_data, size);
-    TOX_ERR_DECRYPTION err3;
+    Tox_Err_Decryption err3;
     ret = tox_pass_decrypt(enc_data, size2, (const uint8_t *)"correcthorsebatterystaple", 25, dec_data, &err3);
     ck_assert_msg(ret, "failed to decrypt save: %d", err3);
     tox_options_set_savedata_data(options, dec_data, size);
@@ -99,7 +99,7 @@ static void test_save_friend(void)
     size = tox_get_savedata_size(tox3);
     VLA(uint8_t, data2, size);
     tox_get_savedata(tox3, data2);
-    TOX_ERR_KEY_DERIVATION keyerr;
+    Tox_Err_Key_Derivation keyerr;
     Tox_Pass_Key *key = tox_pass_key_derive((const uint8_t *)"123qweasdzxc", 12, &keyerr);
     ck_assert_msg(key != nullptr, "pass key allocation failure");
     memcpy((uint8_t *)key, test_salt, TOX_PASS_SALT_LENGTH);
@@ -139,9 +139,9 @@ static void test_save_friend(void)
 
 static void test_keys(void)
 {
-    TOX_ERR_ENCRYPTION encerr;
-    TOX_ERR_DECRYPTION decerr;
-    TOX_ERR_KEY_DERIVATION keyerr;
+    Tox_Err_Encryption encerr;
+    Tox_Err_Decryption decerr;
+    Tox_Err_Key_Derivation keyerr;
     Tox_Pass_Key *key = tox_pass_key_derive((const uint8_t *)"123qweasdzxc", 12, &keyerr);
     ck_assert_msg(key != nullptr, "generic failure 1: %d", keyerr);
     const uint8_t *string = (const uint8_t *)"No Patrick, mayonnaise is not an instrument."; // 44
@@ -177,7 +177,7 @@ static void test_keys(void)
     ck_assert_msg(memcmp(out1, string, 44) == 0, "decryption 3 failed");
 
     uint8_t salt[TOX_PASS_SALT_LENGTH];
-    TOX_ERR_GET_SALT salt_err;
+    Tox_Err_Get_Salt salt_err;
     ck_assert_msg(tox_get_salt(encrypted, salt, &salt_err), "couldn't get salt");
     ck_assert_msg(salt_err == TOX_ERR_GET_SALT_OK, "get_salt returned an error");
     Tox_Pass_Key *key2 = tox_pass_key_derive_with_salt((const uint8_t *)"123qweasdzxc", 12, salt, &keyerr);
diff --git a/auto_tests/file_saving_test.c b/auto_tests/file_saving_test.c
index 1a345b23..19a21dfe 100644
--- a/auto_tests/file_saving_test.c
+++ b/auto_tests/file_saving_test.c
@@ -61,7 +61,7 @@ static void save_data_encrypted(void)
     size += TOX_PASS_ENCRYPTION_EXTRA_LENGTH;
     uint8_t *cipher = (uint8_t *)malloc(size);
 
-    TOX_ERR_ENCRYPTION eerr;
+    Tox_Err_Encryption eerr;
 
     ck_assert_msg(tox_pass_encrypt(clear, size - TOX_PASS_ENCRYPTION_EXTRA_LENGTH, (const uint8_t *)pphrase,
                                    strlen(pphrase), cipher,
@@ -90,7 +90,7 @@ static void load_data_decrypted(void)
     size_t read_value = fread(cipher, sizeof(*cipher), size, f);
     printf("Read read_value = %u of %u\n", (unsigned)read_value, (unsigned)size);
 
-    TOX_ERR_DECRYPTION derr;
+    Tox_Err_Decryption derr;
 
     ck_assert_msg(tox_pass_decrypt(cipher, size, (const uint8_t *)pphrase, strlen(pphrase), clear, &derr),
                   "Could not decrypt, error code %d.", derr);
@@ -101,7 +101,7 @@ static void load_data_decrypted(void)
 
     tox_options_set_savedata_data(options, clear, size);
 
-    TOX_ERR_NEW err;
+    Tox_Err_New err;
 
     Tox *t = tox_new_log(options, &err, nullptr);
 
diff --git a/auto_tests/file_transfer_test.c b/auto_tests/file_transfer_test.c
index 2e791662..ac1b046c 100644
--- a/auto_tests/file_transfer_test.c
+++ b/auto_tests/file_transfer_test.c
@@ -60,7 +60,7 @@ static void tox_file_receive(Tox *tox, uint32_t friend_number, uint32_t file_num
     if (filesize) {
         sending_pos = size_recv = 1337;
 
-        TOX_ERR_FILE_SEEK err_s;
+        Tox_Err_File_Seek err_s;
 
         ck_assert_msg(tox_file_seek(tox, friend_number, file_number, 1337, &err_s), "tox_file_seek error");
 
@@ -70,13 +70,13 @@ static void tox_file_receive(Tox *tox, uint32_t friend_number, uint32_t file_num
         sending_pos = size_recv = 0;
     }
 
-    TOX_ERR_FILE_CONTROL error;
+    Tox_Err_File_Control error;
 
     ck_assert_msg(tox_file_control(tox, friend_number, file_number, TOX_FILE_CONTROL_RESUME, &error),
                   "tox_file_control failed. %i", error);
     ++file_accepted;
 
-    TOX_ERR_FILE_SEEK err_s;
+    Tox_Err_File_Seek err_s;
 
     ck_assert_msg(!tox_file_seek(tox, friend_number, file_number, 1234, &err_s), "tox_file_seek no error");
 
@@ -84,7 +84,7 @@ static void tox_file_receive(Tox *tox, uint32_t friend_number, uint32_t file_num
 }
 
 static uint32_t sendf_ok;
-static void file_print_control(Tox *tox, uint32_t friend_number, uint32_t file_number, TOX_FILE_CONTROL control,
+static void file_print_control(Tox *tox, uint32_t friend_number, uint32_t file_number, Tox_File_Control control,
                                void *userdata)
 {
     /* First send file num is 0.*/
@@ -121,7 +121,7 @@ static void tox_file_chunk_request(Tox *tox, uint32_t friend_number, uint32_t fi
     VLA(uint8_t, f_data, length);
     memset(f_data, sending_num, length);
 
-    TOX_ERR_FILE_SEND_CHUNK error;
+    Tox_Err_File_Send_Chunk error;
     tox_file_send_chunk(tox, friend_number, file_number, position, f_data, length, &error);
 
 
@@ -159,7 +159,7 @@ static void file_transfer_test(void)
     printf("Starting test: few_clients\n");
     uint32_t index[] = { 1, 2, 3 };
     long long unsigned int cur_time = time(nullptr);
-    TOX_ERR_NEW t_n_error;
+    Tox_Err_New t_n_error;
     Tox *tox1 = tox_new_log(nullptr, &t_n_error, &index[0]);
     ck_assert_msg(t_n_error == TOX_ERR_NEW_OK, "wrong error");
     Tox *tox2 = tox_new_log(nullptr, &t_n_error, &index[1]);
@@ -218,7 +218,7 @@ static void file_transfer_test(void)
                                   sizeof("Gentoo.exe"), nullptr);
     ck_assert_msg(fnum != UINT32_MAX, "tox_new_file_sender fail");
 
-    TOX_ERR_FILE_GET gfierr;
+    Tox_Err_File_Get gfierr;
     ck_assert_msg(!tox_file_get_file_id(tox2, 1, fnum, file_cmp_id, &gfierr), "tox_file_get_file_id didn't fail");
     ck_assert_msg(gfierr == TOX_ERR_FILE_GET_FRIEND_NOT_FOUND, "wrong error");
     ck_assert_msg(!tox_file_get_file_id(tox2, 0, fnum + 1, file_cmp_id, &gfierr), "tox_file_get_file_id didn't fail");
diff --git a/auto_tests/invalid_tcp_proxy_test.c b/auto_tests/invalid_tcp_proxy_test.c
index b0d60f2d..45290a43 100644
--- a/auto_tests/invalid_tcp_proxy_test.c
+++ b/auto_tests/invalid_tcp_proxy_test.c
@@ -41,7 +41,7 @@ int main(void)
         tox_iterate(tox, nullptr);
         c_sleep(ITERATION_INTERVAL);
         // None of the iterations should have a connection.
-        const TOX_CONNECTION status = tox_self_get_connection_status(tox);
+        const Tox_Connection status = tox_self_get_connection_status(tox);
         ck_assert_msg(status == TOX_CONNECTION_NONE,
                       "unexpectedly got a connection (%d)", status);
     }
diff --git a/auto_tests/invalid_udp_proxy_test.c b/auto_tests/invalid_udp_proxy_test.c
index 96c8197b..1e84e451 100644
--- a/auto_tests/invalid_udp_proxy_test.c
+++ b/auto_tests/invalid_udp_proxy_test.c
@@ -41,7 +41,7 @@ int main(void)
         tox_iterate(tox, nullptr);
         c_sleep(ITERATION_INTERVAL);
         // None of the iterations should have a connection.
-        const TOX_CONNECTION status = tox_self_get_connection_status(tox);
+        const Tox_Connection status = tox_self_get_connection_status(tox);
         ck_assert_msg(status == TOX_CONNECTION_NONE,
                       "unexpectedly got a connection (%d)", status);
     }
diff --git a/auto_tests/overflow_recvq_test.c b/auto_tests/overflow_recvq_test.c
index 3f7561e1..205dbb11 100644
--- a/auto_tests/overflow_recvq_test.c
+++ b/auto_tests/overflow_recvq_test.c
@@ -18,7 +18,7 @@ typedef struct State {
 
 #define NUM_MSGS 40000
 
-static void handle_friend_message(Tox *tox, uint32_t friend_number, TOX_MESSAGE_TYPE type,
+static void handle_friend_message(Tox *tox, uint32_t friend_number, Tox_Message_Type type,
                                   const uint8_t *message, size_t length, void *user_data)
 {
     State *state = (State *)user_data;
@@ -36,7 +36,7 @@ static void net_crypto_overflow_test(Tox **toxes, State *state)
             uint8_t message[128] = {0};
             snprintf((char *)message, sizeof(message), "%u-%u", tox_index, i);
 
-            TOX_ERR_FRIEND_SEND_MESSAGE err;
+            Tox_Err_Friend_Send_Message err;
             tox_friend_send_message(toxes[tox_index], 0, TOX_MESSAGE_TYPE_NORMAL, message, sizeof message, &err);
 
             if (err == TOX_ERR_FRIEND_SEND_MESSAGE_SENDQ) {
diff --git a/auto_tests/overflow_sendq_test.c b/auto_tests/overflow_sendq_test.c
index e67da1cf..9601c876 100644
--- a/auto_tests/overflow_sendq_test.c
+++ b/auto_tests/overflow_sendq_test.c
@@ -22,7 +22,7 @@ static void net_crypto_overflow_test(Tox **toxes, State *state)
     bool errored = false;
 
     for (uint32_t i = 0; i < NUM_MSGS; i++) {
-        TOX_ERR_FRIEND_SEND_MESSAGE err;
+        Tox_Err_Friend_Send_Message err;
         tox_friend_send_message(toxes[0], 0, TOX_MESSAGE_TYPE_NORMAL, message, sizeof message, &err);
 
         if (err != TOX_ERR_FRIEND_SEND_MESSAGE_OK) {
diff --git a/auto_tests/save_friend_test.c b/auto_tests/save_friend_test.c
index 07753127..210dd2bf 100644
--- a/auto_tests/save_friend_test.c
+++ b/auto_tests/save_friend_test.c
@@ -22,7 +22,7 @@ struct test_data {
     bool received_status_message;
 };
 
-static void set_random(Tox *m, bool (*setter)(Tox *, const uint8_t *, size_t, TOX_ERR_SET_INFO *), size_t length)
+static void set_random(Tox *m, bool (*setter)(Tox *, const uint8_t *, size_t, Tox_Err_Set_Info *), size_t length)
 {
     VLA(uint8_t, text, length);
     uint32_t i;
diff --git a/auto_tests/save_load_test.c b/auto_tests/save_load_test.c
index 9c171602..cdaf3d3d 100644
--- a/auto_tests/save_load_test.c
+++ b/auto_tests/save_load_test.c
@@ -24,7 +24,7 @@ static void accept_friend_request(Tox *m, const uint8_t *public_key, const uint8
 }
 
 static unsigned int connected_t1;
-static void tox_connection_status(Tox *tox, TOX_CONNECTION connection_status, void *user_data)
+static void tox_connection_status(Tox *tox, Tox_Connection connection_status, void *user_data)
 {
     if (connected_t1 && !connection_status) {
         ck_abort_msg("Tox went offline");
diff --git a/auto_tests/send_message_test.c b/auto_tests/send_message_test.c
index 5346dc9e..8e41006b 100644
--- a/auto_tests/send_message_test.c
+++ b/auto_tests/send_message_test.c
@@ -21,7 +21,7 @@ typedef struct State {
 #define MESSAGE_FILLER 'G'
 
 static void message_callback(
-    Tox *m, uint32_t friendnumber, TOX_MESSAGE_TYPE type,
+    Tox *m, uint32_t friendnumber, Tox_Message_Type type,
     const uint8_t *string, size_t length, void *userdata)
 {
     State *state = (State *)userdata;
@@ -45,7 +45,7 @@ static void send_message_test(Tox **toxes, State *state)
     uint8_t msgs[TOX_MAX_MESSAGE_LENGTH + 1];
     memset(msgs, MESSAGE_FILLER, sizeof(msgs));
 
-    TOX_ERR_FRIEND_SEND_MESSAGE errm;
+    Tox_Err_Friend_Send_Message errm;
     tox_friend_send_message(toxes[0], 0, TOX_MESSAGE_TYPE_NORMAL, msgs, TOX_MAX_MESSAGE_LENGTH + 1, &errm);
     ck_assert_msg(errm == TOX_ERR_FRIEND_SEND_MESSAGE_TOO_LONG, "TOX_MAX_MESSAGE_LENGTH is too small? error=%d", errm);
 
diff --git a/auto_tests/set_name_test.c b/auto_tests/set_name_test.c
index 1e35aa30..4f046e90 100644
--- a/auto_tests/set_name_test.c
+++ b/auto_tests/set_name_test.c
@@ -69,7 +69,7 @@ static void test_set_name(void)
     printf("tox clients connected took %lu seconds\n", (unsigned long)(time(nullptr) - con_time));
 
     tox_callback_friend_name(tox2, nickchange_callback);
-    TOX_ERR_SET_INFO err_n;
+    Tox_Err_Set_Info err_n;
     bool ret = tox_self_set_name(tox1, (const uint8_t *)NICKNAME, sizeof(NICKNAME), &err_n);
     ck_assert_msg(ret && err_n == TOX_ERR_SET_INFO_OK, "tox_self_set_name failed because %u\n", err_n);
 
diff --git a/auto_tests/set_status_message_test.c b/auto_tests/set_status_message_test.c
index 1ef8ae56..9cf26754 100644
--- a/auto_tests/set_status_message_test.c
+++ b/auto_tests/set_status_message_test.c
@@ -72,7 +72,7 @@ static void test_set_status_message(void)
 
     printf("tox clients connected took %lu seconds\n", (unsigned long)(time(nullptr) - con_time));
 
-    TOX_ERR_SET_INFO err_n;
+    Tox_Err_Set_Info err_n;
     tox_callback_friend_status_message(tox2, status_callback);
     bool ret = tox_self_set_status_message(tox1, (const uint8_t *)STATUS_MESSAGE, sizeof(STATUS_MESSAGE),
                                            &err_n);
diff --git a/auto_tests/tcp_relay_test.c b/auto_tests/tcp_relay_test.c
index f2035f35..79387291 100644
--- a/auto_tests/tcp_relay_test.c
+++ b/auto_tests/tcp_relay_test.c
@@ -36,7 +36,7 @@ int main(void)
         c_sleep(ITERATION_INTERVAL);
     } while (tox_self_get_connection_status(tox_tcp) == TOX_CONNECTION_NONE);
 
-    const TOX_CONNECTION status = tox_self_get_connection_status(tox_tcp);
+    const Tox_Connection status = tox_self_get_connection_status(tox_tcp);
     ck_assert_msg(status == TOX_CONNECTION_TCP,
                   "expected TCP connection, but got %d", status);
     printf("Connection (TCP): %d\n", status);
diff --git a/auto_tests/tox_many_tcp_test.c b/auto_tests/tox_many_tcp_test.c
index e09ed8fb..77eef929 100644
--- a/auto_tests/tox_many_tcp_test.c
+++ b/auto_tests/tox_many_tcp_test.c
@@ -62,7 +62,7 @@ START_TEST(test_many_clients_tcp)
         tox_callback_friend_request(toxes[i], accept_friend_request);
         uint8_t dpk[TOX_PUBLIC_KEY_SIZE];
         tox_self_get_dht_id(toxes[0], dpk);
-        TOX_ERR_BOOTSTRAP error = TOX_ERR_BOOTSTRAP_OK;
+        Tox_Err_Bootstrap error = TOX_ERR_BOOTSTRAP_OK;
         ck_assert_msg(tox_add_tcp_relay(toxes[i], TOX_LOCALHOST, TCP_RELAY_PORT, dpk, &error), "add relay error, %u, %d", i,
                       error);
         uint16_t first_port = tox_self_get_udp_port(toxes[0], nullptr);
@@ -91,7 +91,7 @@ loop_top:
 
         tox_self_get_address(toxes[pairs[i].tox1], address);
 
-        TOX_ERR_FRIEND_ADD test;
+        Tox_Err_Friend_Add test;
         uint32_t num = tox_friend_add(toxes[pairs[i].tox2], address, (const uint8_t *)"Gentoo", 7, &test);
 
         if (test == TOX_ERR_FRIEND_ADD_ALREADY_SENT) {
@@ -185,7 +185,7 @@ loop_top:
 
         tox_self_get_address(toxes[pairs[i].tox1], address);
 
-        TOX_ERR_FRIEND_ADD test;
+        Tox_Err_Friend_Add test;
         uint32_t num = tox_friend_add(toxes[pairs[i].tox2], address, (const uint8_t *)"Gentoo", 7, &test);
 
         if (test == TOX_ERR_FRIEND_ADD_ALREADY_SENT) {
diff --git a/auto_tests/tox_many_test.c b/auto_tests/tox_many_test.c
index 6a2f5485..59ade859 100644
--- a/auto_tests/tox_many_test.c
+++ b/auto_tests/tox_many_test.c
@@ -68,7 +68,7 @@ loop_top:
 
         tox_self_get_address(toxes[pairs[i].tox1], address);
 
-        TOX_ERR_FRIEND_ADD test;
+        Tox_Err_Friend_Add test;
         uint32_t num = tox_friend_add(toxes[pairs[i].tox2], address, (const uint8_t *)"Gentoo", 7, &test);
 
         if (test == TOX_ERR_FRIEND_ADD_ALREADY_SENT) {
diff --git a/auto_tests/tox_one_test.c b/auto_tests/tox_one_test.c
index 28f18c29..62486acb 100644
--- a/auto_tests/tox_one_test.c
+++ b/auto_tests/tox_one_test.c
@@ -44,7 +44,7 @@ static void test_one(void)
 
     uint8_t address[TOX_ADDRESS_SIZE];
     tox_self_get_address(tox1, address);
-    TOX_ERR_FRIEND_ADD error;
+    Tox_Err_Friend_Add error;
     uint32_t ret = tox_friend_add(tox1, address, (const uint8_t *)"m", 1, &error);
     ck_assert_msg(ret == UINT32_MAX && error == TOX_ERR_FRIEND_ADD_OWN_KEY, "Adding own address worked.");
 
@@ -82,7 +82,7 @@ static void test_one(void)
     tox_get_savedata(tox1, data);
 
     tox_kill(tox2);
-    TOX_ERR_NEW err_n;
+    Tox_Err_New err_n;
 
     struct Tox_Options *options = tox_options_new(nullptr);
     tox_options_set_savedata_type(options, TOX_SAVEDATA_TYPE_TOX_SAVE);
diff --git a/auto_tests/toxav_basic_test.c b/auto_tests/toxav_basic_test.c
index 048b54a5..5c6daefa 100644
--- a/auto_tests/toxav_basic_test.c
+++ b/auto_tests/toxav_basic_test.c
@@ -28,7 +28,7 @@
 
 
 #define ck_assert_call_control(a, b, c) do { \
-    TOXAV_ERR_CALL_CONTROL cc_err; \
+    Toxav_Err_Call_Control cc_err; \
     bool ok = toxav_call_control(a, b, c, &cc_err); \
     if (!ok) { \
         printf("toxav_call_control returned error %d\n", cc_err); \
@@ -113,7 +113,7 @@ static void regular_call_flow(
     clear_call_control(AliceCC);
     clear_call_control(BobCC);
 
-    TOXAV_ERR_CALL call_err;
+    Toxav_Err_Call call_err;
     toxav_call(AliceAV, 0, a_br, v_br, &call_err);
 
     if (call_err != TOXAV_ERR_CALL_OK) {
@@ -125,7 +125,7 @@ static void regular_call_flow(
 
     do {
         if (BobCC->incoming) {
-            TOXAV_ERR_ANSWER answer_err;
+            Toxav_Err_Answer answer_err;
             toxav_answer(BobAV, 0, a_br, v_br, &answer_err);
 
             if (answer_err != TOXAV_ERR_ANSWER_OK) {
@@ -137,7 +137,7 @@ static void regular_call_flow(
         } else { /* TODO(mannol): rtp */
             if (time(nullptr) - start_time >= 1) {
 
-                TOXAV_ERR_CALL_CONTROL cc_err;
+                Toxav_Err_Call_Control cc_err;
                 toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_CANCEL, &cc_err);
 
                 if (cc_err != TOXAV_ERR_CALL_CONTROL_OK) {
@@ -162,7 +162,7 @@ static void test_av_flows(void)
     CallControl AliceCC, BobCC;
 
     {
-        TOX_ERR_NEW error;
+        Tox_Err_New error;
 
         bootstrap = tox_new_log(nullptr, &error, &index[0]);
         ck_assert(error == TOX_ERR_NEW_OK);
@@ -215,7 +215,7 @@ static void test_av_flows(void)
 
 
     {
-        TOXAV_ERR_NEW error;
+        Toxav_Err_New error;
         AliceAV = toxav_new(Alice, &error);
         ck_assert(error == TOXAV_ERR_NEW_OK);
 
@@ -261,7 +261,7 @@ static void test_av_flows(void)
         clear_call_control(&BobCC);
 
         {
-            TOXAV_ERR_CALL rc;
+            Toxav_Err_Call rc;
             toxav_call(AliceAV, 0, 48, 0, &rc);
 
             if (rc != TOXAV_ERR_CALL_OK) {
@@ -276,7 +276,7 @@ static void test_av_flows(void)
 
         /* Reject */
         {
-            TOXAV_ERR_CALL_CONTROL rc;
+            Toxav_Err_Call_Control rc;
             toxav_call_control(BobAV, 0, TOXAV_CALL_CONTROL_CANCEL, &rc);
 
             if (rc != TOXAV_ERR_CALL_CONTROL_OK) {
@@ -299,7 +299,7 @@ static void test_av_flows(void)
         clear_call_control(&BobCC);
 
         {
-            TOXAV_ERR_CALL rc;
+            Toxav_Err_Call rc;
             toxav_call(AliceAV, 0, 48, 0, &rc);
 
             if (rc != TOXAV_ERR_CALL_OK) {
@@ -314,7 +314,7 @@ static void test_av_flows(void)
 
         /* Cancel */
         {
-            TOXAV_ERR_CALL_CONTROL rc;
+            Toxav_Err_Call_Control rc;
             toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_CANCEL, &rc);
 
             if (rc != TOXAV_ERR_CALL_CONTROL_OK) {
@@ -339,7 +339,7 @@ static void test_av_flows(void)
 
         /* Assume sending audio and video */
         {
-            TOXAV_ERR_CALL rc;
+            Toxav_Err_Call rc;
             toxav_call(AliceAV, 0, 48, 1000, &rc);
 
             if (rc != TOXAV_ERR_CALL_OK) {
@@ -361,7 +361,7 @@ static void test_av_flows(void)
         ck_assert(!toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_SHOW_VIDEO, nullptr));
 
         {
-            TOXAV_ERR_ANSWER rc;
+            Toxav_Err_Answer rc;
             toxav_answer(BobAV, 0, 48, 4000, &rc);
 
             if (rc != TOXAV_ERR_ANSWER_OK) {
@@ -406,7 +406,7 @@ static void test_av_flows(void)
         ck_assert(BobCC.state & TOXAV_FRIEND_CALL_STATE_ACCEPTING_V);
 
         {
-            TOXAV_ERR_CALL_CONTROL rc;
+            Toxav_Err_Call_Control rc;
             toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_CANCEL, &rc);
 
             if (rc != TOXAV_ERR_CALL_CONTROL_OK) {
@@ -429,7 +429,7 @@ static void test_av_flows(void)
 
         /* Assume sending audio and video */
         {
-            TOXAV_ERR_CALL rc;
+            Toxav_Err_Call rc;
             toxav_call(AliceAV, 0, 48, 0, &rc);
 
             if (rc != TOXAV_ERR_CALL_OK) {
@@ -443,7 +443,7 @@ static void test_av_flows(void)
         } while (!BobCC.incoming);
 
         {
-            TOXAV_ERR_ANSWER rc;
+            Toxav_Err_Answer rc;
             toxav_answer(BobAV, 0, 48, 0, &rc);
 
             if (rc != TOXAV_ERR_ANSWER_OK) {
@@ -474,7 +474,7 @@ static void test_av_flows(void)
         ck_assert(!(BobCC.state & TOXAV_FRIEND_CALL_STATE_SENDING_A));
 
         {
-            TOXAV_ERR_CALL_CONTROL rc;
+            Toxav_Err_Call_Control rc;
             toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_CANCEL, &rc);
 
             if (rc != TOXAV_ERR_CALL_CONTROL_OK) {
@@ -497,7 +497,7 @@ static void test_av_flows(void)
 
         /* Assume sending audio and video */
         {
-            TOXAV_ERR_CALL rc;
+            Toxav_Err_Call rc;
             toxav_call(AliceAV, 0, 48, 0, &rc);
 
             if (rc != TOXAV_ERR_CALL_OK) {
@@ -511,7 +511,7 @@ static void test_av_flows(void)
         } while (!BobCC.incoming);
 
         {
-            TOXAV_ERR_ANSWER rc;
+            Toxav_Err_Answer rc;
             toxav_answer(BobAV, 0, 48, 0, &rc);
 
             if (rc != TOXAV_ERR_ANSWER_OK) {
@@ -534,7 +534,7 @@ static void test_av_flows(void)
         iterate_tox(bootstrap, Alice, Bob);
 
         {
-            TOXAV_ERR_CALL_CONTROL rc;
+            Toxav_Err_Call_Control rc;
             toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_CANCEL, &rc);
 
             if (rc != TOXAV_ERR_CALL_CONTROL_OK) {
diff --git a/auto_tests/toxav_many_test.c b/auto_tests/toxav_many_test.c
index 1cdc0733..1573bac9 100644
--- a/auto_tests/toxav_many_test.c
+++ b/auto_tests/toxav_many_test.c
@@ -82,7 +82,7 @@ static void t_accept_friend_request_cb(Tox *m, const uint8_t *public_key, const
  */
 static ToxAV *setup_av_instance(Tox *tox, CallControl *CC)
 {
-    TOXAV_ERR_NEW error;
+    Toxav_Err_New error;
 
     ToxAV *av = toxav_new(tox, &error);
     ck_assert(error == TOXAV_ERR_NEW_OK);
@@ -107,7 +107,7 @@ static void *call_thread(void *pd)
     memset(BobCC, 0, sizeof(CallControl));
 
     { /* Call */
-        TOXAV_ERR_CALL rc;
+        Toxav_Err_Call rc;
         toxav_call(AliceAV, friend_number, 48, 3000, &rc);
 
         if (rc != TOXAV_ERR_CALL_OK) {
@@ -121,7 +121,7 @@ static void *call_thread(void *pd)
     } while (!BobCC->incoming);
 
     { /* Answer */
-        TOXAV_ERR_ANSWER rc;
+        Toxav_Err_Answer rc;
         toxav_answer(BobAV, 0, 8, 500, &rc);
 
         if (rc != TOXAV_ERR_ANSWER_OK) {
@@ -153,7 +153,7 @@ static void *call_thread(void *pd)
     } while (time(nullptr) - start_time < 4);
 
     { /* Hangup */
-        TOXAV_ERR_CALL_CONTROL rc;
+        Toxav_Err_Call_Control rc;
         toxav_call_control(AliceAV, friend_number, TOXAV_CALL_CONTROL_CANCEL, &rc);
 
         if (rc != TOXAV_ERR_CALL_CONTROL_OK) {
@@ -184,7 +184,7 @@ static void test_av_three_calls(void)
     CallControl AliceCC[3], BobsCC[3];
 
     {
-        TOX_ERR_NEW error;
+        Tox_Err_New error;
 
         bootstrap = tox_new_log(nullptr, &error, &index[0]);
         ck_assert(error == TOX_ERR_NEW_OK);
diff --git a/auto_tests/typing_test.c b/auto_tests/typing_test.c
index 60968876..54577420 100644
--- a/auto_tests/typing_test.c
+++ b/auto_tests/typing_test.c
@@ -48,7 +48,7 @@ static void test_typing(Tox **toxes, State *state)
         iterate_all_wait(2, toxes, state, 200);
     } while (state[1].friend_is_typing);
 
-    TOX_ERR_FRIEND_QUERY err_t;
+    Tox_Err_Friend_Query err_t;
     ck_assert_msg(tox_friend_get_typing(toxes[1], 0, &err_t) == 0,
                   "tox_friend_get_typing should have returned false, but it didn't");
     ck_assert_msg(err_t == TOX_ERR_FRIEND_QUERY_OK, "tox_friend_get_typing call did not return correct error");