mudbase 1.0.0 → 1.1.4

data/docs/ChatApi.md

@@ -4,23 +4,23 @@ All URIs are relative to *https://cloud.mudbase.dev*
 
 | Method | HTTP request | Description |
 | ------ | ------------ | ----------- |
-| [**chat_add_participant**](ChatApi.md#chat_add_participant) | **POST** /api/chat/projects/{projectId}/chats/{chatId}/participants | Add participant to chat |
-| [**chat_add_reaction**](ChatApi.md#chat_add_reaction) | **POST** /api/chat/projects/{projectId}/chats/{chatId}/messages/{messageId}/reactions | Add reaction to message |
-| [**chat_create**](ChatApi.md#chat_create) | **POST** /api/chat/projects/{projectId}/chats | Create new chat |
-| [**chat_delete_message**](ChatApi.md#chat_delete_message) | **DELETE** /api/chat/projects/{projectId}/chats/{chatId}/messages/{messageId} | Delete message |
-| [**chat_edit_message**](ChatApi.md#chat_edit_message) | **PATCH** /api/chat/projects/{projectId}/chats/{chatId}/messages/{messageId} | Edit message |
-| [**chat_get**](ChatApi.md#chat_get) | **GET** /api/chat/projects/{projectId}/chats/{chatId} | Get chat details |
-| [**chat_get_messages**](ChatApi.md#chat_get_messages) | **GET** /api/chat/projects/{projectId}/chats/{chatId}/messages | Get chat messages |
-| [**chat_list**](ChatApi.md#chat_list) | **GET** /api/chat/projects/{projectId}/chats | Get user chats |
-| [**chat_mark_as_read**](ChatApi.md#chat_mark_as_read) | **POST** /api/chat/projects/{projectId}/chats/{chatId}/messages/read | Mark messages as read |
-| [**chat_remove_participant**](ChatApi.md#chat_remove_participant) | **DELETE** /api/chat/projects/{projectId}/chats/{chatId}/participants | Remove participant from chat |
-| [**chat_remove_reaction**](ChatApi.md#chat_remove_reaction) | **DELETE** /api/chat/projects/{projectId}/chats/{chatId}/messages/{messageId}/reactions | Remove reaction from message |
-| [**chat_send_message**](ChatApi.md#chat_send_message) | **POST** /api/chat/projects/{projectId}/chats/{chatId}/messages | Send message |
+| [**add_participant**](ChatApi.md#add_participant) | **POST** /api/chat/projects/{projectId}/chats/{chatId}/participants | Add participant to chat |
+| [**add_reaction**](ChatApi.md#add_reaction) | **POST** /api/chat/projects/{projectId}/chats/{chatId}/messages/{messageId}/reactions | Add reaction to message |
+| [**create_chat**](ChatApi.md#create_chat) | **POST** /api/chat/projects/{projectId}/chats | Create new chat |
+| [**delete_message**](ChatApi.md#delete_message) | **DELETE** /api/chat/projects/{projectId}/chats/{chatId}/messages/{messageId} | Delete message |
+| [**edit_message**](ChatApi.md#edit_message) | **PATCH** /api/chat/projects/{projectId}/chats/{chatId}/messages/{messageId} | Edit message |
+| [**get_chat_details**](ChatApi.md#get_chat_details) | **GET** /api/chat/projects/{projectId}/chats/{chatId} | Get chat details |
+| [**get_chat_messages**](ChatApi.md#get_chat_messages) | **GET** /api/chat/projects/{projectId}/chats/{chatId}/messages | Get chat messages |
+| [**get_user_chats**](ChatApi.md#get_user_chats) | **GET** /api/chat/projects/{projectId}/chats | Get user chats |
+| [**mark_messages_as_read**](ChatApi.md#mark_messages_as_read) | **POST** /api/chat/projects/{projectId}/chats/{chatId}/messages/read | Mark messages as read |
+| [**remove_participant**](ChatApi.md#remove_participant) | **DELETE** /api/chat/projects/{projectId}/chats/{chatId}/participants | Remove participant from chat |
+| [**remove_reaction**](ChatApi.md#remove_reaction) | **DELETE** /api/chat/projects/{projectId}/chats/{chatId}/messages/{messageId}/reactions | Remove reaction from message |
+| [**send_message**](ChatApi.md#send_message) | **POST** /api/chat/projects/{projectId}/chats/{chatId}/messages | Send message |
 
 
-## chat_add_participant
+## add_participant
 
-> <ChatAddParticipant200Response> chat_add_participant(project_id, chat_id, chat_add_participant_request)
+> <AddParticipant200Response> add_participant(project_id, chat_id, add_participant_request)
 
 Add participant to chat
 
@@ -33,39 +33,39 @@ require 'time'
 require 'mudbase'
 # setup authorization
 Mudbase.configure do |config|
-  # Configure Bearer authorization (JWT): BearerToken
+  # Configure Bearer authorization (JWT): ProjectBearerAuth
   config.access_token = 'YOUR_BEARER_TOKEN'
 end
 
 api_instance = Mudbase::ChatApi.new
 project_id = 'project_id_example' # String | Project ID.
 chat_id = 'chat_id_example' # String | Chat ID.
-chat_add_participant_request = Mudbase::ChatAddParticipantRequest.new({user_id: 'user_id_example'}) # ChatAddParticipantRequest | User ID to add and optional role (admin, member).
+add_participant_request = Mudbase::AddParticipantRequest.new({user_id: 'user_id_example'}) # AddParticipantRequest | User ID to add and optional role (admin, member).
 
 begin
   # Add participant to chat
-  result = api_instance.chat_add_participant(project_id, chat_id, chat_add_participant_request)
+  result = api_instance.add_participant(project_id, chat_id, add_participant_request)
   p result
 rescue Mudbase::ApiError => e
-  puts "Error when calling ChatApi->chat_add_participant: #{e}"
+  puts "Error when calling ChatApi->add_participant: #{e}"
 end
 ```
 
-#### Using the chat_add_participant_with_http_info variant
+#### Using the add_participant_with_http_info variant
 
 This returns an Array which contains the response data, status code and headers.
 
-> <Array(<ChatAddParticipant200Response>, Integer, Hash)> chat_add_participant_with_http_info(project_id, chat_id, chat_add_participant_request)
+> <Array(<AddParticipant200Response>, Integer, Hash)> add_participant_with_http_info(project_id, chat_id, add_participant_request)
 
 ```ruby
 begin
   # Add participant to chat
-  data, status_code, headers = api_instance.chat_add_participant_with_http_info(project_id, chat_id, chat_add_participant_request)
+  data, status_code, headers = api_instance.add_participant_with_http_info(project_id, chat_id, add_participant_request)
   p status_code # => 2xx
   p headers # => { ... }
-  p data # => <ChatAddParticipant200Response>
+  p data # => <AddParticipant200Response>
 rescue Mudbase::ApiError => e
-  puts "Error when calling ChatApi->chat_add_participant_with_http_info: #{e}"
+  puts "Error when calling ChatApi->add_participant_with_http_info: #{e}"
 end
 ```
 
@@ -75,15 +75,15 @@ end
 | ---- | ---- | ----------- | ----- |
 | **project_id** | **String** | Project ID. |  |
 | **chat_id** | **String** | Chat ID. |  |
-| **chat_add_participant_request** | [**ChatAddParticipantRequest**](ChatAddParticipantRequest.md) | User ID to add and optional role (admin, member). |  |
+| **add_participant_request** | [**AddParticipantRequest**](AddParticipantRequest.md) | User ID to add and optional role (admin, member). |  |
 
 ### Return type
 
-[**ChatAddParticipant200Response**](ChatAddParticipant200Response.md)
+[**AddParticipant200Response**](AddParticipant200Response.md)
 
 ### Authorization
 
-[BearerToken](../README.md#BearerToken)
+[ProjectBearerAuth](../README.md#ProjectBearerAuth)
 
 ### HTTP request headers
 
@@ -91,9 +91,9 @@ end
 - **Accept**: application/json
 
 
-## chat_add_reaction
+## add_reaction
 
-> <ChatAddReaction200Response> chat_add_reaction(project_id, chat_id, message_id, chat_add_reaction_request)
+> <AddReaction200Response> add_reaction(project_id, chat_id, message_id, add_reaction_request)
 
 Add reaction to message
 
@@ -106,7 +106,7 @@ require 'time'
 require 'mudbase'
 # setup authorization
 Mudbase.configure do |config|
-  # Configure Bearer authorization (JWT): BearerToken
+  # Configure Bearer authorization (JWT): ProjectBearerAuth
   config.access_token = 'YOUR_BEARER_TOKEN'
 end
 
@@ -114,32 +114,32 @@ api_instance = Mudbase::ChatApi.new
 project_id = 'project_id_example' # String | Project ID.
 chat_id = 'chat_id_example' # String | Chat ID.
 message_id = 'message_id_example' # String | Message ID.
-chat_add_reaction_request = Mudbase::ChatAddReactionRequest.new({emoji: 'emoji_example'}) # ChatAddReactionRequest | Emoji reaction (e.g. 👍, ❤️).
+add_reaction_request = Mudbase::AddReactionRequest.new({emoji: 'emoji_example'}) # AddReactionRequest | Emoji reaction (e.g. 👍, ❤️).
 
 begin
   # Add reaction to message
-  result = api_instance.chat_add_reaction(project_id, chat_id, message_id, chat_add_reaction_request)
+  result = api_instance.add_reaction(project_id, chat_id, message_id, add_reaction_request)
   p result
 rescue Mudbase::ApiError => e
-  puts "Error when calling ChatApi->chat_add_reaction: #{e}"
+  puts "Error when calling ChatApi->add_reaction: #{e}"
 end
 ```
 
-#### Using the chat_add_reaction_with_http_info variant
+#### Using the add_reaction_with_http_info variant
 
 This returns an Array which contains the response data, status code and headers.
 
-> <Array(<ChatAddReaction200Response>, Integer, Hash)> chat_add_reaction_with_http_info(project_id, chat_id, message_id, chat_add_reaction_request)
+> <Array(<AddReaction200Response>, Integer, Hash)> add_reaction_with_http_info(project_id, chat_id, message_id, add_reaction_request)
 
 ```ruby
 begin
   # Add reaction to message
-  data, status_code, headers = api_instance.chat_add_reaction_with_http_info(project_id, chat_id, message_id, chat_add_reaction_request)
+  data, status_code, headers = api_instance.add_reaction_with_http_info(project_id, chat_id, message_id, add_reaction_request)
   p status_code # => 2xx
   p headers # => { ... }
-  p data # => <ChatAddReaction200Response>
+  p data # => <AddReaction200Response>
 rescue Mudbase::ApiError => e
-  puts "Error when calling ChatApi->chat_add_reaction_with_http_info: #{e}"
+  puts "Error when calling ChatApi->add_reaction_with_http_info: #{e}"
 end
 ```
 
@@ -150,15 +150,15 @@ end
 | **project_id** | **String** | Project ID. |  |
 | **chat_id** | **String** | Chat ID. |  |
 | **message_id** | **String** | Message ID. |  |
-| **chat_add_reaction_request** | [**ChatAddReactionRequest**](ChatAddReactionRequest.md) | Emoji reaction (e.g. 👍, ❤️). |  |
+| **add_reaction_request** | [**AddReactionRequest**](AddReactionRequest.md) | Emoji reaction (e.g. 👍, ❤️). |  |
 
 ### Return type
 
-[**ChatAddReaction200Response**](ChatAddReaction200Response.md)
+[**AddReaction200Response**](AddReaction200Response.md)
 
 ### Authorization
 
-[BearerToken](../README.md#BearerToken)
+[ProjectBearerAuth](../README.md#ProjectBearerAuth)
 
 ### HTTP request headers
 
@@ -166,9 +166,9 @@ end
 - **Accept**: application/json
 
 
-## chat_create
+## create_chat
 
-> <ChatCreate201Response> chat_create(project_id, chat_create_request)
+> <CreateChat201Response> create_chat(project_id, create_chat_request)
 
 Create new chat
 
@@ -181,38 +181,38 @@ require 'time'
 require 'mudbase'
 # setup authorization
 Mudbase.configure do |config|
-  # Configure Bearer authorization (JWT): BearerToken
+  # Configure Bearer authorization (JWT): ProjectBearerAuth
   config.access_token = 'YOUR_BEARER_TOKEN'
 end
 
 api_instance = Mudbase::ChatApi.new
 project_id = 'project_id_example' # String | Project ID.
-chat_create_request = Mudbase::ChatCreateRequest.new({name: 'name_example', type: 'direct', participants: ['participants_example']}) # ChatCreateRequest | Chat name, type (direct/group/channel/broadcast), participants array, optional description and settings.
+create_chat_request = Mudbase::CreateChatRequest.new({name: 'name_example', type: 'direct', participants: ['participants_example']}) # CreateChatRequest | Chat name, type (direct/group/channel/broadcast), participants array, optional description and settings.
 
 begin
   # Create new chat
-  result = api_instance.chat_create(project_id, chat_create_request)
+  result = api_instance.create_chat(project_id, create_chat_request)
   p result
 rescue Mudbase::ApiError => e
-  puts "Error when calling ChatApi->chat_create: #{e}"
+  puts "Error when calling ChatApi->create_chat: #{e}"
 end
 ```
 
-#### Using the chat_create_with_http_info variant
+#### Using the create_chat_with_http_info variant
 
 This returns an Array which contains the response data, status code and headers.
 
-> <Array(<ChatCreate201Response>, Integer, Hash)> chat_create_with_http_info(project_id, chat_create_request)
+> <Array(<CreateChat201Response>, Integer, Hash)> create_chat_with_http_info(project_id, create_chat_request)
 
 ```ruby
 begin
   # Create new chat
-  data, status_code, headers = api_instance.chat_create_with_http_info(project_id, chat_create_request)
+  data, status_code, headers = api_instance.create_chat_with_http_info(project_id, create_chat_request)
   p status_code # => 2xx
   p headers # => { ... }
-  p data # => <ChatCreate201Response>
+  p data # => <CreateChat201Response>
 rescue Mudbase::ApiError => e
-  puts "Error when calling ChatApi->chat_create_with_http_info: #{e}"
+  puts "Error when calling ChatApi->create_chat_with_http_info: #{e}"
 end
 ```
 
@@ -221,15 +221,15 @@ end
 | Name | Type | Description | Notes |
 | ---- | ---- | ----------- | ----- |
 | **project_id** | **String** | Project ID. |  |
-| **chat_create_request** | [**ChatCreateRequest**](ChatCreateRequest.md) | Chat name, type (direct/group/channel/broadcast), participants array, optional description and settings. |  |
+| **create_chat_request** | [**CreateChatRequest**](CreateChatRequest.md) | Chat name, type (direct/group/channel/broadcast), participants array, optional description and settings. |  |
 
 ### Return type
 
-[**ChatCreate201Response**](ChatCreate201Response.md)
+[**CreateChat201Response**](CreateChat201Response.md)
 
 ### Authorization
 
-[BearerToken](../README.md#BearerToken)
+[ProjectBearerAuth](../README.md#ProjectBearerAuth)
 
 ### HTTP request headers
 
@@ -237,9 +237,9 @@ end
 - **Accept**: application/json
 
 
-## chat_delete_message
+## delete_message
 
-> <MessageResponse> chat_delete_message(project_id, chat_id, message_id)
+> <MessageResponse> delete_message(project_id, chat_id, message_id)
 
 Delete message
 
@@ -252,7 +252,7 @@ require 'time'
 require 'mudbase'
 # setup authorization
 Mudbase.configure do |config|
-  # Configure Bearer authorization (JWT): BearerToken
+  # Configure Bearer authorization (JWT): ProjectBearerAuth
   config.access_token = 'YOUR_BEARER_TOKEN'
 end
 
@@ -263,28 +263,28 @@ message_id = 'message_id_example' # String | Message ID.
 
 begin
   # Delete message
-  result = api_instance.chat_delete_message(project_id, chat_id, message_id)
+  result = api_instance.delete_message(project_id, chat_id, message_id)
   p result
 rescue Mudbase::ApiError => e
-  puts "Error when calling ChatApi->chat_delete_message: #{e}"
+  puts "Error when calling ChatApi->delete_message: #{e}"
 end
 ```
 
-#### Using the chat_delete_message_with_http_info variant
+#### Using the delete_message_with_http_info variant
 
 This returns an Array which contains the response data, status code and headers.
 
-> <Array(<MessageResponse>, Integer, Hash)> chat_delete_message_with_http_info(project_id, chat_id, message_id)
+> <Array(<MessageResponse>, Integer, Hash)> delete_message_with_http_info(project_id, chat_id, message_id)
 
 ```ruby
 begin
   # Delete message
-  data, status_code, headers = api_instance.chat_delete_message_with_http_info(project_id, chat_id, message_id)
+  data, status_code, headers = api_instance.delete_message_with_http_info(project_id, chat_id, message_id)
   p status_code # => 2xx
   p headers # => { ... }
   p data # => <MessageResponse>
 rescue Mudbase::ApiError => e
-  puts "Error when calling ChatApi->chat_delete_message_with_http_info: #{e}"
+  puts "Error when calling ChatApi->delete_message_with_http_info: #{e}"
 end
 ```
 
@@ -302,7 +302,7 @@ end
 
 ### Authorization
 
-[BearerToken](../README.md#BearerToken)
+[ProjectBearerAuth](../README.md#ProjectBearerAuth)
 
 ### HTTP request headers
 
@@ -310,9 +310,9 @@ end
 - **Accept**: application/json
 
 
-## chat_edit_message
+## edit_message
 
-> <ChatEditMessage200Response> chat_edit_message(project_id, chat_id, message_id, chat_edit_message_request)
+> <EditMessage200Response> edit_message(project_id, chat_id, message_id, edit_message_request)
 
 Edit message
 
@@ -325,7 +325,7 @@ require 'time'
 require 'mudbase'
 # setup authorization
 Mudbase.configure do |config|
-  # Configure Bearer authorization (JWT): BearerToken
+  # Configure Bearer authorization (JWT): ProjectBearerAuth
   config.access_token = 'YOUR_BEARER_TOKEN'
 end
 
@@ -333,32 +333,32 @@ api_instance = Mudbase::ChatApi.new
 project_id = 'project_id_example' # String | Project ID.
 chat_id = 'chat_id_example' # String | Chat ID.
 message_id = 'message_id_example' # String | Message ID.
-chat_edit_message_request = Mudbase::ChatEditMessageRequest.new({content: 'content_example'}) # ChatEditMessageRequest | New message content.
+edit_message_request = Mudbase::EditMessageRequest.new({content: 'content_example'}) # EditMessageRequest | New message content.
 
 begin
   # Edit message
-  result = api_instance.chat_edit_message(project_id, chat_id, message_id, chat_edit_message_request)
+  result = api_instance.edit_message(project_id, chat_id, message_id, edit_message_request)
   p result
 rescue Mudbase::ApiError => e
-  puts "Error when calling ChatApi->chat_edit_message: #{e}"
+  puts "Error when calling ChatApi->edit_message: #{e}"
 end
 ```
 
-#### Using the chat_edit_message_with_http_info variant
+#### Using the edit_message_with_http_info variant
 
 This returns an Array which contains the response data, status code and headers.
 
-> <Array(<ChatEditMessage200Response>, Integer, Hash)> chat_edit_message_with_http_info(project_id, chat_id, message_id, chat_edit_message_request)
+> <Array(<EditMessage200Response>, Integer, Hash)> edit_message_with_http_info(project_id, chat_id, message_id, edit_message_request)
 
 ```ruby
 begin
   # Edit message
-  data, status_code, headers = api_instance.chat_edit_message_with_http_info(project_id, chat_id, message_id, chat_edit_message_request)
+  data, status_code, headers = api_instance.edit_message_with_http_info(project_id, chat_id, message_id, edit_message_request)
   p status_code # => 2xx
   p headers # => { ... }
-  p data # => <ChatEditMessage200Response>
+  p data # => <EditMessage200Response>
 rescue Mudbase::ApiError => e
-  puts "Error when calling ChatApi->chat_edit_message_with_http_info: #{e}"
+  puts "Error when calling ChatApi->edit_message_with_http_info: #{e}"
 end
 ```
 
@@ -369,15 +369,15 @@ end
 | **project_id** | **String** | Project ID. |  |
 | **chat_id** | **String** | Chat ID. |  |
 | **message_id** | **String** | Message ID. |  |
-| **chat_edit_message_request** | [**ChatEditMessageRequest**](ChatEditMessageRequest.md) | New message content. |  |
+| **edit_message_request** | [**EditMessageRequest**](EditMessageRequest.md) | New message content. |  |
 
 ### Return type
 
-[**ChatEditMessage200Response**](ChatEditMessage200Response.md)
+[**EditMessage200Response**](EditMessage200Response.md)
 
 ### Authorization
 
-[BearerToken](../README.md#BearerToken)
+[ProjectBearerAuth](../README.md#ProjectBearerAuth)
 
 ### HTTP request headers
 
@@ -385,9 +385,9 @@ end
 - **Accept**: application/json
 
 
-## chat_get
+## get_chat_details
 
-> <ChatGet200Response> chat_get(project_id, chat_id)
+> <GetChatDetails200Response> get_chat_details(project_id, chat_id)
 
 Get chat details
 
@@ -400,7 +400,7 @@ require 'time'
 require 'mudbase'
 # setup authorization
 Mudbase.configure do |config|
-  # Configure Bearer authorization (JWT): BearerToken
+  # Configure Bearer authorization (JWT): ProjectBearerAuth
   config.access_token = 'YOUR_BEARER_TOKEN'
 end
 
@@ -410,28 +410,28 @@ chat_id = 'chat_id_example' # String | Chat ID.
 
 begin
   # Get chat details
-  result = api_instance.chat_get(project_id, chat_id)
+  result = api_instance.get_chat_details(project_id, chat_id)
   p result
 rescue Mudbase::ApiError => e
-  puts "Error when calling ChatApi->chat_get: #{e}"
+  puts "Error when calling ChatApi->get_chat_details: #{e}"
 end
 ```
 
-#### Using the chat_get_with_http_info variant
+#### Using the get_chat_details_with_http_info variant
 
 This returns an Array which contains the response data, status code and headers.
 
-> <Array(<ChatGet200Response>, Integer, Hash)> chat_get_with_http_info(project_id, chat_id)
+> <Array(<GetChatDetails200Response>, Integer, Hash)> get_chat_details_with_http_info(project_id, chat_id)
 
 ```ruby
 begin
   # Get chat details
-  data, status_code, headers = api_instance.chat_get_with_http_info(project_id, chat_id)
+  data, status_code, headers = api_instance.get_chat_details_with_http_info(project_id, chat_id)
   p status_code # => 2xx
   p headers # => { ... }
-  p data # => <ChatGet200Response>
+  p data # => <GetChatDetails200Response>
 rescue Mudbase::ApiError => e
-  puts "Error when calling ChatApi->chat_get_with_http_info: #{e}"
+  puts "Error when calling ChatApi->get_chat_details_with_http_info: #{e}"
 end
 ```
 
@@ -444,11 +444,11 @@ end
 
 ### Return type
 
-[**ChatGet200Response**](ChatGet200Response.md)
+[**GetChatDetails200Response**](GetChatDetails200Response.md)
 
 ### Authorization
 
-[BearerToken](../README.md#BearerToken)
+[ProjectBearerAuth](../README.md#ProjectBearerAuth)
 
 ### HTTP request headers
 
@@ -456,9 +456,9 @@ end
 - **Accept**: application/json
 
 
-## chat_get_messages
+## get_chat_messages
 
-> <ChatGetMessages200Response> chat_get_messages(project_id, chat_id, opts)
+> <GetChatMessages200Response> get_chat_messages(project_id, chat_id, opts)
 
 Get chat messages
 
@@ -471,7 +471,7 @@ require 'time'
 require 'mudbase'
 # setup authorization
 Mudbase.configure do |config|
-  # Configure Bearer authorization (JWT): BearerToken
+  # Configure Bearer authorization (JWT): ProjectBearerAuth
   config.access_token = 'YOUR_BEARER_TOKEN'
 end
 
@@ -487,28 +487,28 @@ opts = {
 
 begin
   # Get chat messages
-  result = api_instance.chat_get_messages(project_id, chat_id, opts)
+  result = api_instance.get_chat_messages(project_id, chat_id, opts)
   p result
 rescue Mudbase::ApiError => e
-  puts "Error when calling ChatApi->chat_get_messages: #{e}"
+  puts "Error when calling ChatApi->get_chat_messages: #{e}"
 end
 ```
 
-#### Using the chat_get_messages_with_http_info variant
+#### Using the get_chat_messages_with_http_info variant
 
 This returns an Array which contains the response data, status code and headers.
 
-> <Array(<ChatGetMessages200Response>, Integer, Hash)> chat_get_messages_with_http_info(project_id, chat_id, opts)
+> <Array(<GetChatMessages200Response>, Integer, Hash)> get_chat_messages_with_http_info(project_id, chat_id, opts)
 
 ```ruby
 begin
   # Get chat messages
-  data, status_code, headers = api_instance.chat_get_messages_with_http_info(project_id, chat_id, opts)
+  data, status_code, headers = api_instance.get_chat_messages_with_http_info(project_id, chat_id, opts)
   p status_code # => 2xx
   p headers # => { ... }
-  p data # => <ChatGetMessages200Response>
+  p data # => <GetChatMessages200Response>
 rescue Mudbase::ApiError => e
-  puts "Error when calling ChatApi->chat_get_messages_with_http_info: #{e}"
+  puts "Error when calling ChatApi->get_chat_messages_with_http_info: #{e}"
 end
 ```
 
@@ -525,11 +525,11 @@ end
 
 ### Return type
 
-[**ChatGetMessages200Response**](ChatGetMessages200Response.md)
+[**GetChatMessages200Response**](GetChatMessages200Response.md)
 
 ### Authorization
 
-[BearerToken](../README.md#BearerToken)
+[ProjectBearerAuth](../README.md#ProjectBearerAuth)
 
 ### HTTP request headers
 
@@ -537,9 +537,9 @@ end
 - **Accept**: application/json
 
 
-## chat_list
+## get_user_chats
 
-> <ChatList200Response> chat_list(project_id, opts)
+> <GetUserChats200Response> get_user_chats(project_id, opts)
 
 Get user chats
 
@@ -552,7 +552,7 @@ require 'time'
 require 'mudbase'
 # setup authorization
 Mudbase.configure do |config|
-  # Configure Bearer authorization (JWT): BearerToken
+  # Configure Bearer authorization (JWT): ProjectBearerAuth
   config.access_token = 'YOUR_BEARER_TOKEN'
 end
 
@@ -565,28 +565,28 @@ opts = {
 
 begin
   # Get user chats
-  result = api_instance.chat_list(project_id, opts)
+  result = api_instance.get_user_chats(project_id, opts)
   p result
 rescue Mudbase::ApiError => e
-  puts "Error when calling ChatApi->chat_list: #{e}"
+  puts "Error when calling ChatApi->get_user_chats: #{e}"
 end
 ```
 
-#### Using the chat_list_with_http_info variant
+#### Using the get_user_chats_with_http_info variant
 
 This returns an Array which contains the response data, status code and headers.
 
-> <Array(<ChatList200Response>, Integer, Hash)> chat_list_with_http_info(project_id, opts)
+> <Array(<GetUserChats200Response>, Integer, Hash)> get_user_chats_with_http_info(project_id, opts)
 
 ```ruby
 begin
   # Get user chats
-  data, status_code, headers = api_instance.chat_list_with_http_info(project_id, opts)
+  data, status_code, headers = api_instance.get_user_chats_with_http_info(project_id, opts)
   p status_code # => 2xx
   p headers # => { ... }
-  p data # => <ChatList200Response>
+  p data # => <GetUserChats200Response>
 rescue Mudbase::ApiError => e
-  puts "Error when calling ChatApi->chat_list_with_http_info: #{e}"
+  puts "Error when calling ChatApi->get_user_chats_with_http_info: #{e}"
 end
 ```
 
@@ -600,11 +600,11 @@ end
 
 ### Return type
 
-[**ChatList200Response**](ChatList200Response.md)
+[**GetUserChats200Response**](GetUserChats200Response.md)
 
 ### Authorization
 
-[BearerToken](../README.md#BearerToken)
+[ProjectBearerAuth](../README.md#ProjectBearerAuth)
 
 ### HTTP request headers
 
@@ -612,9 +612,9 @@ end
 - **Accept**: application/json
 
 
-## chat_mark_as_read
+## mark_messages_as_read
 
-> <ChatMarkAsRead200Response> chat_mark_as_read(project_id, chat_id, chat_mark_as_read_request)
+> <MarkMessagesAsRead200Response> mark_messages_as_read(project_id, chat_id, mark_messages_as_read_request)
 
 Mark messages as read
 
@@ -627,39 +627,39 @@ require 'time'
 require 'mudbase'
 # setup authorization
 Mudbase.configure do |config|
-  # Configure Bearer authorization (JWT): BearerToken
+  # Configure Bearer authorization (JWT): ProjectBearerAuth
   config.access_token = 'YOUR_BEARER_TOKEN'
 end
 
 api_instance = Mudbase::ChatApi.new
 project_id = 'project_id_example' # String | Project ID.
 chat_id = 'chat_id_example' # String | Chat ID.
-chat_mark_as_read_request = Mudbase::ChatMarkAsReadRequest.new({message_ids: ['message_ids_example']}) # ChatMarkAsReadRequest | Array of message IDs to mark as read.
+mark_messages_as_read_request = Mudbase::MarkMessagesAsReadRequest.new({message_ids: ['message_ids_example']}) # MarkMessagesAsReadRequest | Array of message IDs to mark as read.
 
 begin
   # Mark messages as read
-  result = api_instance.chat_mark_as_read(project_id, chat_id, chat_mark_as_read_request)
+  result = api_instance.mark_messages_as_read(project_id, chat_id, mark_messages_as_read_request)
   p result
 rescue Mudbase::ApiError => e
-  puts "Error when calling ChatApi->chat_mark_as_read: #{e}"
+  puts "Error when calling ChatApi->mark_messages_as_read: #{e}"
 end
 ```
 
-#### Using the chat_mark_as_read_with_http_info variant
+#### Using the mark_messages_as_read_with_http_info variant
 
 This returns an Array which contains the response data, status code and headers.
 
-> <Array(<ChatMarkAsRead200Response>, Integer, Hash)> chat_mark_as_read_with_http_info(project_id, chat_id, chat_mark_as_read_request)
+> <Array(<MarkMessagesAsRead200Response>, Integer, Hash)> mark_messages_as_read_with_http_info(project_id, chat_id, mark_messages_as_read_request)
 
 ```ruby
 begin
   # Mark messages as read
-  data, status_code, headers = api_instance.chat_mark_as_read_with_http_info(project_id, chat_id, chat_mark_as_read_request)
+  data, status_code, headers = api_instance.mark_messages_as_read_with_http_info(project_id, chat_id, mark_messages_as_read_request)
   p status_code # => 2xx
   p headers # => { ... }
-  p data # => <ChatMarkAsRead200Response>
+  p data # => <MarkMessagesAsRead200Response>
 rescue Mudbase::ApiError => e
-  puts "Error when calling ChatApi->chat_mark_as_read_with_http_info: #{e}"
+  puts "Error when calling ChatApi->mark_messages_as_read_with_http_info: #{e}"
 end
 ```
 
@@ -669,15 +669,15 @@ end
 | ---- | ---- | ----------- | ----- |
 | **project_id** | **String** | Project ID. |  |
 | **chat_id** | **String** | Chat ID. |  |
-| **chat_mark_as_read_request** | [**ChatMarkAsReadRequest**](ChatMarkAsReadRequest.md) | Array of message IDs to mark as read. |  |
+| **mark_messages_as_read_request** | [**MarkMessagesAsReadRequest**](MarkMessagesAsReadRequest.md) | Array of message IDs to mark as read. |  |
 
 ### Return type
 
-[**ChatMarkAsRead200Response**](ChatMarkAsRead200Response.md)
+[**MarkMessagesAsRead200Response**](MarkMessagesAsRead200Response.md)
 
 ### Authorization
 
-[BearerToken](../README.md#BearerToken)
+[ProjectBearerAuth](../README.md#ProjectBearerAuth)
 
 ### HTTP request headers
 
@@ -685,9 +685,9 @@ end
 - **Accept**: application/json
 
 
-## chat_remove_participant
+## remove_participant
 
-> <MessageResponse> chat_remove_participant(project_id, chat_id, chat_remove_participant_request)
+> <MessageResponse> remove_participant(project_id, chat_id, remove_participant_request)
 
 Remove participant from chat
 
@@ -700,39 +700,39 @@ require 'time'
 require 'mudbase'
 # setup authorization
 Mudbase.configure do |config|
-  # Configure Bearer authorization (JWT): BearerToken
+  # Configure Bearer authorization (JWT): ProjectBearerAuth
   config.access_token = 'YOUR_BEARER_TOKEN'
 end
 
 api_instance = Mudbase::ChatApi.new
 project_id = 'project_id_example' # String | Project ID.
 chat_id = 'chat_id_example' # String | Chat ID.
-chat_remove_participant_request = Mudbase::ChatRemoveParticipantRequest.new({user_id: 'user_id_example'}) # ChatRemoveParticipantRequest | User ID of the participant to remove.
+remove_participant_request = Mudbase::RemoveParticipantRequest.new({user_id: 'user_id_example'}) # RemoveParticipantRequest | User ID of the participant to remove.
 
 begin
   # Remove participant from chat
-  result = api_instance.chat_remove_participant(project_id, chat_id, chat_remove_participant_request)
+  result = api_instance.remove_participant(project_id, chat_id, remove_participant_request)
   p result
 rescue Mudbase::ApiError => e
-  puts "Error when calling ChatApi->chat_remove_participant: #{e}"
+  puts "Error when calling ChatApi->remove_participant: #{e}"
 end
 ```
 
-#### Using the chat_remove_participant_with_http_info variant
+#### Using the remove_participant_with_http_info variant
 
 This returns an Array which contains the response data, status code and headers.
 
-> <Array(<MessageResponse>, Integer, Hash)> chat_remove_participant_with_http_info(project_id, chat_id, chat_remove_participant_request)
+> <Array(<MessageResponse>, Integer, Hash)> remove_participant_with_http_info(project_id, chat_id, remove_participant_request)
 
 ```ruby
 begin
   # Remove participant from chat
-  data, status_code, headers = api_instance.chat_remove_participant_with_http_info(project_id, chat_id, chat_remove_participant_request)
+  data, status_code, headers = api_instance.remove_participant_with_http_info(project_id, chat_id, remove_participant_request)
   p status_code # => 2xx
   p headers # => { ... }
   p data # => <MessageResponse>
 rescue Mudbase::ApiError => e
-  puts "Error when calling ChatApi->chat_remove_participant_with_http_info: #{e}"
+  puts "Error when calling ChatApi->remove_participant_with_http_info: #{e}"
 end
 ```
 
@@ -742,7 +742,7 @@ end
 | ---- | ---- | ----------- | ----- |
 | **project_id** | **String** | Project ID. |  |
 | **chat_id** | **String** | Chat ID. |  |
-| **chat_remove_participant_request** | [**ChatRemoveParticipantRequest**](ChatRemoveParticipantRequest.md) | User ID of the participant to remove. |  |
+| **remove_participant_request** | [**RemoveParticipantRequest**](RemoveParticipantRequest.md) | User ID of the participant to remove. |  |
 
 ### Return type
 
@@ -750,7 +750,7 @@ end
 
 ### Authorization
 
-[BearerToken](../README.md#BearerToken)
+[ProjectBearerAuth](../README.md#ProjectBearerAuth)
 
 ### HTTP request headers
 
@@ -758,9 +758,9 @@ end
 - **Accept**: application/json
 
 
-## chat_remove_reaction
+## remove_reaction
 
-> <ChatRemoveReaction200Response> chat_remove_reaction(project_id, chat_id, message_id, chat_add_reaction_request)
+> <RemoveReaction200Response> remove_reaction(project_id, chat_id, message_id, add_reaction_request)
 
 Remove reaction from message
 
@@ -773,7 +773,7 @@ require 'time'
 require 'mudbase'
 # setup authorization
 Mudbase.configure do |config|
-  # Configure Bearer authorization (JWT): BearerToken
+  # Configure Bearer authorization (JWT): ProjectBearerAuth
   config.access_token = 'YOUR_BEARER_TOKEN'
 end
 
@@ -781,32 +781,32 @@ api_instance = Mudbase::ChatApi.new
 project_id = 'project_id_example' # String | Project ID.
 chat_id = 'chat_id_example' # String | Chat ID.
 message_id = 'message_id_example' # String | Message ID.
-chat_add_reaction_request = Mudbase::ChatAddReactionRequest.new({emoji: 'emoji_example'}) # ChatAddReactionRequest | Emoji to remove (must match the reaction added by the user).
+add_reaction_request = Mudbase::AddReactionRequest.new({emoji: 'emoji_example'}) # AddReactionRequest | Emoji to remove (must match the reaction added by the user).
 
 begin
   # Remove reaction from message
-  result = api_instance.chat_remove_reaction(project_id, chat_id, message_id, chat_add_reaction_request)
+  result = api_instance.remove_reaction(project_id, chat_id, message_id, add_reaction_request)
   p result
 rescue Mudbase::ApiError => e
-  puts "Error when calling ChatApi->chat_remove_reaction: #{e}"
+  puts "Error when calling ChatApi->remove_reaction: #{e}"
 end
 ```
 
-#### Using the chat_remove_reaction_with_http_info variant
+#### Using the remove_reaction_with_http_info variant
 
 This returns an Array which contains the response data, status code and headers.
 
-> <Array(<ChatRemoveReaction200Response>, Integer, Hash)> chat_remove_reaction_with_http_info(project_id, chat_id, message_id, chat_add_reaction_request)
+> <Array(<RemoveReaction200Response>, Integer, Hash)> remove_reaction_with_http_info(project_id, chat_id, message_id, add_reaction_request)
 
 ```ruby
 begin
   # Remove reaction from message
-  data, status_code, headers = api_instance.chat_remove_reaction_with_http_info(project_id, chat_id, message_id, chat_add_reaction_request)
+  data, status_code, headers = api_instance.remove_reaction_with_http_info(project_id, chat_id, message_id, add_reaction_request)
   p status_code # => 2xx
   p headers # => { ... }
-  p data # => <ChatRemoveReaction200Response>
+  p data # => <RemoveReaction200Response>
 rescue Mudbase::ApiError => e
-  puts "Error when calling ChatApi->chat_remove_reaction_with_http_info: #{e}"
+  puts "Error when calling ChatApi->remove_reaction_with_http_info: #{e}"
 end
 ```
 
@@ -817,15 +817,15 @@ end
 | **project_id** | **String** | Project ID. |  |
 | **chat_id** | **String** | Chat ID. |  |
 | **message_id** | **String** | Message ID. |  |
-| **chat_add_reaction_request** | [**ChatAddReactionRequest**](ChatAddReactionRequest.md) | Emoji to remove (must match the reaction added by the user). |  |
+| **add_reaction_request** | [**AddReactionRequest**](AddReactionRequest.md) | Emoji to remove (must match the reaction added by the user). |  |
 
 ### Return type
 
-[**ChatRemoveReaction200Response**](ChatRemoveReaction200Response.md)
+[**RemoveReaction200Response**](RemoveReaction200Response.md)
 
 ### Authorization
 
-[BearerToken](../README.md#BearerToken)
+[ProjectBearerAuth](../README.md#ProjectBearerAuth)
 
 ### HTTP request headers
 
@@ -833,9 +833,9 @@ end
 - **Accept**: application/json
 
 
-## chat_send_message
+## send_message
 
-> <ChatSendMessage201Response> chat_send_message(project_id, chat_id, chat_send_message_request)
+> <SendMessage201Response> send_message(project_id, chat_id, send_message_request)
 
 Send message
 
@@ -848,39 +848,39 @@ require 'time'
 require 'mudbase'
 # setup authorization
 Mudbase.configure do |config|
-  # Configure Bearer authorization (JWT): BearerToken
+  # Configure Bearer authorization (JWT): ProjectBearerAuth
   config.access_token = 'YOUR_BEARER_TOKEN'
 end
 
 api_instance = Mudbase::ChatApi.new
 project_id = 'project_id_example' # String | Project ID.
 chat_id = 'chat_id_example' # String | Chat ID.
-chat_send_message_request = Mudbase::ChatSendMessageRequest.new({type: 'text', content: 'content_example'}) # ChatSendMessageRequest | Message type, content, optional replyTo and mentions.
+send_message_request = Mudbase::SendMessageRequest.new({type: 'text', content: 'content_example'}) # SendMessageRequest | Message type, content, optional replyTo and mentions.
 
 begin
   # Send message
-  result = api_instance.chat_send_message(project_id, chat_id, chat_send_message_request)
+  result = api_instance.send_message(project_id, chat_id, send_message_request)
   p result
 rescue Mudbase::ApiError => e
-  puts "Error when calling ChatApi->chat_send_message: #{e}"
+  puts "Error when calling ChatApi->send_message: #{e}"
 end
 ```
 
-#### Using the chat_send_message_with_http_info variant
+#### Using the send_message_with_http_info variant
 
 This returns an Array which contains the response data, status code and headers.
 
-> <Array(<ChatSendMessage201Response>, Integer, Hash)> chat_send_message_with_http_info(project_id, chat_id, chat_send_message_request)
+> <Array(<SendMessage201Response>, Integer, Hash)> send_message_with_http_info(project_id, chat_id, send_message_request)
 
 ```ruby
 begin
   # Send message
-  data, status_code, headers = api_instance.chat_send_message_with_http_info(project_id, chat_id, chat_send_message_request)
+  data, status_code, headers = api_instance.send_message_with_http_info(project_id, chat_id, send_message_request)
   p status_code # => 2xx
   p headers # => { ... }
-  p data # => <ChatSendMessage201Response>
+  p data # => <SendMessage201Response>
 rescue Mudbase::ApiError => e
-  puts "Error when calling ChatApi->chat_send_message_with_http_info: #{e}"
+  puts "Error when calling ChatApi->send_message_with_http_info: #{e}"
 end
 ```
 
@@ -890,15 +890,15 @@ end
 | ---- | ---- | ----------- | ----- |
 | **project_id** | **String** | Project ID. |  |
 | **chat_id** | **String** | Chat ID. |  |
-| **chat_send_message_request** | [**ChatSendMessageRequest**](ChatSendMessageRequest.md) | Message type, content, optional replyTo and mentions. |  |
+| **send_message_request** | [**SendMessageRequest**](SendMessageRequest.md) | Message type, content, optional replyTo and mentions. |  |
 
 ### Return type
 
-[**ChatSendMessage201Response**](ChatSendMessage201Response.md)
+[**SendMessage201Response**](SendMessage201Response.md)
 
 ### Authorization
 
-[BearerToken](../README.md#BearerToken)
+[ProjectBearerAuth](../README.md#ProjectBearerAuth)
 
 ### HTTP request headers