mudbase 1.1.9 → 1.2.1

data/docs/ChatApi.md

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