stream-chat-ruby 2.23.0 → 3.0.0

data/lib/stream-chat/client.rb

@@ -22,20 +22,17 @@ module StreamChat
 
   class Client
     extend T::Sig
-    # For now we disable runtime type checks.
-    # We will enable it with a major bump in the future,
-    # but for now, let's just run a static type check.
 
     DEFAULT_BASE_URL = 'https://chat.stream-io-api.com'
     DEFAULT_TIMEOUT = 6.0
 
-    T::Sig::WithoutRuntime.sig { returns(String) }
+    sig { returns(String) }
     attr_reader :api_key
 
-    T::Sig::WithoutRuntime.sig { returns(String) }
+    sig { returns(String) }
     attr_reader :api_secret
 
-    T::Sig::WithoutRuntime.sig { returns(Faraday::Connection) }
+    sig { returns(Faraday::Connection) }
     attr_reader :conn
 
     # initializes a Stream Chat API Client
@@ -48,7 +45,7 @@ module StreamChat
     # @example initialized the client with a timeout setting
     #   StreamChat::Client.new('my_key', 'my_secret', 3.0)
     #
-    T::Sig::WithoutRuntime.sig { params(api_key: String, api_secret: String, timeout: T.nilable(T.any(Float, String)), options: T.untyped).void }
+    sig { params(api_key: String, api_secret: String, timeout: T.nilable(T.any(Float, String)), options: T.untyped).void }
     def initialize(api_key, api_secret, timeout = nil, **options)
       raise ArgumentError, 'api_key and api_secret are required' if api_key.to_s.empty? || api_secret.to_s.empty?
 
@@ -73,7 +70,7 @@ module StreamChat
     # environmental variables. STREAM_CHAT_TIMEOUT and STREAM_CHAT_URL
     # variables are optional.
     # @param [StringKeyHash] options extra options
-    T::Sig::WithoutRuntime.sig { params(options: T.untyped).returns(Client) }
+    sig { params(options: T.untyped).returns(Client) }
     def self.from_env(**options)
       Client.new(ENV.fetch('STREAM_KEY'),
                  ENV.fetch('STREAM_SECRET'),
@@ -84,7 +81,7 @@ module StreamChat
     # Sets the underlying Faraday http client.
     #
     # @param [client] an instance of Faraday::Connection
-    T::Sig::WithoutRuntime.sig { params(client: Faraday::Connection).void }
+    sig { params(client: Faraday::Connection).void }
     def set_http_client(client)
       @conn = client
     end
@@ -95,7 +92,7 @@ module StreamChat
     # Knowing whether a user is authorized to perform certain actions is managed
     # separately via a role based permissions system.
     # You can set an `exp` (expires at) or `iat` (issued at) claim as well.
-    T::Sig::WithoutRuntime.sig { params(user_id: String, exp: T.nilable(Integer), iat: T.nilable(Integer)).returns(String) }
+    sig { params(user_id: String, exp: T.nilable(Integer), iat: T.nilable(Integer)).returns(String) }
     def create_token(user_id, exp = nil, iat = nil)
       payload = { user_id: user_id }
       payload['exp'] = exp unless exp.nil?
@@ -104,13 +101,13 @@ module StreamChat
     end
 
     # Updates application settings.
-    T::Sig::WithoutRuntime.sig { params(settings: T.untyped).returns(StreamChat::StreamResponse) }
+    sig { params(settings: T.untyped).returns(StreamChat::StreamResponse) }
     def update_app_settings(**settings)
       patch('app', data: settings)
     end
 
     # Returns application settings.
-    T::Sig::WithoutRuntime.sig { returns(StreamChat::StreamResponse) }
+    sig { returns(StreamChat::StreamResponse) }
     def get_app_settings
       get('app')
     end
@@ -120,14 +117,14 @@ module StreamChat
     # Any user is allowed to flag a message. This triggers the message.flagged
     # webhook event and adds the message to the inbox of your
     # Stream Dashboard Chat Moderation view.
-    T::Sig::WithoutRuntime.sig { params(id: String, options: T.untyped).returns(StreamChat::StreamResponse) }
+    sig { params(id: String, options: T.untyped).returns(StreamChat::StreamResponse) }
     def flag_message(id, **options)
       payload = { target_message_id: id }.merge(options)
       post('moderation/flag', data: payload)
     end
 
     # Unflags a message.
-    T::Sig::WithoutRuntime.sig { params(id: String, options: T.untyped).returns(StreamChat::StreamResponse) }
+    sig { params(id: String, options: T.untyped).returns(StreamChat::StreamResponse) }
     def unflag_message(id, **options)
       payload = { target_message_id: id }.merge(options)
       post('moderation/unflag', data: payload)
@@ -138,7 +135,7 @@ module StreamChat
     # If you prefer to build your own in app moderation dashboard, rather than use the Stream
     # dashboard, then the query message flags endpoint lets you get flagged messages. Similar
     # to other queries in Stream Chat, you can filter the flags using query operators.
-    T::Sig::WithoutRuntime.sig { params(filter_conditions: StringKeyHash, options: T.untyped).returns(StreamChat::StreamResponse) }
+    sig { params(filter_conditions: StringKeyHash, options: T.untyped).returns(StreamChat::StreamResponse) }
     def query_message_flags(filter_conditions, **options)
       params = options.merge({
                                filter_conditions: filter_conditions
@@ -147,28 +144,28 @@ module StreamChat
     end
 
     # Flags a user.
-    T::Sig::WithoutRuntime.sig { params(id: String, options: T.untyped).returns(StreamChat::StreamResponse) }
+    sig { params(id: String, options: T.untyped).returns(StreamChat::StreamResponse) }
     def flag_user(id, **options)
       payload = { target_user_id: id }.merge(options)
       post('moderation/flag', data: payload)
     end
 
     # Unflags a user.
-    T::Sig::WithoutRuntime.sig { params(id: String, options: T.untyped).returns(StreamChat::StreamResponse) }
+    sig { params(id: String, options: T.untyped).returns(StreamChat::StreamResponse) }
     def unflag_user(id, **options)
       payload = { target_user_id: id }.merge(options)
       post('moderation/unflag', data: payload)
     end
 
     # Queries flag reports.
-    T::Sig::WithoutRuntime.sig { params(options: T.untyped).returns(StreamChat::StreamResponse) }
+    sig { params(options: T.untyped).returns(StreamChat::StreamResponse) }
     def query_flag_reports(**options)
       data = { filter_conditions: options }
       post('moderation/reports', data: data)
     end
 
     # Sends a flag report review.
-    T::Sig::WithoutRuntime.sig { params(report_id: String, review_result: String, user_id: String, details: T.untyped).returns(StreamChat::StreamResponse) }
+    sig { params(report_id: String, review_result: String, user_id: String, details: T.untyped).returns(StreamChat::StreamResponse) }
     def review_flag_report(report_id, review_result, user_id, **details)
       data = {
         review_result: review_result,
@@ -179,7 +176,7 @@ module StreamChat
     end
 
     # Returns a message.
-    T::Sig::WithoutRuntime.sig { params(id: String).returns(StreamChat::StreamResponse) }
+    sig { params(id: String).returns(StreamChat::StreamResponse) }
     def get_message(id)
       get("messages/#{id}")
     end
@@ -188,7 +185,7 @@ module StreamChat
     #
     # You can enable and/or disable the search indexing on a per channel basis
     # type through the Stream Dashboard.
-    T::Sig::WithoutRuntime.sig { params(filter_conditions: StringKeyHash, query: T.any(String, StringKeyHash), sort: T.nilable(T::Hash[String, Integer]), options: T.untyped).returns(StreamChat::StreamResponse) }
+    sig { params(filter_conditions: StringKeyHash, query: T.any(String, StringKeyHash), sort: T.nilable(T::Hash[String, Integer]), options: T.untyped).returns(StreamChat::StreamResponse) }
     def search(filter_conditions, query, sort: nil, **options)
       offset = T.cast(options[:offset], T.nilable(Integer))
       next_value = options[:next]
@@ -207,21 +204,21 @@ module StreamChat
     end
 
     # @deprecated Use {#upsert_users} instead.
-    T::Sig::WithoutRuntime.sig { params(users: T::Array[StringKeyHash]).returns(StreamChat::StreamResponse) }
+    sig { params(users: T::Array[StringKeyHash]).returns(StreamChat::StreamResponse) }
     def update_users(users)
       warn '[DEPRECATION] `update_users` is deprecated.  Please use `upsert_users` instead.'
       upsert_users(users)
     end
 
     # @deprecated Use {#upsert_user} instead.
-    T::Sig::WithoutRuntime.sig { params(user: StringKeyHash).returns(StreamChat::StreamResponse) }
+    sig { params(user: StringKeyHash).returns(StreamChat::StreamResponse) }
     def update_user(user)
       warn '[DEPRECATION] `update_user` is deprecated.  Please use `upsert_user` instead.'
       upsert_user(user)
     end
 
     # Creates or updates users.
-    T::Sig::WithoutRuntime.sig { params(users: T::Array[StringKeyHash]).returns(StreamChat::StreamResponse) }
+    sig { params(users: T::Array[StringKeyHash]).returns(StreamChat::StreamResponse) }
     def upsert_users(users)
       payload = {}
       users.each do |user|
@@ -234,25 +231,25 @@ module StreamChat
     end
 
     # Creates or updates a user.
-    T::Sig::WithoutRuntime.sig { params(user: StringKeyHash).returns(StreamChat::StreamResponse) }
+    sig { params(user: StringKeyHash).returns(StreamChat::StreamResponse) }
     def upsert_user(user)
       upsert_users([user])
     end
 
     # Updates multiple users partially.
-    T::Sig::WithoutRuntime.sig { params(updates: T::Array[StringKeyHash]).returns(StreamChat::StreamResponse) }
+    sig { params(updates: T::Array[StringKeyHash]).returns(StreamChat::StreamResponse) }
     def update_users_partial(updates)
       patch('users', data: { users: updates })
     end
 
     # Updates a single user partially.
-    T::Sig::WithoutRuntime.sig { params(update: StringKeyHash).returns(StreamChat::StreamResponse) }
+    sig { params(update: StringKeyHash).returns(StreamChat::StreamResponse) }
     def update_user_partial(update)
       update_users_partial([update])
     end
 
     # Deletes a user synchronously.
-    T::Sig::WithoutRuntime.sig { params(user_id: String, options: T.untyped).returns(StreamChat::StreamResponse) }
+    sig { params(user_id: String, options: T.untyped).returns(StreamChat::StreamResponse) }
     def delete_user(user_id, **options)
       delete("users/#{user_id}", params: options)
     end
@@ -260,20 +257,20 @@ module StreamChat
     # Deactivates a user.
     # Deactivated users cannot connect to Stream Chat, and can't send or receive messages.
     # To reactivate a user, use `reactivate_user` method.
-    T::Sig::WithoutRuntime.sig { params(user_id: String, options: T.untyped).returns(StreamChat::StreamResponse) }
+    sig { params(user_id: String, options: T.untyped).returns(StreamChat::StreamResponse) }
     def deactivate_user(user_id, **options)
       post("users/#{user_id}/deactivate", params: options)
     end
 
     # Reactivates a deactivated user. Use deactivate_user to deactivate a user.
-    T::Sig::WithoutRuntime.sig { params(user_id: String, options: T.untyped).returns(StreamChat::StreamResponse) }
+    sig { params(user_id: String, options: T.untyped).returns(StreamChat::StreamResponse) }
     def reactivate_user(user_id, **options)
       post("users/#{user_id}/reactivate", params: options)
     end
 
     # Exports a user. It exports a user and returns an object
     # containing all of it's data.
-    T::Sig::WithoutRuntime.sig { params(user_id: String, options: T.untyped).returns(StreamChat::StreamResponse) }
+    sig { params(user_id: String, options: T.untyped).returns(StreamChat::StreamResponse) }
     def export_user(user_id, **options)
       get("users/#{user_id}/export", params: options)
     end
@@ -282,7 +279,7 @@ module StreamChat
     # When a user is banned, they will not be allowed to post messages until the
     # ban is removed or expired but will be able to connect to Chat and to channels as before.
     # To unban a user, use `unban_user` method.
-    T::Sig::WithoutRuntime.sig { params(target_id: String, options: T.untyped).returns(StreamChat::StreamResponse) }
+    sig { params(target_id: String, options: T.untyped).returns(StreamChat::StreamResponse) }
     def ban_user(target_id, **options)
       payload = { target_user_id: target_id }.merge(options)
       post('moderation/ban', data: payload)
@@ -290,7 +287,7 @@ module StreamChat
 
     # Unbans a user.
     # To ban a user, use `ban_user` method.
-    T::Sig::WithoutRuntime.sig { params(target_id: String, options: T.untyped).returns(StreamChat::StreamResponse) }
+    sig { params(target_id: String, options: T.untyped).returns(StreamChat::StreamResponse) }
     def unban_user(target_id, **options)
       params = { target_user_id: target_id }.merge(options)
       delete('moderation/ban', params: params)
@@ -301,7 +298,7 @@ module StreamChat
     # but any message sent during the will only be visible to the messages author
     # and invisible to other users of the App.
     # To remove a shadow ban, use `remove_shadow_ban` method.
-    T::Sig::WithoutRuntime.sig { params(target_id: String, options: T.untyped).returns(StreamChat::StreamResponse) }
+    sig { params(target_id: String, options: T.untyped).returns(StreamChat::StreamResponse) }
     def shadow_ban(target_id, **options)
       payload = { target_user_id: target_id, shadow: true }.merge(options)
       post('moderation/ban', data: payload)
@@ -309,28 +306,28 @@ module StreamChat
 
     # Removes a shadow ban of a user.
     # To shadow ban a user, use `shadow_ban` method.
-    T::Sig::WithoutRuntime.sig { params(target_id: String, options: T.untyped).returns(StreamChat::StreamResponse) }
+    sig { params(target_id: String, options: T.untyped).returns(StreamChat::StreamResponse) }
     def remove_shadow_ban(target_id, **options)
       params = { target_user_id: target_id, shadow: true }.merge(options)
       delete('moderation/ban', params: params)
     end
 
     # Mutes a user.
-    T::Sig::WithoutRuntime.sig { params(target_id: String, user_id: String).returns(StreamChat::StreamResponse) }
+    sig { params(target_id: String, user_id: String).returns(StreamChat::StreamResponse) }
     def mute_user(target_id, user_id)
       payload = { target_id: target_id, user_id: user_id }
       post('moderation/mute', data: payload)
     end
 
     # Unmutes a user.
-    T::Sig::WithoutRuntime.sig { params(target_id: String, user_id: String).returns(StreamChat::StreamResponse) }
+    sig { params(target_id: String, user_id: String).returns(StreamChat::StreamResponse) }
     def unmute_user(target_id, user_id)
       payload = { target_id: target_id, user_id: user_id }
       post('moderation/unmute', data: payload)
     end
 
     # Marks all messages as read for a user.
-    T::Sig::WithoutRuntime.sig { params(user_id: String).returns(StreamChat::StreamResponse) }
+    sig { params(user_id: String).returns(StreamChat::StreamResponse) }
     def mark_all_read(user_id)
       payload = { user: { id: user_id } }
       post('channels/read', data: payload)
@@ -342,7 +339,7 @@ module StreamChat
     # promote content. Pinning a message is, by default, restricted to certain user roles,
     # but this is flexible. Each channel can have multiple pinned messages and these can be created
     # or updated with or without an expiration.
-    T::Sig::WithoutRuntime.sig { params(message_id: String, user_id: String, expiration: T.nilable(String)).returns(StreamChat::StreamResponse) }
+    sig { params(message_id: String, user_id: String, expiration: T.nilable(String)).returns(StreamChat::StreamResponse) }
     def pin_message(message_id, user_id, expiration: nil)
       updates = {
         set: {
@@ -354,7 +351,7 @@ module StreamChat
     end
 
     # Unpins a message.
-    T::Sig::WithoutRuntime.sig { params(message_id: String, user_id: String).returns(StreamChat::StreamResponse) }
+    sig { params(message_id: String, user_id: String).returns(StreamChat::StreamResponse) }
     def unpin_message(message_id, user_id)
       updates = {
         set: {
@@ -366,7 +363,7 @@ module StreamChat
 
     # Updates a message. Fully overwrites a message.
     # For partial update, use `update_message_partial` method.
-    T::Sig::WithoutRuntime.sig { params(message: StringKeyHash).returns(StreamChat::StreamResponse) }
+    sig { params(message: StringKeyHash).returns(StreamChat::StreamResponse) }
     def update_message(message)
       raise ArgumentError, 'message must have an id' unless message.key? 'id'
 
@@ -376,7 +373,7 @@ module StreamChat
     # Updates a message partially.
     # A partial update can be used to set and unset specific fields when
     # it is necessary to retain additional data fields on the object. AKA a patch style update.
-    T::Sig::WithoutRuntime.sig { params(message_id: String, updates: StringKeyHash, user_id: T.nilable(String), options: T.untyped).returns(StreamChat::StreamResponse) }
+    sig { params(message_id: String, updates: StringKeyHash, user_id: T.nilable(String), options: T.untyped).returns(StreamChat::StreamResponse) }
     def update_message_partial(message_id, updates, user_id: nil, **options)
       params = updates.merge(options)
       params['user'] = { id: user_id } if user_id
@@ -384,7 +381,7 @@ module StreamChat
     end
 
     # Deletes a message.
-    T::Sig::WithoutRuntime.sig { params(message_id: String, options: T.untyped).returns(StreamChat::StreamResponse) }
+    sig { params(message_id: String, options: T.untyped).returns(StreamChat::StreamResponse) }
     def delete_message(message_id, **options)
       delete("messages/#{message_id}", params: options)
     end
@@ -396,7 +393,7 @@ module StreamChat
     # 2) User Search: you can add the banned:true condition to your search. Please note that
     # this will only return users that were banned at the app-level and not the ones
     # that were banned only on channels.
-    T::Sig::WithoutRuntime.sig { params(filter_conditions: StringKeyHash, sort: T.nilable(T::Hash[String, Integer]), options: T.untyped).returns(StreamChat::StreamResponse) }
+    sig { params(filter_conditions: StringKeyHash, sort: T.nilable(T::Hash[String, Integer]), options: T.untyped).returns(StreamChat::StreamResponse) }
     def query_banned_users(filter_conditions, sort: nil, **options)
       params = options.merge({
                                filter_conditions: filter_conditions,
@@ -407,7 +404,7 @@ module StreamChat
 
     # Allows you to search for users and see if they are online/offline.
     # You can filter and sort on the custom fields you've set for your user, the user id, and when the user was last active.
-    T::Sig::WithoutRuntime.sig { params(filter_conditions: StringKeyHash, sort: T.nilable(T::Hash[String, Integer]), options: T.untyped).returns(StreamChat::StreamResponse) }
+    sig { params(filter_conditions: StringKeyHash, sort: T.nilable(T::Hash[String, Integer]), options: T.untyped).returns(StreamChat::StreamResponse) }
     def query_users(filter_conditions, sort: nil, **options)
       params = options.merge({
                                filter_conditions: filter_conditions,
@@ -422,7 +419,7 @@ module StreamChat
     # Multiple filters can be combined using AND, OR logical operators, each filter can use its
     # comparison (equality, inequality, greater than, greater or equal, etc.).
     # You can find the complete list of supported operators in the query syntax section of the docs.
-    T::Sig::WithoutRuntime.sig { params(filter_conditions: StringKeyHash, sort: T.nilable(T::Hash[String, Integer]), options: T.untyped).returns(StreamChat::StreamResponse) }
+    sig { params(filter_conditions: StringKeyHash, sort: T.nilable(T::Hash[String, Integer]), options: T.untyped).returns(StreamChat::StreamResponse) }
     def query_channels(filter_conditions, sort: nil, **options)
       data = { state: true, watch: false, presence: false }
       data = data.merge(options).merge({
@@ -433,32 +430,32 @@ module StreamChat
     end
 
     # Creates a new channel type.
-    T::Sig::WithoutRuntime.sig { params(data: StringKeyHash).returns(StreamChat::StreamResponse) }
+    sig { params(data: StringKeyHash).returns(StreamChat::StreamResponse) }
     def create_channel_type(data)
       data['commands'] = ['all'] unless data.key?('commands') || data['commands'].nil? || data['commands'].empty?
       post('channeltypes', data: data)
     end
 
     # Returns a channel types.
-    T::Sig::WithoutRuntime.sig { params(channel_type: String).returns(StreamChat::StreamResponse) }
+    sig { params(channel_type: String).returns(StreamChat::StreamResponse) }
     def get_channel_type(channel_type)
       get("channeltypes/#{channel_type}")
     end
 
     # Returns a list of channel types.
-    T::Sig::WithoutRuntime.sig { returns(StreamChat::StreamResponse) }
+    sig { returns(StreamChat::StreamResponse) }
     def list_channel_types
       get('channeltypes')
     end
 
     # Updates a channel type.
-    T::Sig::WithoutRuntime.sig { params(channel_type: String, options: T.untyped).returns(StreamChat::StreamResponse) }
+    sig { params(channel_type: String, options: T.untyped).returns(StreamChat::StreamResponse) }
     def update_channel_type(channel_type, **options)
       put("channeltypes/#{channel_type}", data: options)
     end
 
     # Deletes a channel type.
-    T::Sig::WithoutRuntime.sig { params(channel_type: String).returns(StreamChat::StreamResponse) }
+    sig { params(channel_type: String).returns(StreamChat::StreamResponse) }
     def delete_channel_type(channel_type)
       delete("channeltypes/#{channel_type}")
     end
@@ -471,13 +468,13 @@ module StreamChat
     #
     # @return [StreamChat::Channel]
     #
-    T::Sig::WithoutRuntime.sig { params(channel_type: String, channel_id: T.nilable(String), data: T.nilable(StringKeyHash)).returns(StreamChat::Channel) }
+    sig { params(channel_type: String, channel_id: T.nilable(String), data: T.nilable(StringKeyHash)).returns(StreamChat::Channel) }
     def channel(channel_type, channel_id: nil, data: nil)
       StreamChat::Channel.new(self, channel_type, channel_id, data)
     end
 
     # Adds a device to a user.
-    T::Sig::WithoutRuntime.sig { params(device_id: String, push_provider: String, user_id: String, push_provider_name: T.nilable(String)).returns(StreamChat::StreamResponse) }
+    sig { params(device_id: String, push_provider: String, user_id: String, push_provider_name: T.nilable(String)).returns(StreamChat::StreamResponse) }
     def add_device(device_id, push_provider, user_id, push_provider_name = nil)
       post('devices', data: {
              id: device_id,
@@ -488,20 +485,20 @@ module StreamChat
     end
 
     # Delete a device.
-    T::Sig::WithoutRuntime.sig { params(device_id: String, user_id: String).returns(StreamChat::StreamResponse) }
+    sig { params(device_id: String, user_id: String).returns(StreamChat::StreamResponse) }
     def delete_device(device_id, user_id)
       delete('devices', params: { id: device_id, user_id: user_id })
     end
 
     # Returns a list of devices.
-    T::Sig::WithoutRuntime.sig { params(user_id: String).returns(StreamChat::StreamResponse) }
+    sig { params(user_id: String).returns(StreamChat::StreamResponse) }
     def get_devices(user_id)
       get('devices', params: { user_id: user_id })
     end
 
     # Get rate limit quotas and usage.
     # If no params are toggled, all limits for all endpoints are returned.
-    T::Sig::WithoutRuntime.sig { params(server_side: T::Boolean, android: T::Boolean, ios: T::Boolean, web: T::Boolean, endpoints: T::Array[String]).returns(StreamChat::StreamResponse) }
+    sig { params(server_side: T::Boolean, android: T::Boolean, ios: T::Boolean, web: T::Boolean, endpoints: T::Array[String]).returns(StreamChat::StreamResponse) }
     def get_rate_limits(server_side: false, android: false, ios: false, web: false, endpoints: [])
       params = {}
       params['server_side'] = server_side if server_side
@@ -514,14 +511,14 @@ module StreamChat
     end
 
     # Verify the signature added to a webhook event.
-    T::Sig::WithoutRuntime.sig { params(request_body: String, x_signature: String).returns(T::Boolean) }
+    sig { params(request_body: String, x_signature: String).returns(T::Boolean) }
     def verify_webhook(request_body, x_signature)
       signature = OpenSSL::HMAC.hexdigest('SHA256', @api_secret, request_body)
       signature == x_signature
     end
 
     # Allows you to send custom events to a connected user.
-    T::Sig::WithoutRuntime.sig { params(user_id: String, event: StringKeyHash).returns(StreamChat::StreamResponse) }
+    sig { params(user_id: String, event: StringKeyHash).returns(StreamChat::StreamResponse) }
     def send_user_event(user_id, event)
       post("users/#{user_id}/event", data: event)
     end
@@ -529,13 +526,13 @@ module StreamChat
     # Translates an existing message to another language. The source language
     # is inferred from the user language or detected automatically by analyzing its text.
     # If possible it is recommended to store the user language. See the documentation.
-    T::Sig::WithoutRuntime.sig { params(message_id: String, language: String).returns(StreamChat::StreamResponse) }
+    sig { params(message_id: String, language: String).returns(StreamChat::StreamResponse) }
     def translate_message(message_id, language)
       post("messages/#{message_id}/translate", data: { language: language })
     end
 
     # Runs a message command action.
-    T::Sig::WithoutRuntime.sig { params(message_id: String, data: StringKeyHash).returns(StreamChat::StreamResponse) }
+    sig { params(message_id: String, data: StringKeyHash).returns(StreamChat::StreamResponse) }
     def run_message_action(message_id, data)
       post("messages/#{message_id}/action", data: data)
     end
@@ -546,7 +543,7 @@ module StreamChat
     # Support and livestreams are common use cases for guests users because really
     # often you want a visitor to be able to use chat on your application without (or before)
     # they have a regular user account.
-    T::Sig::WithoutRuntime.sig { params(user: StringKeyHash).returns(StreamChat::StreamResponse) }
+    sig { params(user: StringKeyHash).returns(StreamChat::StreamResponse) }
     def create_guest(user)
       post('guests', data: user)
     end
@@ -558,7 +555,7 @@ module StreamChat
     # of the most common profane words.
     # You can manage your own block lists via the Stream dashboard or APIs to a manage
     # blocklists and configure your channel types to use them.
-    T::Sig::WithoutRuntime.sig { returns(StreamChat::StreamResponse) }
+    sig { returns(StreamChat::StreamResponse) }
     def list_blocklists
       get('blocklists')
     end
@@ -570,7 +567,7 @@ module StreamChat
     # of the most common profane words.
     # You can manage your own block lists via the Stream dashboard or APIs to a manage
     # blocklists and configure your channel types to use them.
-    T::Sig::WithoutRuntime.sig { params(name: String).returns(StreamChat::StreamResponse) }
+    sig { params(name: String).returns(StreamChat::StreamResponse) }
     def get_blocklist(name)
       get("blocklists/#{name}")
     end
@@ -582,7 +579,7 @@ module StreamChat
     # of the most common profane words.
     # You can manage your own block lists via the Stream dashboard or APIs to a manage
     # blocklists and configure your channel types to use them.
-    T::Sig::WithoutRuntime.sig { params(name: String, words: StringKeyHash).returns(StreamChat::StreamResponse) }
+    sig { params(name: String, words: T::Array[String]).returns(StreamChat::StreamResponse) }
     def create_blocklist(name, words)
       post('blocklists', data: { name: name, words: words })
     end
@@ -594,7 +591,7 @@ module StreamChat
     # of the most common profane words.
     # You can manage your own block lists via the Stream dashboard or APIs to a manage
     # blocklists and configure your channel types to use them.
-    T::Sig::WithoutRuntime.sig { params(name: String, words: StringKeyHash).returns(StreamChat::StreamResponse) }
+    sig { params(name: String, words: T::Array[String]).returns(StreamChat::StreamResponse) }
     def update_blocklist(name, words)
       put("blocklists/#{name}", data: { words: words })
     end
@@ -606,7 +603,7 @@ module StreamChat
     # of the most common profane words.
     # You can manage your own block lists via the Stream dashboard or APIs to a manage
     # blocklists and configure your channel types to use them.
-    T::Sig::WithoutRuntime.sig { params(name: String).returns(StreamChat::StreamResponse) }
+    sig { params(name: String).returns(StreamChat::StreamResponse) }
     def delete_blocklist(name)
       delete("blocklists/#{name}")
     end
@@ -616,51 +613,51 @@ module StreamChat
     # Channel exports are created asynchronously, you can use the Task ID returned by
     # the APIs to keep track of the status and to download the final result when it is ready.
     # Use `get_task` to check the status of the export.
-    T::Sig::WithoutRuntime.sig { params(channels: StringKeyHash, options: T.untyped).returns(StreamChat::StreamResponse) }
+    sig { params(channels: StringKeyHash, options: T.untyped).returns(StreamChat::StreamResponse) }
     def export_channels(*channels, **options)
       post('export_channels', data: { channels: channels, **options })
     end
 
     # Returns the status of a channel export. It contains the URL to the JSON file.
-    T::Sig::WithoutRuntime.sig { params(task_id: String).returns(StreamChat::StreamResponse) }
+    sig { params(task_id: String).returns(StreamChat::StreamResponse) }
     def get_export_channel_status(task_id)
       get("export_channels/#{task_id}")
     end
 
     # Returns the status of a task.
-    T::Sig::WithoutRuntime.sig { params(task_id: String).returns(StreamChat::StreamResponse) }
+    sig { params(task_id: String).returns(StreamChat::StreamResponse) }
     def get_task(task_id)
       get("tasks/#{task_id}")
     end
 
     # Delete users asynchronously. Use `get_task` to check the status of the task.
-    T::Sig::WithoutRuntime.sig { params(user_ids: T::Array[String], user: String, messages: T.nilable(StringKeyHash), conversations: T.nilable(String)).returns(StreamChat::StreamResponse) }
+    sig { params(user_ids: T::Array[String], user: String, messages: T.nilable(String), conversations: T.nilable(String)).returns(StreamChat::StreamResponse) }
     def delete_users(user_ids, user: SOFT_DELETE, messages: nil, conversations: nil)
       post('users/delete', data: { user_ids: user_ids, user: user, messages: messages, conversations: conversations })
     end
 
     # Deletes multiple channels. This is an asynchronous operation and the returned value is a task Id.
     # You can use `get_task` method to check the status of the task.
-    T::Sig::WithoutRuntime.sig { params(cids: T::Array[String], hard_delete: T::Boolean).returns(StreamChat::StreamResponse) }
+    sig { params(cids: T::Array[String], hard_delete: T::Boolean).returns(StreamChat::StreamResponse) }
     def delete_channels(cids, hard_delete: false)
       post('channels/delete', data: { cids: cids, hard_delete: hard_delete })
     end
 
     # Revoke tokens for an application issued since the given date.
-    T::Sig::WithoutRuntime.sig { params(before: T.any(DateTime, String)).returns(StreamChat::StreamResponse) }
+    sig { params(before: T.any(DateTime, String)).returns(StreamChat::StreamResponse) }
     def revoke_tokens(before)
       before = T.cast(before, DateTime).rfc3339 if before.instance_of?(DateTime)
       update_app_settings({ 'revoke_tokens_issued_before' => before })
     end
 
     # Revoke tokens for a user issued since the given date.
-    T::Sig::WithoutRuntime.sig { params(user_id: String, before: T.any(DateTime, String)).returns(StreamChat::StreamResponse) }
+    sig { params(user_id: String, before: T.any(DateTime, String)).returns(StreamChat::StreamResponse) }
     def revoke_user_token(user_id, before)
       revoke_users_token([user_id], before)
     end
 
     # Revoke tokens for users issued since.
-    T::Sig::WithoutRuntime.sig { params(user_ids: T::Array[String], before: T.any(DateTime, String)).returns(StreamChat::StreamResponse) }
+    sig { params(user_ids: T::Array[String], before: T.any(DateTime, String)).returns(StreamChat::StreamResponse) }
     def revoke_users_token(user_ids, before)
       before = T.cast(before, DateTime).rfc3339 if before.instance_of?(DateTime)
 
@@ -676,27 +673,27 @@ module StreamChat
       update_users_partial(updates)
     end
 
-    T::Sig::WithoutRuntime.sig { params(relative_url: String, params: T.nilable(StringKeyHash), data: T.nilable(StringKeyHash)).returns(StreamChat::StreamResponse) }
+    sig { params(relative_url: String, params: T.nilable(StringKeyHash), data: T.nilable(StringKeyHash)).returns(StreamChat::StreamResponse) }
     def put(relative_url, params: nil, data: nil)
       make_http_request(:put, relative_url, params: params, data: data)
     end
 
-    T::Sig::WithoutRuntime.sig { params(relative_url: String, params: T.nilable(StringKeyHash), data: T.nilable(StringKeyHash)).returns(StreamChat::StreamResponse) }
+    sig { params(relative_url: String, params: T.nilable(StringKeyHash), data: T.nilable(StringKeyHash)).returns(StreamChat::StreamResponse) }
     def post(relative_url, params: nil, data: nil)
       make_http_request(:post, relative_url, params: params, data: data)
     end
 
-    T::Sig::WithoutRuntime.sig { params(relative_url: String, params: T.nilable(StringKeyHash)).returns(StreamChat::StreamResponse) }
+    sig { params(relative_url: String, params: T.nilable(StringKeyHash)).returns(StreamChat::StreamResponse) }
     def get(relative_url, params: nil)
       make_http_request(:get, relative_url, params: params)
     end
 
-    T::Sig::WithoutRuntime.sig { params(relative_url: String, params: T.nilable(StringKeyHash)).returns(StreamChat::StreamResponse) }
+    sig { params(relative_url: String, params: T.nilable(StringKeyHash)).returns(StreamChat::StreamResponse) }
     def delete(relative_url, params: nil)
       make_http_request(:delete, relative_url, params: params)
     end
 
-    T::Sig::WithoutRuntime.sig { params(relative_url: String, params: T.nilable(StringKeyHash), data: T.nilable(StringKeyHash)).returns(StreamChat::StreamResponse) }
+    sig { params(relative_url: String, params: T.nilable(StringKeyHash), data: T.nilable(StringKeyHash)).returns(StreamChat::StreamResponse) }
     def patch(relative_url, params: nil, data: nil)
       make_http_request(:patch, relative_url, params: params, data: data)
     end
@@ -705,7 +702,7 @@ module StreamChat
     #
     # This functionality defaults to using the Stream CDN. If you would like, you can
     # easily change the logic to upload to your own CDN of choice.
-    T::Sig::WithoutRuntime.sig { params(relative_url: String, file_url: String, user: StringKeyHash, content_type: T.nilable(String)).returns(StreamChat::StreamResponse) }
+    sig { params(relative_url: String, file_url: String, user: StringKeyHash, content_type: T.nilable(String)).returns(StreamChat::StreamResponse) }
     def send_file(relative_url, file_url, user, content_type = nil)
       url = [@base_url, relative_url].join('/')
 
@@ -725,7 +722,7 @@ module StreamChat
     end
 
     # Check push notification settings.
-    T::Sig::WithoutRuntime.sig { params(push_data: StringKeyHash).returns(StreamChat::StreamResponse) }
+    sig { params(push_data: StringKeyHash).returns(StreamChat::StreamResponse) }
     def check_push(push_data)
       post('check_push', data: push_data)
     end
@@ -733,103 +730,103 @@ module StreamChat
     # Check SQS Push settings
     #
     # When no parameters are given, the current SQS app settings are used.
-    T::Sig::WithoutRuntime.sig { params(sqs_key: T.nilable(String), sqs_secret: T.nilable(String), sqs_url: T.nilable(String)).returns(StreamChat::StreamResponse) }
+    sig { params(sqs_key: T.nilable(String), sqs_secret: T.nilable(String), sqs_url: T.nilable(String)).returns(StreamChat::StreamResponse) }
     def check_sqs(sqs_key = nil, sqs_secret = nil, sqs_url = nil)
       post('check_sqs', data: { sqs_key: sqs_key, sqs_secret: sqs_secret, sqs_url: sqs_url })
     end
 
     # Creates a new command.
-    T::Sig::WithoutRuntime.sig { params(command: StringKeyHash).returns(StreamChat::StreamResponse) }
+    sig { params(command: StringKeyHash).returns(StreamChat::StreamResponse) }
     def create_command(command)
       post('commands', data: command)
     end
 
     # Gets a comamnd.
-    T::Sig::WithoutRuntime.sig { params(name: String).returns(StreamChat::StreamResponse) }
+    sig { params(name: String).returns(StreamChat::StreamResponse) }
     def get_command(name)
       get("commands/#{name}")
     end
 
     # Updates a command.
-    T::Sig::WithoutRuntime.sig { params(name: String, command: StringKeyHash).returns(StreamChat::StreamResponse) }
+    sig { params(name: String, command: StringKeyHash).returns(StreamChat::StreamResponse) }
     def update_command(name, command)
       put("commands/#{name}", data: command)
     end
 
     # Deletes a command.
-    T::Sig::WithoutRuntime.sig { params(name: String).returns(StreamChat::StreamResponse) }
+    sig { params(name: String).returns(StreamChat::StreamResponse) }
     def delete_command(name)
       delete("commands/#{name}")
     end
 
     # Lists all commands.
-    T::Sig::WithoutRuntime.sig { returns(StreamChat::StreamResponse) }
+    sig { returns(StreamChat::StreamResponse) }
     def list_commands
       get('commands')
     end
 
     # Lists all permissions.
-    T::Sig::WithoutRuntime.sig { returns(StreamChat::StreamResponse) }
+    sig { returns(StreamChat::StreamResponse) }
     def list_permissions
       get('permissions')
     end
 
     # Gets a permission.
-    T::Sig::WithoutRuntime.sig { params(id: String).returns(StreamChat::StreamResponse) }
+    sig { params(id: String).returns(StreamChat::StreamResponse) }
     def get_permission(id)
       get("permissions/#{id}")
     end
 
     # Creates a new permission.
-    T::Sig::WithoutRuntime.sig { params(permission: StringKeyHash).returns(StreamChat::StreamResponse) }
+    sig { params(permission: StringKeyHash).returns(StreamChat::StreamResponse) }
     def create_permission(permission)
       post('permissions', data: permission)
     end
 
     # Updates a permission.
-    T::Sig::WithoutRuntime.sig { params(id: String, permission: StringKeyHash).returns(StreamChat::StreamResponse) }
+    sig { params(id: String, permission: StringKeyHash).returns(StreamChat::StreamResponse) }
     def update_permission(id, permission)
       put("permissions/#{id}", data: permission)
     end
 
     # Deletes a permission by id.
-    T::Sig::WithoutRuntime.sig { params(id: String).returns(StreamChat::StreamResponse) }
+    sig { params(id: String).returns(StreamChat::StreamResponse) }
     def delete_permission(id)
       delete("permissions/#{id}")
     end
 
     # Create a new role.
-    T::Sig::WithoutRuntime.sig { params(name: String).returns(StreamChat::StreamResponse) }
+    sig { params(name: String).returns(StreamChat::StreamResponse) }
     def create_role(name)
       post('roles', data: { name: name })
     end
 
     # Delete a role by name.
-    T::Sig::WithoutRuntime.sig { params(name: String).returns(StreamChat::StreamResponse) }
+    sig { params(name: String).returns(StreamChat::StreamResponse) }
     def delete_role(name)
       delete("roles/#{name}")
     end
 
     # List all roles.
-    T::Sig::WithoutRuntime.sig { returns(StreamChat::StreamResponse) }
+    sig { returns(StreamChat::StreamResponse) }
     def list_roles
       get('roles')
     end
 
     # Create or update a push provider.
-    T::Sig::WithoutRuntime.sig { params(push_provider: StringKeyHash).returns(StreamChat::StreamResponse) }
+    sig { params(push_provider: StringKeyHash).returns(StreamChat::StreamResponse) }
     def upsert_push_provider(push_provider)
       post('push_providers', data: { push_provider: push_provider })
     end
 
     # Delete a push provider by type and name.
-    T::Sig::WithoutRuntime.sig { params(type: String, name: String).returns(StreamChat::StreamResponse) }
+    sig { params(type: String, name: String).returns(StreamChat::StreamResponse) }
     def delete_push_provider(type, name)
       delete("push_providers/#{type}/#{name}")
     end
 
     # Lists all push providers.
-    T::Sig::WithoutRuntime.sig { returns(StreamChat::StreamResponse) }
+    sig { returns(StreamChat::StreamResponse) }
     def list_push_providers
       get('push_providers')
     end
@@ -839,7 +836,7 @@ module StreamChat
     #   url_resp = client.create_import_url('myfile.json')
     #   Faraday.put(url_resp['upload_url'], File.read('myfile.json'), 'Content-Type' => 'application/json')
     #   client.create_import(url_resp['path'], 'upsert')
-    T::Sig::WithoutRuntime.sig { params(filename: String).returns(StreamChat::StreamResponse) }
+    sig { params(filename: String).returns(StreamChat::StreamResponse) }
     def create_import_url(filename)
       post('import_urls', data: { filename: filename })
     end
@@ -849,120 +846,120 @@ module StreamChat
     #   url_resp = client.create_import_url('myfile.json')
     #   Faraday.put(url_resp['upload_url'], File.read('myfile.json'), 'Content-Type' => 'application/json')
     #   client.create_import(url_resp['path'], 'upsert')
-    T::Sig::WithoutRuntime.sig { params(path: String, mode: String).returns(StreamChat::StreamResponse) }
+    sig { params(path: String, mode: String).returns(StreamChat::StreamResponse) }
     def create_import(path, mode)
       post('imports', data: { path: path, mode: mode })
     end
 
     # Returns an import by id.
-    T::Sig::WithoutRuntime.sig { params(id: String).returns(StreamChat::StreamResponse) }
+    sig { params(id: String).returns(StreamChat::StreamResponse) }
     def get_import(id)
       get("imports/#{id}")
     end
 
     # Lists imports. Options dictionary can contain 'offset' and 'limit' keys for pagination.
-    T::Sig::WithoutRuntime.sig { params(options: T.untyped).returns(StreamChat::StreamResponse) }
+    sig { params(options: T.untyped).returns(StreamChat::StreamResponse) }
     def list_imports(options)
       get('imports', params: options)
     end
 
     # Creates a campaign.
-    T::Sig::WithoutRuntime.sig { params(campaign: StringKeyHash).returns(StreamChat::StreamResponse) }
+    sig { params(campaign: StringKeyHash).returns(StreamChat::StreamResponse) }
     def create_campaign(campaign)
       post('campaigns', data: { campaign: campaign })
     end
 
     # Gets a campaign.
-    T::Sig::WithoutRuntime.sig { params(campaign_id: String).returns(StreamChat::StreamResponse) }
+    sig { params(campaign_id: String).returns(StreamChat::StreamResponse) }
     def get_campaign(campaign_id)
       get("campaigns/#{campaign_id}")
     end
 
     # Lists all campaigns. Options dictionary can contain 'offset' and 'limit' keys for pagination.
-    T::Sig::WithoutRuntime.sig { params(options: StringKeyHash).returns(StreamChat::StreamResponse) }
+    sig { params(options: StringKeyHash).returns(StreamChat::StreamResponse) }
     def list_campaigns(options)
       get('campaigns', params: options)
     end
 
     # Updates a campaign.
-    T::Sig::WithoutRuntime.sig { params(campaign_id: String, campaign: StringKeyHash).returns(StreamChat::StreamResponse) }
+    sig { params(campaign_id: String, campaign: StringKeyHash).returns(StreamChat::StreamResponse) }
     def update_campaign(campaign_id, campaign)
       put("campaigns/#{campaign_id}", data: { campaign: campaign })
     end
 
     # Deletes a campaign.
-    T::Sig::WithoutRuntime.sig { params(campaign_id: String).returns(StreamChat::StreamResponse) }
+    sig { params(campaign_id: String).returns(StreamChat::StreamResponse) }
     def delete_campaign(campaign_id)
       delete("campaigns/#{campaign_id}")
     end
 
     # Schedules a campaign.
-    T::Sig::WithoutRuntime.sig { params(campaign_id: String, send_at: Integer).returns(StreamChat::StreamResponse) }
+    sig { params(campaign_id: String, send_at: Integer).returns(StreamChat::StreamResponse) }
     def schedule_campaign(campaign_id, send_at)
       patch("campaigns/#{campaign_id}/schedule", data: { send_at: send_at })
     end
 
     # Stops a campaign.
-    T::Sig::WithoutRuntime.sig { params(campaign_id: String).returns(StreamChat::StreamResponse) }
+    sig { params(campaign_id: String).returns(StreamChat::StreamResponse) }
     def stop_campaign(campaign_id)
       patch("campaigns/#{campaign_id}/stop")
     end
 
     # Resumes a campaign.
-    T::Sig::WithoutRuntime.sig { params(campaign_id: String).returns(StreamChat::StreamResponse) }
+    sig { params(campaign_id: String).returns(StreamChat::StreamResponse) }
     def resume_campaign(campaign_id)
       patch("campaigns/#{campaign_id}/resume")
     end
 
     # Tests a campaign.
-    T::Sig::WithoutRuntime.sig { params(campaign_id: String, users: T::Array[StringKeyHash]).returns(StreamChat::StreamResponse) }
+    sig { params(campaign_id: String, users: T::Array[StringKeyHash]).returns(StreamChat::StreamResponse) }
     def test_campaign(campaign_id, users)
       post("campaigns/#{campaign_id}/test", data: { users: users })
     end
 
     # Creates a campaign segment.
-    T::Sig::WithoutRuntime.sig { params(segment: StringKeyHash).returns(StreamChat::StreamResponse) }
+    sig { params(segment: StringKeyHash).returns(StreamChat::StreamResponse) }
     def create_segment(segment)
       post('segments', data: { segment: segment })
     end
 
     # Gets a campaign segment.
-    T::Sig::WithoutRuntime.sig { params(segment_id: String).returns(StreamChat::StreamResponse) }
+    sig { params(segment_id: String).returns(StreamChat::StreamResponse) }
     def get_segment(segment_id)
       get("segments/#{segment_id}")
     end
 
     # Lists all campaign segments. Options dictionary can contain 'offset' and 'limit' keys for pagination.
-    T::Sig::WithoutRuntime.sig { params(options: StringKeyHash).returns(StreamChat::StreamResponse) }
+    sig { params(options: StringKeyHash).returns(StreamChat::StreamResponse) }
     def list_segments(options)
       get('segments', params: options)
     end
 
     # Updates a campaign segment.
-    T::Sig::WithoutRuntime.sig { params(segment_id: String, segment: StringKeyHash).returns(StreamChat::StreamResponse) }
+    sig { params(segment_id: String, segment: StringKeyHash).returns(StreamChat::StreamResponse) }
     def update_segment(segment_id, segment)
       put("segments/#{segment_id}", data: { segment: segment })
     end
 
     # Deletes a campaign segment.
-    T::Sig::WithoutRuntime.sig { params(segment_id: String).returns(StreamChat::StreamResponse) }
+    sig { params(segment_id: String).returns(StreamChat::StreamResponse) }
     def delete_segment(segment_id)
       delete("segments/#{segment_id}")
     end
 
     private
 
-    T::Sig::WithoutRuntime.sig { returns(T::Hash[String, String]) }
+    sig { returns(T::Hash[String, String]) }
     def get_default_params
       { api_key: @api_key }
     end
 
-    T::Sig::WithoutRuntime.sig { returns(String) }
+    sig { returns(String) }
     def get_user_agent
       "stream-ruby-client-#{StreamChat::VERSION}"
     end
 
-    T::Sig::WithoutRuntime.sig { returns(T::Hash[String, String]) }
+    sig { returns(T::Hash[String, String]) }
     def get_default_headers
       {
         'Content-Type': 'application/json',
@@ -970,7 +967,7 @@ module StreamChat
       }
     end
 
-    T::Sig::WithoutRuntime.sig { params(response: Faraday::Response).returns(StreamChat::StreamResponse) }
+    sig { params(response: Faraday::Response).returns(StreamChat::StreamResponse) }
     def parse_response(response)
       begin
         parsed_result = JSON.parse(response.body)
@@ -982,7 +979,7 @@ module StreamChat
       StreamResponse.new(parsed_result, response)
     end
 
-    T::Sig::WithoutRuntime.sig { params(method: Symbol, relative_url: String, params: T.nilable(StringKeyHash), data: T.nilable(StringKeyHash)).returns(StreamChat::StreamResponse) }
+    sig { params(method: Symbol, relative_url: String, params: T.nilable(StringKeyHash), data: T.nilable(StringKeyHash)).returns(StreamChat::StreamResponse) }
     def make_http_request(method, relative_url, params: nil, data: nil)
       headers = get_default_headers
       headers['Authorization'] = @auth_token