mudbase 1.1.4

data/docs/ChatApi.md

@@ -0,0 +1,907 @@
+# Mudbase::ChatApi
+
+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 |
+
+
+## add_participant
+
+> <AddParticipant200Response> add_participant(project_id, chat_id, add_participant_request)
+
+Add participant to chat
+
+Add a user to the chat with an optional role (admin or member).
+
+### Examples
+
+```ruby
+require 'time'
+require 'mudbase'
+# setup authorization
+Mudbase.configure do |config|
+  # 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.
+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.add_participant(project_id, chat_id, add_participant_request)
+  p result
+rescue Mudbase::ApiError => e
+  puts "Error when calling ChatApi->add_participant: #{e}"
+end
+```
+
+#### Using the 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)
+
+```ruby
+begin
+  # Add participant to chat
+  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 # => <AddParticipant200Response>
+rescue Mudbase::ApiError => e
+  puts "Error when calling ChatApi->add_participant_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **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). |  |
+
+### Return type
+
+[**AddParticipant200Response**](AddParticipant200Response.md)
+
+### Authorization
+
+[ProjectBearerAuth](../README.md#ProjectBearerAuth)
+
+### HTTP request headers
+
+- **Content-Type**: application/json
+- **Accept**: application/json
+
+
+## add_reaction
+
+> <AddReaction200Response> add_reaction(project_id, chat_id, message_id, add_reaction_request)
+
+Add reaction to message
+
+Add an emoji reaction to a message.
+
+### Examples
+
+```ruby
+require 'time'
+require 'mudbase'
+# setup authorization
+Mudbase.configure do |config|
+  # 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.
+message_id = 'message_id_example' # String | Message ID.
+add_reaction_request = Mudbase::AddReactionRequest.new({emoji: 'emoji_example'}) # AddReactionRequest | Emoji reaction (e.g. 👍, ❤️).
+
+begin
+  # Add reaction to message
+  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->add_reaction: #{e}"
+end
+```
+
+#### Using the 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)
+
+```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)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <AddReaction200Response>
+rescue Mudbase::ApiError => e
+  puts "Error when calling ChatApi->add_reaction_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **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. 👍, ❤️). |  |
+
+### Return type
+
+[**AddReaction200Response**](AddReaction200Response.md)
+
+### Authorization
+
+[ProjectBearerAuth](../README.md#ProjectBearerAuth)
+
+### HTTP request headers
+
+- **Content-Type**: application/json
+- **Accept**: application/json
+
+
+## create_chat
+
+> <CreateChat201Response> create_chat(project_id, create_chat_request)
+
+Create new chat
+
+Create a new chat (direct, group, channel, or broadcast) with name, type, participants, and optional settings.
+
+### Examples
+
+```ruby
+require 'time'
+require 'mudbase'
+# setup authorization
+Mudbase.configure do |config|
+  # 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.
+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.create_chat(project_id, create_chat_request)
+  p result
+rescue Mudbase::ApiError => e
+  puts "Error when calling ChatApi->create_chat: #{e}"
+end
+```
+
+#### Using the create_chat_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)
+
+```ruby
+begin
+  # Create new chat
+  data, status_code, headers = api_instance.create_chat_with_http_info(project_id, create_chat_request)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <CreateChat201Response>
+rescue Mudbase::ApiError => e
+  puts "Error when calling ChatApi->create_chat_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| 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. |  |
+
+### Return type
+
+[**CreateChat201Response**](CreateChat201Response.md)
+
+### Authorization
+
+[ProjectBearerAuth](../README.md#ProjectBearerAuth)
+
+### HTTP request headers
+
+- **Content-Type**: application/json
+- **Accept**: application/json
+
+
+## delete_message
+
+> <MessageResponse> delete_message(project_id, chat_id, message_id)
+
+Delete message
+
+Delete a message from the chat (sender or admin). May be soft-delete or permanent depending on implementation.
+
+### Examples
+
+```ruby
+require 'time'
+require 'mudbase'
+# setup authorization
+Mudbase.configure do |config|
+  # 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.
+message_id = 'message_id_example' # String | Message ID.
+
+begin
+  # Delete message
+  result = api_instance.delete_message(project_id, chat_id, message_id)
+  p result
+rescue Mudbase::ApiError => e
+  puts "Error when calling ChatApi->delete_message: #{e}"
+end
+```
+
+#### 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)> 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)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <MessageResponse>
+rescue Mudbase::ApiError => e
+  puts "Error when calling ChatApi->delete_message_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **project_id** | **String** | Project ID. |  |
+| **chat_id** | **String** | Chat ID. |  |
+| **message_id** | **String** | Message ID. |  |
+
+### Return type
+
+[**MessageResponse**](MessageResponse.md)
+
+### Authorization
+
+[ProjectBearerAuth](../README.md#ProjectBearerAuth)
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json
+
+
+## edit_message
+
+> <EditMessage200Response> edit_message(project_id, chat_id, message_id, edit_message_request)
+
+Edit message
+
+Update the content of a message (sender only; supports edit history).
+
+### Examples
+
+```ruby
+require 'time'
+require 'mudbase'
+# setup authorization
+Mudbase.configure do |config|
+  # 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.
+message_id = 'message_id_example' # String | Message ID.
+edit_message_request = Mudbase::EditMessageRequest.new({content: 'content_example'}) # EditMessageRequest | New message content.
+
+begin
+  # Edit message
+  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->edit_message: #{e}"
+end
+```
+
+#### Using the 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)
+
+```ruby
+begin
+  # Edit message
+  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 # => <EditMessage200Response>
+rescue Mudbase::ApiError => e
+  puts "Error when calling ChatApi->edit_message_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **project_id** | **String** | Project ID. |  |
+| **chat_id** | **String** | Chat ID. |  |
+| **message_id** | **String** | Message ID. |  |
+| **edit_message_request** | [**EditMessageRequest**](EditMessageRequest.md) | New message content. |  |
+
+### Return type
+
+[**EditMessage200Response**](EditMessage200Response.md)
+
+### Authorization
+
+[ProjectBearerAuth](../README.md#ProjectBearerAuth)
+
+### HTTP request headers
+
+- **Content-Type**: application/json
+- **Accept**: application/json
+
+
+## get_chat_details
+
+> <GetChatDetails200Response> get_chat_details(project_id, chat_id)
+
+Get chat details
+
+Returns full chat metadata including participants and roles for a single chat.
+
+### Examples
+
+```ruby
+require 'time'
+require 'mudbase'
+# setup authorization
+Mudbase.configure do |config|
+  # 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.
+
+begin
+  # Get chat details
+  result = api_instance.get_chat_details(project_id, chat_id)
+  p result
+rescue Mudbase::ApiError => e
+  puts "Error when calling ChatApi->get_chat_details: #{e}"
+end
+```
+
+#### Using the get_chat_details_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)
+
+```ruby
+begin
+  # Get chat details
+  data, status_code, headers = api_instance.get_chat_details_with_http_info(project_id, chat_id)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <GetChatDetails200Response>
+rescue Mudbase::ApiError => e
+  puts "Error when calling ChatApi->get_chat_details_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **project_id** | **String** | Project ID. |  |
+| **chat_id** | **String** | Chat ID. |  |
+
+### Return type
+
+[**GetChatDetails200Response**](GetChatDetails200Response.md)
+
+### Authorization
+
+[ProjectBearerAuth](../README.md#ProjectBearerAuth)
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json
+
+
+## get_chat_messages
+
+> <GetChatMessages200Response> get_chat_messages(project_id, chat_id, opts)
+
+Get chat messages
+
+Returns paginated messages for a chat with optional before/after cursor for time-based pagination.
+
+### Examples
+
+```ruby
+require 'time'
+require 'mudbase'
+# setup authorization
+Mudbase.configure do |config|
+  # 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.
+opts = {
+  page: 56, # Integer | Page number (1-based).
+  limit: 56, # Integer | Number of messages per page.
+  before: Time.parse('2013-10-20T19:20:30+01:00'), # Time | Return messages before this timestamp (cursor).
+  after: Time.parse('2013-10-20T19:20:30+01:00') # Time | Return messages after this timestamp (cursor).
+}
+
+begin
+  # Get chat messages
+  result = api_instance.get_chat_messages(project_id, chat_id, opts)
+  p result
+rescue Mudbase::ApiError => e
+  puts "Error when calling ChatApi->get_chat_messages: #{e}"
+end
+```
+
+#### Using the get_chat_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)
+
+```ruby
+begin
+  # Get chat messages
+  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 # => <GetChatMessages200Response>
+rescue Mudbase::ApiError => e
+  puts "Error when calling ChatApi->get_chat_messages_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **project_id** | **String** | Project ID. |  |
+| **chat_id** | **String** | Chat ID. |  |
+| **page** | **Integer** | Page number (1-based). | [optional][default to 1] |
+| **limit** | **Integer** | Number of messages per page. | [optional][default to 50] |
+| **before** | **Time** | Return messages before this timestamp (cursor). | [optional] |
+| **after** | **Time** | Return messages after this timestamp (cursor). | [optional] |
+
+### Return type
+
+[**GetChatMessages200Response**](GetChatMessages200Response.md)
+
+### Authorization
+
+[ProjectBearerAuth](../README.md#ProjectBearerAuth)
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json
+
+
+## get_user_chats
+
+> <GetUserChats200Response> get_user_chats(project_id, opts)
+
+Get user chats
+
+Returns paginated list of chats for the current user in the project, with last message and unread count.
+
+### Examples
+
+```ruby
+require 'time'
+require 'mudbase'
+# setup authorization
+Mudbase.configure do |config|
+  # 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.
+opts = {
+  page: 56, # Integer | Page number (1-based).
+  limit: 56 # Integer | Number of chats per page.
+}
+
+begin
+  # Get user chats
+  result = api_instance.get_user_chats(project_id, opts)
+  p result
+rescue Mudbase::ApiError => e
+  puts "Error when calling ChatApi->get_user_chats: #{e}"
+end
+```
+
+#### Using the get_user_chats_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)
+
+```ruby
+begin
+  # Get user chats
+  data, status_code, headers = api_instance.get_user_chats_with_http_info(project_id, opts)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <GetUserChats200Response>
+rescue Mudbase::ApiError => e
+  puts "Error when calling ChatApi->get_user_chats_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **project_id** | **String** | Project ID. |  |
+| **page** | **Integer** | Page number (1-based). | [optional][default to 1] |
+| **limit** | **Integer** | Number of chats per page. | [optional][default to 20] |
+
+### Return type
+
+[**GetUserChats200Response**](GetUserChats200Response.md)
+
+### Authorization
+
+[ProjectBearerAuth](../README.md#ProjectBearerAuth)
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json
+
+
+## mark_messages_as_read
+
+> <MarkMessagesAsRead200Response> mark_messages_as_read(project_id, chat_id, mark_messages_as_read_request)
+
+Mark messages as read
+
+Mark one or more messages as read for the current user in the chat.
+
+### Examples
+
+```ruby
+require 'time'
+require 'mudbase'
+# setup authorization
+Mudbase.configure do |config|
+  # 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.
+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.mark_messages_as_read(project_id, chat_id, mark_messages_as_read_request)
+  p result
+rescue Mudbase::ApiError => e
+  puts "Error when calling ChatApi->mark_messages_as_read: #{e}"
+end
+```
+
+#### Using the mark_messages_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)
+
+```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)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <MarkMessagesAsRead200Response>
+rescue Mudbase::ApiError => e
+  puts "Error when calling ChatApi->mark_messages_as_read_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **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. |  |
+
+### Return type
+
+[**MarkMessagesAsRead200Response**](MarkMessagesAsRead200Response.md)
+
+### Authorization
+
+[ProjectBearerAuth](../README.md#ProjectBearerAuth)
+
+### HTTP request headers
+
+- **Content-Type**: application/json
+- **Accept**: application/json
+
+
+## remove_participant
+
+> <MessageResponse> remove_participant(project_id, chat_id, remove_participant_request)
+
+Remove participant from chat
+
+Remove a user from the chat by userId.
+
+### Examples
+
+```ruby
+require 'time'
+require 'mudbase'
+# setup authorization
+Mudbase.configure do |config|
+  # 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.
+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.remove_participant(project_id, chat_id, remove_participant_request)
+  p result
+rescue Mudbase::ApiError => e
+  puts "Error when calling ChatApi->remove_participant: #{e}"
+end
+```
+
+#### 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)> remove_participant_with_http_info(project_id, chat_id, 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)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <MessageResponse>
+rescue Mudbase::ApiError => e
+  puts "Error when calling ChatApi->remove_participant_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **project_id** | **String** | Project ID. |  |
+| **chat_id** | **String** | Chat ID. |  |
+| **remove_participant_request** | [**RemoveParticipantRequest**](RemoveParticipantRequest.md) | User ID of the participant to remove. |  |
+
+### Return type
+
+[**MessageResponse**](MessageResponse.md)
+
+### Authorization
+
+[ProjectBearerAuth](../README.md#ProjectBearerAuth)
+
+### HTTP request headers
+
+- **Content-Type**: application/json
+- **Accept**: application/json
+
+
+## remove_reaction
+
+> <RemoveReaction200Response> remove_reaction(project_id, chat_id, message_id, add_reaction_request)
+
+Remove reaction from message
+
+Remove the current user's emoji reaction from a message.
+
+### Examples
+
+```ruby
+require 'time'
+require 'mudbase'
+# setup authorization
+Mudbase.configure do |config|
+  # 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.
+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).
+
+begin
+  # Remove reaction from message
+  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->remove_reaction: #{e}"
+end
+```
+
+#### Using the 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)
+
+```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)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <RemoveReaction200Response>
+rescue Mudbase::ApiError => e
+  puts "Error when calling ChatApi->remove_reaction_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **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). |  |
+
+### Return type
+
+[**RemoveReaction200Response**](RemoveReaction200Response.md)
+
+### Authorization
+
+[ProjectBearerAuth](../README.md#ProjectBearerAuth)
+
+### HTTP request headers
+
+- **Content-Type**: application/json
+- **Accept**: application/json
+
+
+## send_message
+
+> <SendMessage201Response> send_message(project_id, chat_id, send_message_request)
+
+Send message
+
+Send a message (text, image, video, audio, file, location, contact) to a chat with optional replyTo and mentions.
+
+### Examples
+
+```ruby
+require 'time'
+require 'mudbase'
+# setup authorization
+Mudbase.configure do |config|
+  # 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.
+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.send_message(project_id, chat_id, send_message_request)
+  p result
+rescue Mudbase::ApiError => e
+  puts "Error when calling ChatApi->send_message: #{e}"
+end
+```
+
+#### Using the 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)
+
+```ruby
+begin
+  # Send message
+  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 # => <SendMessage201Response>
+rescue Mudbase::ApiError => e
+  puts "Error when calling ChatApi->send_message_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **project_id** | **String** | Project ID. |  |
+| **chat_id** | **String** | Chat ID. |  |
+| **send_message_request** | [**SendMessageRequest**](SendMessageRequest.md) | Message type, content, optional replyTo and mentions. |  |
+
+### Return type
+
+[**SendMessage201Response**](SendMessage201Response.md)
+
+### Authorization
+
+[ProjectBearerAuth](../README.md#ProjectBearerAuth)
+
+### HTTP request headers
+
+- **Content-Type**: application/json
+- **Accept**: application/json
+