stream-chat-ruby 2.20.0 → 2.21.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 36870782d8439c010ce69c4593b2a9007b25ea0c18f748ea8bc809507378b2cd
-  data.tar.gz: f5eeb52979560fa3be08059c71517dd5637ef317f78f9cf6ff27f2fabe8e3d61
+  metadata.gz: 800770eb3b23adf3a433b13784d19cd0d35c6bcc24d46e05687926d3e646fcad
+  data.tar.gz: 77c2fa8401f2d16e5aaaff3ba5e00b83f35388abc7875ba1bbd301fdf8e0f910
 SHA512:
-  metadata.gz: cdffeaa2e783243ca32b098034b27c5175993d480dd34d78b7e6b2538e2c788fef8bbcf4c32357a2ab48e14edfcee056c4b3018a0f2cc4fb1e2a09a4b5c22fb3
-  data.tar.gz: b2be01f9571c5ff952660fd046b35dd3fabe8920e3d3d58e50087253c74a57351ccee9b7fe5e0ccaa8fd154b64a20cd1046e6e4fd1662d1abbd1dc03ea1c5578
+  metadata.gz: e76da1cf10fb1f0a8d25f56eb77a0ad29898691a7cd9402efab643f483015adae91ba9344a21ff0d4e7ea233fda16ae2a73596afe8e52e9c342d86c9e62e4515
+  data.tar.gz: 7a898a5e6916344cecc340b175dbfb7e9e1884d3963465b593250320aad5b994213521932cb93e2e79f033f302d0f8748e2062ef494cb503c4979d0182db72a3

data/.rubocop.yml

@@ -2,6 +2,9 @@ AllCops:
   DisabledByDefault: false
   NewCops: enable
   TargetRubyVersion: 2.5
+  Exclude:
+    - sorbet/**/*.rbi
+    - vendor/bundle/**/*
 
 Layout/LineLength:
   Enabled: false

data/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+## [2.21.0](https://github.com/GetStream/stream-chat-ruby/compare/v2.20.0...v2.21.0) (2022-03-03)
+
+
+### Features
+
+* add options to delete message ([#80](https://github.com/GetStream/stream-chat-ruby/issues/80)) ([6a343e9](https://github.com/GetStream/stream-chat-ruby/commit/6a343e9fa9409150c27afc4246765f07bb12e571))
+* add sorbet type checker ([#83](https://github.com/GetStream/stream-chat-ruby/issues/83)) ([f2fcee5](https://github.com/GetStream/stream-chat-ruby/commit/f2fcee58ecc0c3b4016721e997c42c44753bba9a))
+
+
+### Bug Fixes
+
+* update app settings ([#86](https://github.com/GetStream/stream-chat-ruby/issues/86)) ([3f88185](https://github.com/GetStream/stream-chat-ruby/commit/3f88185117c5710e0b3e66f7f402f2c8969dec2f))
+
 ## [2.20.0](https://github.com/GetStream/stream-chat-ruby/compare/v2.19.0...v2.20.0) (2022-02-04)
 
 

data/CONTRIBUTING.md

@@ -0,0 +1,64 @@
+
+# :recycle: Contributing
+
+We welcome code changes that improve this library or fix a problem, please make sure to follow all best practices and add tests if applicable before submitting a Pull Request on Github. We are very happy to merge your code in the official repository. Make sure to sign our [Contributor License Agreement (CLA)](https://docs.google.com/forms/d/e/1FAIpQLScFKsKkAJI7mhCr7K9rEIOpqIDThrWxuvxnwUq2XkHyG154vQ/viewform) first. See our license file for more details.
+
+## Getting started
+
+### Install dependencies
+
+```shell
+$ bundle install --path vendor/bundle
+```
+
+### Run tests
+
+```shell
+$ STREAM_KEY=my_api_key STREAM_SECRET=my_api_secret bundle exec rake spec
+```
+
+### Linters and type check
+
+We use [Rubocop](https://github.com/rubocop/rubocop) for linting and [Sorbet](https://sorbet.org/) for type checking.
+
+To run them:
+```shell
+$ bundle exec rake rubocop
+$ bundle exec srb tc
+```
+
+These linters can be easily integrated into IDEs such as RubyMine or VS Code.
+
+For VS Code, just install the basic Ruby extension which handles Rubocop ([`rebornix.ruby`](https://marketplace.visualstudio.com/items?itemName=rebornix.Ruby)) and the official Sorbet one ([`sorbet.sorbet-vscode-extension`](https://marketplace.visualstudio.com/items?itemName=sorbet.sorbet-vscode-extension)).
+
+Recommended settings:
+```json
+{
+    "editor.formatOnSave": true,
+    "ruby.useBundler": true,
+    "ruby.lint": {
+        "rubocop": {
+            "useBundler": true, // enable rubocop via bundler
+        }
+    },
+    "ruby.format": "rubocop",
+    "ruby.useLanguageServer": true,
+    "sorbet.enabled": true
+}
+```
+
+### Commit message convention
+
+This repository follows a commit message convention in order to automatically generate the [CHANGELOG](./CHANGELOG.md). Make sure you follow the rules of [conventional commits](https://www.conventionalcommits.org/) when opening a pull request.
+
+### Releasing a new version (for Stream developers)
+
+In order to release new version you need to be a maintainer of the library.
+
+- Kick off a job called `initiate_release` ([link](https://github.com/GetStream/stream-chat-ruby/actions/workflows/initiate_release.yml)).
+
+The job creates a pull request with the changelog. Check if it looks good.
+
+- Merge the pull request.
+
+Once the PR is merged, it automatically kicks off another job which will upload the Gem to RubyGems.org and creates a GitHub release.

data/Gemfile

@@ -9,6 +9,7 @@ group :dev do
   gem 'pry'
   gem 'pry-doc'
   gem 'rubocop', require: false
+  gem 'sorbet'
 end
 
 group :test do

data/README.md

@@ -1,57 +1,64 @@
-# stream-chat-ruby
+# Official Ruby SDK for [Stream Chat](https://getstream.io/chat/)
 
 [![build](https://github.com/GetStream/stream-chat-ruby/workflows/build/badge.svg)](https://github.com/GetStream/stream-chat-ruby/actions) [![Gem Version](https://badge.fury.io/rb/stream-chat-ruby.svg)](http://badge.fury.io/rb/stream-chat-ruby)
 
-stream-chat-ruby is the official Ruby client for [Stream chat](https://getstream.io/chat/) a service for building chat applications.
+<p align="center">
+    <img src="./assets/logo.svg" width="50%" height="50%">
+</p>
+<p align="center">
+    Official Ruby API client for Stream Chat, a service for building chat applications.
+    <br />
+    <a href="https://getstream.io/chat/docs/"><strong>Explore the docs »</strong></a>
+    <br />
+    <br />
+    <a href="https://github.com/GetStream/rails-chat-example">Code Samples</a>
+    ·
+    <a href="https://github.com/GetStream/stream-chat-ruby/issues">Report Bug</a>
+    ·
+    <a href="https://github.com/GetStream/stream-chat-ruby/issues">Request Feature</a>
+</p>
 
-You can sign up for a Stream account at https://getstream.io/chat/get_started/.
+## 📝 About Stream
 
-You can use this library to access chat API endpoints server-side. For the
-client-side integrations (web and mobile) have a look at the JavaScript, iOS and
-Android SDK libraries (https://getstream.io/chat/).
+You can sign up for a Stream account at our [Get Started](https://getstream.io/chat/get_started/) page.
 
-### Installation
+You can use this library to access chat API endpoints server-side.
 
-stream-chat-ruby supports:
+For the client-side integrations (web and mobile) have a look at the JavaScript, iOS and Android SDK libraries ([docs](https://getstream.io/chat/)).
 
-- Ruby (2.5, 2.6, 2.7, 3.0, 3.1)
+## ⚙️ Installation
+
+[`stream-chat-ruby`](https://rubygems.org/gems/stream-chat-ruby) supports:
 
-#### Install
+- Ruby (2.5, 2.6, 2.7, 3.0, 3.1)
 
 ```bash
-gem install stream-chat-ruby
+$ gem install stream-chat-ruby
 ```
 
-### Documentation
-
-[Official API docs](https://getstream.io/chat/docs/)
-
-### Supported features
-
-- Chat channel type, channels and members
-- Messages
-- User management
-- Moderation API
-- Push configuration
-- User devices
-- User search
-- Channel search
-- Blocklists
-- Export channels
-
-### Import
+## ✨ Getting started
 
 ```ruby
 require 'stream-chat'
-```
 
-### Initialize client
-
-```ruby
 client = StreamChat::Client.new(api_key='STREAM_KEY', api_secret='STREAM_SECRET')
 ```
 
-### Generate a token for client side use
+> 💡 Note: since v2.21.0 we implemented [Sorbet](https://sorbet.org/) type checker. As of v2.x.x we only use it for static type checks and you won't notice any difference, but from v3.0.0 **we will enable runtime checks** 🚨 🚨 🚨.
+
+> What this means, is that you'll receive an error during runtime if you pass an invalid type to our methods. To prepare for that, just make sure whatever you pass in, matches the method signature (`sig { ... }`).
+ 
+---
+
+> Additionally, in a future major version, we would like to enforce symbol hash keys during runtime to conform to Ruby best practises. It's a good idea to prepare your application for that.
+> ```ruby
+> # Wrong:
+> user = { "user" => { "id" => "bob-1"}}
+> # Correct:
+> user = { :user => { :id => "bob-1" }}
+> ```
+
+### Generate a token for client-side usage:
 
 ```ruby
 client.create_token('bob-1')
@@ -66,87 +73,58 @@ client.update_user({
     :name => 'Robert Tables'
 })
 
-# batch update is also supported
-jane = ...
-june = ...
+# Batch update is also supported
+jane = {:id => 'jane-1'}
+june = {:id => 'june-1'}
 client.update_users([jane, june])
 ```
 
-### Channel types CRUD
+### Channel types
 
 ```ruby
-# Create
 client.create_channel_type({
-    'name' => 'livechat',
-    'automod' => 'disabled',
-    'commands' => ['ban'],
-    'mutes' => true
+    :name => 'livechat',
+    :automod => 'disabled',
+    :commands => ['ban'],
+    :mutes => true
 })
 
-# Update
-client.update_channel_type('livechat', 'automod' => 'enabled'})
-
-# Get
-client.get_channel_type('livechat')
-
-# List
-client.list_channel_types
-
-# Delete
-client.delete_channel_type('livechat')
+channel_types = client.list_channel_types()
 ```
 
 ### Channels
 
 ```ruby
 # Create a channel with members from the start
-chan = client.channel("messaging", channel_id: "bob-and-jane", data: {'members'=> ['bob-1', 'jane-77']})
+chan = client.channel("messaging", channel_id: "bob-and-jane", data: {:members => ['bob-1', 'jane-77']})
 chan.create('bob-1')
 
 # Create a channel and then add members
 chan = client.channel("messaging", channel_id: "bob-and-jane")
 chan.create('bob-1')
 chan.add_members(['bob-1', 'jane-77'])
+```
 
-# Send messages
-m1 = chan.send_message({'text' => 'Hi Jane!'}, 'bob-1')
-m2 = chan.send_message({'text' => 'Hi Bob'}, 'jane-77')
-
-# Send replies
-r1 = chan.send_message({'text' => 'And a good day!', 'parent_id' => m1['id']}, 'bob-1')
-
-# Send reactions
-chan.send_reaction(m1['id'], {'type' => 'like'}, 'bob-1')
+### Reactions
+```ruby
+chan.send_reaction(m1['id'], {:type => 'like'}, 'bob-1')
+```
 
-# Add/remove moderators
+### Moderation
+```ruby
 chan.add_moderators(['jane-77'])
 chan.demote_moderators(['bob-1'])
 
-# Add a ban with a timeout
 chan.ban_user('bob-1', timeout: 30)
 
-# Remove a ban
 chan.unban_user('bob-1')
-
-# Query channel state
-chan.query({'messages' => { 'limit' => 10, 'id_lte' => m1['id']}})
-
-# Update metadata (overwrite)
-chan.update({'motd' => 'one apple a day....'})
-
-# Update partial
-# 1. key-value pairs to set
-# 2. keys to unset (remove)
-chan.update_partial({color: 'blue', age: 30}, ['motd'])
-
-# Query channel members
-chan.query_members({name: {'$autocomplete': 'test'}}, sort: {last_created_at: -1}, offset: 5, limit: 5)
 ```
 
 ### Messages
 
 ```ruby
-# Delete a message from any channel by ID
+m1 = chan.send_message({:text => 'Hi Jane!'}, 'bob-1')
+
 deleted_message = client.delete_message(r1['id'])
 
 ```
@@ -154,29 +132,23 @@ deleted_message = client.delete_message(r1['id'])
 ### Devices
 
 ```ruby
-# Add device
-jane_phone = client.add_device({'id' => 'iOS Device Token', 'push_provider' => push_provider.apn, 'user_id' => 'jane-77'})
+jane_phone = client.add_device({:id => 'iOS Device Token', :push_provider => push_provider.apn, :user_id => 'jane-77'})
 
-# List devices
 client.get_devices('jane-77')
 
-# Remove device
 client.remove_device(jane_phone['id'], jane_phone['user_id'])
 ```
 
 ### Blocklists
 
 ```ruby
-# Create a blocklist
 client.create_blocklist('my_blocker', %w[fudge cream sugar])
 
-# Enable it on messaging channel type
+# Enable it on 'messaging' channel type
 client.update_channel_type('messaging', blocklist: 'my_blocker', blocklist_behavior: 'block')
 
-# Get the details of the blocklist
 client.get_blocklist('my_blocker')
 
-# Delete the blocklist
 client.delete_blocklist('my_blocker')
 ```
 
@@ -184,7 +156,7 @@ client.delete_blocklist('my_blocker')
 
 ```ruby
 # Register an export
-response = client.export_channels({type: 'messaging', id: 'jane'})
+response = client.export_channels({:type => 'messaging', :id => 'jane'})
 
 # Check completion
 status_response = client.get_export_channel_status(response['task_id'])
@@ -204,33 +176,13 @@ limits = client.get_rate_limits(server_side: true)
 limits = client.get_rate_limits(android: true, ios: true, endpoints: ['QueryChannels', 'SendMessage'])
 ```
 
-### Example Rails application
-
-See [an example rails application using the Ruby SDK](https://github.com/GetStream/rails-chat-example).
-
-### Contributing
-
-First, make sure you can run the test suite. Tests are run via rspec
-
-```bash
-STREAM_KEY=my_api_key STREAM_SECRET=my_api_secret bundle exec rake spec
-```
-
-This repository follows a commit message convention in order to automatically generate the [CHANGELOG](./CHANGELOG.md). Make sure you follow the rules of [conventional commits](https://www.conventionalcommits.org/) when opening a pull request.
-
-### Releasing a new version
-
-In order to release new version you need to be a maintainer of the library.
-
-- Kick off a job called `initiate_release` ([link](https://github.com/GetStream/stream-chat-ruby/actions/workflows/initiate_release.yml)).
-
-The job creates a pull request with the changelog. Check if it looks good.
+## ✍️ Contributing
 
-- Merge the pull request.
+We welcome code changes that improve this library or fix a problem, please make sure to follow all best practices and add tests if applicable before submitting a Pull Request on Github. We are very happy to merge your code in the official repository. Make sure to sign our [Contributor License Agreement (CLA)](https://docs.google.com/forms/d/e/1FAIpQLScFKsKkAJI7mhCr7K9rEIOpqIDThrWxuvxnwUq2XkHyG154vQ/viewform) first. See our [license file](./LICENSE) for more details.
 
-Once the PR is merged, it automatically kicks off another job which will upload the Gem to RubyGems.org and creates a GitHub release.
+Head over to [CONTRIBUTING.md](./CONTRIBUTING.md) for some development tips.
 
-## We are hiring!
+## 🧑‍💻 We are hiring!
 
 We've recently closed a [$38 million Series B funding round](https://techcrunch.com/2021/03/04/stream-raises-38m-as-its-chat-and-activity-feed-apis-power-communications-for-1b-users/) and we keep actively growing.
 Our APIs are used by more than a billion end-users, and you'll have a chance to make a huge impact on the product within a team of the strongest engineers all over the world.

data/lib/stream-chat/channel.rb

@@ -1,49 +1,72 @@
+# typed: strict
 # frozen_string_literal: true
 
+require 'stream-chat/client'
 require 'stream-chat/errors'
 require 'stream-chat/util'
+require 'stream-chat/types'
 
 module StreamChat
-  class Channel # rubocop:todo Metrics/ClassLength # rubocop:todo Style/Documentation
+  class Channel
+    extend T::Sig
+    T::Configuration.default_checked_level = :never
+    # 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.
+
+    sig { returns(T.nilable(String)) }
     attr_reader :id
+
+    sig { returns(String) }
     attr_reader :channel_type
+
+    sig { returns(StringKeyHash) }
     attr_reader :custom_data
+
+    sig { returns(T::Array[StringKeyHash]) }
     attr_reader :members
 
+    sig { params(client: StreamChat::Client, channel_type: String, channel_id: T.nilable(String), custom_data: T.nilable(StringKeyHash)).void }
     def initialize(client, channel_type, channel_id = nil, custom_data = nil)
       @channel_type = channel_type
       @id = channel_id
-      @cid = "#{@channel_type}:#{@id}"
+      @cid = T.let("#{@channel_type}:#{@id}", String)
       @client = client
-      @custom_data = custom_data
-      @custom_data = {} if @custom_data.nil?
+      @custom_data = T.let(custom_data || {}, StringKeyHash)
+      @members = T.let([], T::Array[StringKeyHash])
     end
 
+    sig { returns(String) }
     def url
       raise StreamChannelException, 'channel does not have an id' if @id.nil?
 
       "channels/#{@channel_type}/#{@id}"
     end
 
+    sig { params(message_ids: T::Array[String]).returns(StreamChat::StreamResponse) }
     def get_messages(message_ids)
       @client.get("#{url}/messages", params: { 'ids' => message_ids.join(',') })
     end
 
+    sig { params(message: StringKeyHash, user_id: String).returns(StreamChat::StreamResponse) }
     def send_message(message, user_id)
       payload = { message: add_user_id(message, user_id) }
       @client.post("#{url}/message", data: payload)
     end
 
+    sig { params(event: StringKeyHash, user_id: String).returns(StreamChat::StreamResponse) }
     def send_event(event, user_id)
       payload = { 'event' => add_user_id(event, user_id) }
       @client.post("#{url}/event", data: payload)
     end
 
+    sig { params(message_id: String, reaction: StringKeyHash, user_id: String).returns(StreamChat::StreamResponse) }
     def send_reaction(message_id, reaction, user_id)
       payload = { reaction: add_user_id(reaction, user_id) }
       @client.post("messages/#{message_id}/reaction", data: payload)
     end
 
+    sig { params(message_id: String, reaction_type: String, user_id: String).returns(StreamChat::StreamResponse) }
     def delete_reaction(message_id, reaction_type, user_id)
       @client.delete(
         "messages/#{message_id}/reaction/#{reaction_type}",
@@ -51,11 +74,13 @@ module StreamChat
       )
     end
 
+    sig { params(user_id: String).returns(StreamChat::StreamResponse) }
     def create(user_id)
       @custom_data['created_by'] = { id: user_id }
       query(watch: false, state: false, presence: false)
     end
 
+    sig { params(options: T.untyped).returns(StreamChat::StreamResponse) }
     def query(**options)
       payload = { state: true, data: @custom_data }.merge(options)
       url = "channels/#{@channel_type}"
@@ -66,17 +91,18 @@ module StreamChat
       state
     end
 
+    sig { params(filter_conditions: StringKeyHash, sort: T.nilable(T::Hash[String, Integer]), options: T.untyped).returns(StreamChat::StreamResponse) }
     def query_members(filter_conditions = {}, sort: nil, **options)
       params = {}.merge(options).merge({
                                          id: @id,
                                          type: @channel_type,
                                          filter_conditions: filter_conditions,
-                                         sort: get_sort_fields(sort)
+                                         sort: StreamChat.get_sort_fields(sort)
                                        })
 
       if @id == '' && @members.length.positive?
         params['members'] = []
-        @members&.each do |m|
+        @members.each do |m|
           params['members'] << m['user'].nil? ? m['user_id'] : m['user']['id']
         end
       end
@@ -84,11 +110,13 @@ module StreamChat
       @client.get('members', params: { payload: params.to_json })
     end
 
+    sig { params(channel_data: T.nilable(StringKeyHash), update_message: T.nilable(StringKeyHash), options: T.untyped).returns(StreamChat::StreamResponse) }
     def update(channel_data, update_message = nil, **options)
       payload = { data: channel_data, message: update_message }.merge(options)
       @client.post(url, data: payload)
     end
 
+    sig { params(set: T.nilable(StringKeyHash), unset: T.nilable(T::Array[String])).returns(StreamChat::StreamResponse) }
     def update_partial(set = nil, unset = nil)
       raise StreamChannelException, 'set or unset is needed' if set.nil? && unset.nil?
 
@@ -96,107 +124,131 @@ module StreamChat
       @client.patch(url, data: payload)
     end
 
+    sig { returns(StreamChat::StreamResponse) }
     def delete
       @client.delete(url)
     end
 
+    sig { params(options: T.untyped).returns(StreamChat::StreamResponse) }
     def truncate(**options)
       @client.post("#{url}/truncate", data: options)
     end
 
+    sig { params(user_id: String, expiration: T.nilable(Integer)).returns(StreamChat::StreamResponse) }
     def mute(user_id, expiration = nil)
       data = { user_id: user_id, channel_cid: @cid }
       data['expiration'] = expiration if expiration
       @client.post('moderation/mute/channel', data: data)
     end
 
+    sig { params(user_id: String).returns(StreamChat::StreamResponse) }
     def unmute(user_id)
       @client.post('moderation/unmute/channel', data: { 'user_id' => user_id, 'channel_cid' => @cid })
     end
 
+    sig { params(user_ids: T::Array[String], options: T.untyped).returns(StreamChat::StreamResponse) }
     def add_members(user_ids, **options)
       payload = options.merge({ add_members: user_ids })
       update(nil, nil, **payload)
     end
 
+    sig { params(user_ids: T::Array[String], options: T.untyped).returns(StreamChat::StreamResponse) }
     def invite_members(user_ids, **options)
       payload = options.merge({ invites: user_ids })
       update(nil, nil, **payload)
     end
 
+    sig { params(user_id: String, options: T.untyped).returns(StreamChat::StreamResponse) }
     def accept_invite(user_id, **options)
       payload = options.merge({ user_id: user_id, accept_invite: true })
       update(nil, nil, **payload)
     end
 
+    sig { params(user_id: String, options: T.untyped).returns(StreamChat::StreamResponse) }
     def reject_invite(user_id, **options)
       payload = options.merge({ user_id: user_id, reject_invite: true })
       update(nil, nil, **payload)
     end
 
+    sig { params(user_ids: T::Array[String]).returns(StreamChat::StreamResponse) }
     def add_moderators(user_ids)
       update(nil, nil, add_moderators: user_ids)
     end
 
+    sig { params(user_ids: T::Array[String]).returns(StreamChat::StreamResponse) }
     def remove_members(user_ids)
       update(nil, nil, remove_members: user_ids)
     end
 
+    sig { params(members: T::Array[StringKeyHash], message: T.nilable(StringKeyHash)).returns(StreamChat::StreamResponse) }
     def assign_roles(members, message = nil)
       update(nil, message, assign_roles: members)
     end
 
+    sig { params(user_ids: T::Array[String]).returns(StreamChat::StreamResponse) }
     def demote_moderators(user_ids)
       update(nil, nil, demote_moderators: user_ids)
     end
 
+    sig { params(user_id: String, options: StringKeyHash).returns(StreamChat::StreamResponse) }
     def mark_read(user_id, **options)
       payload = add_user_id(options, user_id)
       @client.post("#{url}/read", data: payload)
     end
 
+    sig { params(parent_id: String, options: T.untyped).returns(StreamChat::StreamResponse) }
     def get_replies(parent_id, **options)
       @client.get("messages/#{parent_id}/replies", params: options)
     end
 
+    sig { params(message_id: String, options: T.untyped).returns(StreamChat::StreamResponse) }
     def get_reactions(message_id, **options)
       @client.get("messages/#{message_id}/reactions", params: options)
     end
 
+    sig { params(user_id: String, options: T.untyped).returns(StreamChat::StreamResponse) }
     def ban_user(user_id, **options)
       @client.ban_user(user_id, type: @channel_type, id: @id, **options)
     end
 
+    sig { params(user_id: String).returns(StreamChat::StreamResponse) }
     def unban_user(user_id)
       @client.unban_user(user_id, type: @channel_type, id: @id)
     end
 
+    sig { params(user_id: String).returns(StreamChat::StreamResponse) }
     def hide(user_id)
       @client.post("#{url}/hide", data: { user_id: user_id })
     end
 
+    sig { params(user_id: String).returns(StreamChat::StreamResponse) }
     def show(user_id)
       @client.post("#{url}/show", data: { user_id: user_id })
     end
 
+    sig { params(url: String, user: StringKeyHash, content_type: T.nilable(String)).returns(StreamChat::StreamResponse) }
     def send_file(url, user, content_type = nil)
       @client.send_file("#{self.url}/file", url, user, content_type)
     end
 
+    sig { params(url: String, user: StringKeyHash, content_type: T.nilable(String)).returns(StreamChat::StreamResponse) }
     def send_image(url, user, content_type = nil)
       @client.send_file("#{self.url}/image", url, user, content_type)
     end
 
+    sig { params(url: String).returns(StreamChat::StreamResponse) }
     def delete_file(url)
       @client.delete("#{self.url}/file", params: { url: url })
     end
 
+    sig { params(url: String).returns(StreamChat::StreamResponse) }
     def delete_image(url)
       @client.delete("#{self.url}/image", params: { url: url })
     end
 
     private
 
+    sig { params(payload: StringKeyHash, user_id: String).returns(StringKeyHash) }
     def add_user_id(payload, user_id)
       payload.merge({ user: { id: user_id } })
     end