Class: GetStream::Generated::ChatClient

Inherits:
Object
  • Object
show all
Defined in:
lib/getstream_ruby/generated/chat_client.rb

Overview

Chat API client with generated methods

Instance Method Summary collapse

Constructor Details

#initialize(client) ⇒ ChatClient

Returns a new instance of ChatClient.



12
13
14
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 12

def initialize(client)
  @client = client
end

Instance Method Details

#add_segment_targets(_id, add_segment_targets_request) ⇒ Models::Response

Add targets to a segment

Parameters:

  • _id (String)
  • add_segment_targets_request (AddSegmentTargetsRequest)

Returns:



1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 1663

def add_segment_targets(_id, add_segment_targets_request)
  path = '/api/v2/chat/segments/{id}/addtargets'
  # Replace path parameters
  path = path.gsub('{id}', _id.to_s)
  # Build request body
  body = add_segment_targets_request

  # Make the API request
  @client.make_request(
    :post,
    path,
    body: body
  )
end

#cast_poll_vote(message_id, poll_id, cast_poll_vote_request) ⇒ Models::PollVoteResponse

Cast a vote on a pollSends events:- feeds.poll.vote_casted- feeds.poll.vote_changed- feeds.poll.vote_removed- poll.vote_casted- poll.vote_changed- poll.vote_removed

Parameters:

  • message_id (String)
  • poll_id (String)
  • cast_poll_vote_request (CastPollVoteRequest)

Returns:



1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 1250

def cast_poll_vote(message_id, poll_id, cast_poll_vote_request)
  path = '/api/v2/chat/messages/{message_id}/polls/{poll_id}/vote'
  # Replace path parameters
  path = path.gsub('{message_id}', message_id.to_s)
  path = path.gsub('{poll_id}', poll_id.to_s)
  # Build request body
  body = cast_poll_vote_request

  # Make the API request
  @client.make_request(
    :post,
    path,
    body: body
  )
end

#channel_batch_update(channel_batch_update_request) ⇒ Models::ChannelBatchUpdateResponse

Update channels in batchSends events:- channel.frozen- channel.hidden- channel.unfrozen- channel.updated- channel.visible- member.added- member.removed- member.updated

Parameters:

  • channel_batch_update_request (ChannelBatchUpdateRequest)

Returns:



171
172
173
174
175
176
177
178
179
180
181
182
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 171

def channel_batch_update(channel_batch_update_request)
  path = '/api/v2/chat/channels/batch'
  # Build request body
  body = channel_batch_update_request

  # Make the API request
  @client.make_request(
    :put,
    path,
    body: body
  )
end

#commit_message(_id, commit_message_request) ⇒ Models::MessageActionResponse

Commits a pending message, which will make it visible in the channelSends events:- message.new- message.updated

Parameters:

  • _id (String)
  • commit_message_request (CommitMessageRequest)

Returns:



1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 1083

def commit_message(_id, commit_message_request)
  path = '/api/v2/chat/messages/{id}/commit'
  # Replace path parameters
  path = path.gsub('{id}', _id.to_s)
  # Build request body
  body = commit_message_request

  # Make the API request
  @client.make_request(
    :post,
    path,
    body: body
  )
end

#create_campaign(create_campaign_request) ⇒ Models::CreateCampaignResponse

Creates a campaign

Parameters:

  • create_campaign_request (CreateCampaignRequest)

Returns:



19
20
21
22
23
24
25
26
27
28
29
30
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 19

def create_campaign(create_campaign_request)
  path = '/api/v2/chat/campaigns'
  # Build request body
  body = create_campaign_request

  # Make the API request
  @client.make_request(
    :post,
    path,
    body: body
  )
end

#create_channel_type(create_channel_type_request) ⇒ Models::CreateChannelTypeResponse

Creates new channel type

Parameters:

  • create_channel_type_request (CreateChannelTypeRequest)

Returns:



756
757
758
759
760
761
762
763
764
765
766
767
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 756

def create_channel_type(create_channel_type_request)
  path = '/api/v2/chat/channeltypes'
  # Build request body
  body = create_channel_type_request

  # Make the API request
  @client.make_request(
    :post,
    path,
    body: body
  )
end

#create_command(create_command_request) ⇒ Models::CreateCommandResponse

Creates custom chat command

Parameters:

  • create_command_request (CreateCommandRequest)

Returns:



838
839
840
841
842
843
844
845
846
847
848
849
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 838

def create_command(create_command_request)
  path = '/api/v2/chat/commands'
  # Build request body
  body = create_command_request

  # Make the API request
  @client.make_request(
    :post,
    path,
    body: body
  )
end

#create_reminder(message_id, create_reminder_request) ⇒ Models::ReminderResponseData

Creates a new reminderSends events:- reminder.created

Parameters:

  • message_id (String)
  • create_reminder_request (CreateReminderRequest)

Returns:



1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 1337

def create_reminder(message_id, create_reminder_request)
  path = '/api/v2/chat/messages/{message_id}/reminders'
  # Replace path parameters
  path = path.gsub('{message_id}', message_id.to_s)
  # Build request body
  body = create_reminder_request

  # Make the API request
  @client.make_request(
    :post,
    path,
    body: body
  )
end

#create_segment(create_segment_request) ⇒ Models::CreateSegmentResponse

Create a segment

Parameters:

  • create_segment_request (CreateSegmentRequest)

Returns:



1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 1576

def create_segment(create_segment_request)
  path = '/api/v2/chat/segments'
  # Build request body
  body = create_segment_request

  # Make the API request
  @client.make_request(
    :post,
    path,
    body: body
  )
end

#delete_campaign(_id) ⇒ Models::DeleteCampaignResponse

Delete campaign

Parameters:

  • _id (String)

Returns:



53
54
55
56
57
58
59
60
61
62
63
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 53

def delete_campaign(_id)
  path = '/api/v2/chat/campaigns/{id}'
  # Replace path parameters
  path = path.gsub('{id}', _id.to_s)

  # Make the API request
  @client.make_request(
    :delete,
    path
  )
end

#delete_channel(_type, _id, hard_delete = nil) ⇒ Models::DeleteChannelResponse

Deletes channelSends events:- channel.deleted

Parameters:

  • _type (String)
  • _id (String)
  • hard_delete (Boolean) (defaults to: nil)

Returns:



283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 283

def delete_channel(_type, _id, hard_delete = nil)
  path = '/api/v2/chat/channels/{type}/{id}'
  # Replace path parameters
  path = path.gsub('{type}', _type.to_s)
  path = path.gsub('{id}', _id.to_s)
  # Build query parameters
  query_params = {}
  query_params['hard_delete'] = hard_delete unless hard_delete.nil?

  # Make the API request
  @client.make_request(
    :delete,
    path,
    query_params: query_params
  )
end

#delete_channel_file(_type, _id, url = nil) ⇒ Models::Response

Deletes previously uploaded file

Parameters:

  • _type (String)
  • _id (String)
  • url (String) (defaults to: nil)

Returns:



451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 451

def delete_channel_file(_type, _id, url = nil)
  path = '/api/v2/chat/channels/{type}/{id}/file'
  # Replace path parameters
  path = path.gsub('{type}', _type.to_s)
  path = path.gsub('{id}', _id.to_s)
  # Build query parameters
  query_params = {}
  query_params['url'] = url unless url.nil?

  # Make the API request
  @client.make_request(
    :delete,
    path,
    query_params: query_params
  )
end

#delete_channel_image(_type, _id, url = nil) ⇒ Models::Response

Deletes previously uploaded image

Parameters:

  • _type (String)
  • _id (String)
  • url (String) (defaults to: nil)

Returns:



518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 518

def delete_channel_image(_type, _id, url = nil)
  path = '/api/v2/chat/channels/{type}/{id}/image'
  # Replace path parameters
  path = path.gsub('{type}', _type.to_s)
  path = path.gsub('{id}', _id.to_s)
  # Build query parameters
  query_params = {}
  query_params['url'] = url unless url.nil?

  # Make the API request
  @client.make_request(
    :delete,
    path,
    query_params: query_params
  )
end

#delete_channel_type(name) ⇒ Models::Response

Deletes channel type

Parameters:

  • name (String)

Returns:



773
774
775
776
777
778
779
780
781
782
783
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 773

def delete_channel_type(name)
  path = '/api/v2/chat/channeltypes/{name}'
  # Replace path parameters
  path = path.gsub('{name}', name.to_s)

  # Make the API request
  @client.make_request(
    :delete,
    path
  )
end

#delete_channels(delete_channels_request) ⇒ Models::DeleteChannelsResponse

Allows to delete several channels at once asynchronouslySends events:- channel.deleted

Parameters:

  • delete_channels_request (DeleteChannelsRequest)

Returns:



188
189
190
191
192
193
194
195
196
197
198
199
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 188

def delete_channels(delete_channels_request)
  path = '/api/v2/chat/channels/delete'
  # Build request body
  body = delete_channels_request

  # Make the API request
  @client.make_request(
    :post,
    path,
    body: body
  )
end

#delete_command(name) ⇒ Models::DeleteCommandResponse

Deletes custom chat command

Parameters:

  • name (String)

Returns:



855
856
857
858
859
860
861
862
863
864
865
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 855

def delete_command(name)
  path = '/api/v2/chat/commands/{name}'
  # Replace path parameters
  path = path.gsub('{name}', name.to_s)

  # Make the API request
  @client.make_request(
    :delete,
    path
  )
end

#delete_draft(_type, _id, parent_id = nil, user_id = nil) ⇒ Models::Response

Deletes a draftSends events:- draft.deleted

Parameters:

  • _type (String)
  • _id (String)
  • parent_id (String) (defaults to: nil)
  • user_id (String) (defaults to: nil)

Returns:



380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 380

def delete_draft(_type, _id, parent_id = nil, user_id = nil)
  path = '/api/v2/chat/channels/{type}/{id}/draft'
  # Replace path parameters
  path = path.gsub('{type}', _type.to_s)
  path = path.gsub('{id}', _id.to_s)
  # Build query parameters
  query_params = {}
  query_params['parent_id'] = parent_id unless parent_id.nil?
  query_params['user_id'] = user_id unless user_id.nil?

  # Make the API request
  @client.make_request(
    :delete,
    path,
    query_params: query_params
  )
end

#delete_message(_id, hard = nil, deleted_by = nil, delete_for_me = nil) ⇒ Models::DeleteMessageResponse

Deletes messageSends events:- message.deleted

Parameters:

  • _id (String)
  • hard (Boolean) (defaults to: nil)
  • deleted_by (String) (defaults to: nil)
  • delete_for_me (Boolean) (defaults to: nil)

Returns:



979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 979

def delete_message(_id, hard = nil, deleted_by = nil, delete_for_me = nil)
  path = '/api/v2/chat/messages/{id}'
  # Replace path parameters
  path = path.gsub('{id}', _id.to_s)
  # Build query parameters
  query_params = {}
  query_params['hard'] = hard unless hard.nil?
  query_params['deleted_by'] = deleted_by unless deleted_by.nil?
  query_params['delete_for_me'] = delete_for_me unless delete_for_me.nil?

  # Make the API request
  @client.make_request(
    :delete,
    path,
    query_params: query_params
  )
end

#delete_poll_vote(message_id, poll_id, vote_id, user_id = nil) ⇒ Models::PollVoteResponse

Delete a vote from a pollSends events:- feeds.poll.vote_removed- poll.vote_removed

Parameters:

  • message_id (String)
  • poll_id (String)
  • vote_id (String)
  • user_id (String) (defaults to: nil)

Returns:



1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 1273

def delete_poll_vote(message_id, poll_id, vote_id, user_id = nil)
  path = '/api/v2/chat/messages/{message_id}/polls/{poll_id}/vote/{vote_id}'
  # Replace path parameters
  path = path.gsub('{message_id}', message_id.to_s)
  path = path.gsub('{poll_id}', poll_id.to_s)
  path = path.gsub('{vote_id}', vote_id.to_s)
  # Build query parameters
  query_params = {}
  query_params['user_id'] = user_id unless user_id.nil?

  # Make the API request
  @client.make_request(
    :delete,
    path,
    query_params: query_params
  )
end

#delete_reaction(_id, _type, user_id = nil) ⇒ Models::DeleteReactionResponse

Removes user reaction from the messageSends events:- reaction.deleted

Parameters:

  • _id (String)
  • _type (String)
  • user_id (String) (defaults to: nil)

Returns:



1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 1144

def delete_reaction(_id, _type, user_id = nil)
  path = '/api/v2/chat/messages/{id}/reaction/{type}'
  # Replace path parameters
  path = path.gsub('{id}', _id.to_s)
  path = path.gsub('{type}', _type.to_s)
  # Build query parameters
  query_params = {}
  query_params['user_id'] = user_id unless user_id.nil?

  # Make the API request
  @client.make_request(
    :delete,
    path,
    query_params: query_params
  )
end

#delete_reminder(message_id, user_id = nil) ⇒ Models::DeleteReminderResponse

Deletes a user's created reminderSends events:- reminder.deleted

Parameters:

  • message_id (String)
  • user_id (String) (defaults to: nil)

Returns:



1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 1296

def delete_reminder(message_id, user_id = nil)
  path = '/api/v2/chat/messages/{message_id}/reminders'
  # Replace path parameters
  path = path.gsub('{message_id}', message_id.to_s)
  # Build query parameters
  query_params = {}
  query_params['user_id'] = user_id unless user_id.nil?

  # Make the API request
  @client.make_request(
    :delete,
    path,
    query_params: query_params
  )
end

#delete_retention_policy(delete_retention_policy_request) ⇒ Models::DeleteRetentionPolicyResponse

Removes a retention policy for the app. Server-side only.

Parameters:

  • delete_retention_policy_request (DeleteRetentionPolicyRequest)

Returns:



1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 1524

def delete_retention_policy(delete_retention_policy_request)
  path = '/api/v2/chat/retention_policy/delete'
  # Build request body
  body = delete_retention_policy_request

  # Make the API request
  @client.make_request(
    :post,
    path,
    body: body
  )
end

#delete_segment(_id) ⇒ Models::Response

Delete a segment

Parameters:

  • _id (String)

Returns:



1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 1610

def delete_segment(_id)
  path = '/api/v2/chat/segments/{id}'
  # Replace path parameters
  path = path.gsub('{id}', _id.to_s)

  # Make the API request
  @client.make_request(
    :delete,
    path
  )
end

#delete_segment_targets(_id, delete_segment_targets_request) ⇒ Models::Response

Delete targets from a segment

Parameters:

  • _id (String)
  • delete_segment_targets_request (DeleteSegmentTargetsRequest)

Returns:



1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 1683

def delete_segment_targets(_id, delete_segment_targets_request)
  path = '/api/v2/chat/segments/{id}/deletetargets'
  # Replace path parameters
  path = path.gsub('{id}', _id.to_s)
  # Build request body
  body = delete_segment_targets_request

  # Make the API request
  @client.make_request(
    :post,
    path,
    body: body
  )
end

#ephemeral_message_update(_id, update_message_partial_request) ⇒ Models::UpdateMessagePartialResponse

Updates message fields without storing in database, only sends update eventSends events:- message.updated

Parameters:

  • _id (String)
  • update_message_partial_request (UpdateMessagePartialRequest)

Returns:



1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 1103

def ephemeral_message_update(_id, update_message_partial_request)
  path = '/api/v2/chat/messages/{id}/ephemeral'
  # Replace path parameters
  path = path.gsub('{id}', _id.to_s)
  # Build request body
  body = update_message_partial_request

  # Make the API request
  @client.make_request(
    :patch,
    path,
    body: body
  )
end

#export_channels(export_channels_request) ⇒ Models::ExportChannelsResponse

Exports channel data to JSON file

Parameters:

  • export_channels_request (ExportChannelsRequest)

Returns:



924
925
926
927
928
929
930
931
932
933
934
935
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 924

def export_channels(export_channels_request)
  path = '/api/v2/chat/export_channels'
  # Build request body
  body = export_channels_request

  # Make the API request
  @client.make_request(
    :post,
    path,
    body: body
  )
end

#get_campaign(_id, prev = nil, _next = nil, limit = nil) ⇒ Models::GetCampaignResponse

Get campaign by ID.

Parameters:

  • _id (String)
  • prev (String) (defaults to: nil)
  • _next (String) (defaults to: nil)
  • limit (Integer) (defaults to: nil)

Returns:



72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 72

def get_campaign(_id, prev = nil, _next = nil, limit = nil)
  path = '/api/v2/chat/campaigns/{id}'
  # Replace path parameters
  path = path.gsub('{id}', _id.to_s)
  # Build query parameters
  query_params = {}
  query_params['prev'] = prev unless prev.nil?
  query_params['next'] = _next unless _next.nil?
  query_params['limit'] = limit unless limit.nil?

  # Make the API request
  @client.make_request(
    :get,
    path,
    query_params: query_params
  )
end

#get_channel(_type, _id, state = nil, messages_limit = nil, members_limit = nil, watchers_limit = nil) ⇒ Models::ChannelStateResponse

Returns a channel by its CID without creating it. Responds with 404 when the channel does not exist, so it doubles as an existence check. Pass state=true to also load messages, read state and watchers.

Parameters:

  • _type (String)
  • _id (String)
  • state (Boolean) (defaults to: nil)
  • messages_limit (Integer) (defaults to: nil)
  • members_limit (Integer) (defaults to: nil)
  • watchers_limit (Integer) (defaults to: nil)

Returns:



309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 309

def get_channel(_type, _id, state = nil, messages_limit = nil, members_limit = nil, watchers_limit = nil)
  path = '/api/v2/chat/channels/{type}/{id}'
  # Replace path parameters
  path = path.gsub('{type}', _type.to_s)
  path = path.gsub('{id}', _id.to_s)
  # Build query parameters
  query_params = {}
  query_params['state'] = state unless state.nil?
  query_params['messages_limit'] = messages_limit unless messages_limit.nil?
  query_params['members_limit'] = members_limit unless members_limit.nil?
  query_params['watchers_limit'] = watchers_limit unless watchers_limit.nil?

  # Make the API request
  @client.make_request(
    :get,
    path,
    query_params: query_params
  )
end

#get_channel_type(name) ⇒ Models::GetChannelTypeResponse

Gets channel type

Parameters:

  • name (String)

Returns:



789
790
791
792
793
794
795
796
797
798
799
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 789

def get_channel_type(name)
  path = '/api/v2/chat/channeltypes/{name}'
  # Replace path parameters
  path = path.gsub('{name}', name.to_s)

  # Make the API request
  @client.make_request(
    :get,
    path
  )
end

#get_command(name) ⇒ Models::GetCommandResponse

Returns custom command by its name

Parameters:

  • name (String)

Returns:



871
872
873
874
875
876
877
878
879
880
881
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 871

def get_command(name)
  path = '/api/v2/chat/commands/{name}'
  # Replace path parameters
  path = path.gsub('{name}', name.to_s)

  # Make the API request
  @client.make_request(
    :get,
    path
  )
end

#get_draft(_type, _id, parent_id = nil, user_id = nil) ⇒ Models::GetDraftResponse

Get a draft

Parameters:

  • _type (String)
  • _id (String)
  • parent_id (String) (defaults to: nil)
  • user_id (String) (defaults to: nil)

Returns:



405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 405

def get_draft(_type, _id, parent_id = nil, user_id = nil)
  path = '/api/v2/chat/channels/{type}/{id}/draft'
  # Replace path parameters
  path = path.gsub('{type}', _type.to_s)
  path = path.gsub('{id}', _id.to_s)
  # Build query parameters
  query_params = {}
  query_params['parent_id'] = parent_id unless parent_id.nil?
  query_params['user_id'] = user_id unless user_id.nil?

  # Make the API request
  @client.make_request(
    :get,
    path,
    query_params: query_params
  )
end

#get_many_messages(_type, _id, ids) ⇒ Models::GetManyMessagesResponse

Returns list messages found by IDs

Parameters:

  • _type (String)
  • _id (String)
  • ids (Array<String>)

Returns:



612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 612

def get_many_messages(_type, _id, ids)
  path = '/api/v2/chat/channels/{type}/{id}/messages'
  # Replace path parameters
  path = path.gsub('{type}', _type.to_s)
  path = path.gsub('{id}', _id.to_s)
  # Build query parameters
  query_params = {}
  query_params['ids'] = ids unless ids.nil?

  # Make the API request
  @client.make_request(
    :get,
    path,
    query_params: query_params
  )
end

#get_message(_id, show_deleted_message = nil) ⇒ Models::GetMessageResponse

Returns message by ID

Parameters:

  • _id (String)
  • show_deleted_message (Boolean) (defaults to: nil)

Returns:



1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 1002

def get_message(_id, show_deleted_message = nil)
  path = '/api/v2/chat/messages/{id}'
  # Replace path parameters
  path = path.gsub('{id}', _id.to_s)
  # Build query parameters
  query_params = {}
  query_params['show_deleted_message'] = show_deleted_message unless show_deleted_message.nil?

  # Make the API request
  @client.make_request(
    :get,
    path,
    query_params: query_params
  )
end

#get_or_create_channel(_type, _id, channel_get_or_create_request) ⇒ Models::ChannelStateResponse

This Method creates a channel or returns an existing one with matching attributesSends events:- channel.created- member.added- member.removed- member.updated- user.watching.start

Parameters:

  • _type (String)
  • _id (String)
  • channel_get_or_create_request (ChannelGetOrCreateRequest)

Returns:



635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 635

def get_or_create_channel(_type, _id, channel_get_or_create_request)
  path = '/api/v2/chat/channels/{type}/{id}/query'
  # Replace path parameters
  path = path.gsub('{type}', _type.to_s)
  path = path.gsub('{id}', _id.to_s)
  # Build request body
  body = channel_get_or_create_request

  # Make the API request
  @client.make_request(
    :post,
    path,
    body: body
  )
end

#get_or_create_distinct_channel(_type, channel_get_or_create_request) ⇒ Models::ChannelStateResponse

This Method creates a channel or returns an existing one with matching attributesSends events:- channel.created- member.added- member.removed- member.updated- user.watching.start

Parameters:

  • _type (String)
  • channel_get_or_create_request (ChannelGetOrCreateRequest)

Returns:



262
263
264
265
266
267
268
269
270
271
272
273
274
275
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 262

def get_or_create_distinct_channel(_type, channel_get_or_create_request)
  path = '/api/v2/chat/channels/{type}/query'
  # Replace path parameters
  path = path.gsub('{type}', _type.to_s)
  # Build request body
  body = channel_get_or_create_request

  # Make the API request
  @client.make_request(
    :post,
    path,
    body: body
  )
end

#get_reactions(_id, limit = nil, offset = nil) ⇒ Models::GetReactionsResponse

Returns list of reactions of specific message

Parameters:

  • _id (String)
  • limit (Integer) (defaults to: nil)
  • offset (Integer) (defaults to: nil)

Returns:



1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 1167

def get_reactions(_id, limit = nil, offset = nil)
  path = '/api/v2/chat/messages/{id}/reactions'
  # Replace path parameters
  path = path.gsub('{id}', _id.to_s)
  # Build query parameters
  query_params = {}
  query_params['limit'] = limit unless limit.nil?
  query_params['offset'] = offset unless offset.nil?

  # Make the API request
  @client.make_request(
    :get,
    path,
    query_params: query_params
  )
end

#get_replies(parent_id, limit = nil, id_gte = nil, id_gt = nil, id_lte = nil, id_lt = nil, id_around = nil, sort = nil) ⇒ Models::GetRepliesResponse

Returns replies (thread) of the message

Parameters:

  • parent_id (String)
  • limit (Integer) (defaults to: nil)
  • id_gte (String) (defaults to: nil)
  • id_gt (String) (defaults to: nil)
  • id_lte (String) (defaults to: nil)
  • id_lt (String) (defaults to: nil)
  • id_around (String) (defaults to: nil)
  • sort (Array<SortParamRequest>) (defaults to: nil)

Returns:



1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 1363

def get_replies(parent_id, limit = nil, id_gte = nil, id_gt = nil, id_lte = nil, id_lt = nil, id_around = nil, sort = nil)
  path = '/api/v2/chat/messages/{parent_id}/replies'
  # Replace path parameters
  path = path.gsub('{parent_id}', parent_id.to_s)
  # Build query parameters
  query_params = {}
  query_params['limit'] = limit unless limit.nil?
  query_params['id_gte'] = id_gte unless id_gte.nil?
  query_params['id_gt'] = id_gt unless id_gt.nil?
  query_params['id_lte'] = id_lte unless id_lte.nil?
  query_params['id_lt'] = id_lt unless id_lt.nil?
  query_params['id_around'] = id_around unless id_around.nil?
  query_params['sort'] = sort unless sort.nil?

  # Make the API request
  @client.make_request(
    :get,
    path,
    query_params: query_params
  )
end

#get_retention_policy ⇒ Models::GetRetentionPolicyResponse

Returns all retention policies configured for the app. Server-side only.

Returns:



1493
1494
1495
1496
1497
1498
1499
1500
1501
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 1493

def get_retention_policy()
  path = '/api/v2/chat/retention_policy'

  # Make the API request
  @client.make_request(
    :get,
    path
  )
end

#get_retention_policy_runs(get_retention_policy_runs_request) ⇒ Models::GetRetentionPolicyRunsResponse

Returns filtered and sorted retention cleanup run history for the app. Supports filter_conditions on 'policy' (possible values: 'old-messages', 'inactive-channels') and 'date' fields. Server-side only.

Parameters:

  • get_retention_policy_runs_request (GetRetentionPolicyRunsRequest)

Returns:



1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 1541

def get_retention_policy_runs(get_retention_policy_runs_request)
  path = '/api/v2/chat/retention_policy/runs'
  # Build request body
  body = get_retention_policy_runs_request

  # Make the API request
  @client.make_request(
    :post,
    path,
    body: body
  )
end

#get_segment(_id) ⇒ Models::GetSegmentResponse

Get segment

Parameters:

  • _id (String)

Returns:



1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 1626

def get_segment(_id)
  path = '/api/v2/chat/segments/{id}'
  # Replace path parameters
  path = path.gsub('{id}', _id.to_s)

  # Make the API request
  @client.make_request(
    :get,
    path
  )
end

#get_thread(message_id, reply_limit = nil, participant_limit = nil, member_limit = nil) ⇒ Models::GetThreadResponse

Return a specific thread

Parameters:

  • message_id (String)
  • reply_limit (Integer) (defaults to: nil)
  • participant_limit (Integer) (defaults to: nil)
  • member_limit (Integer) (defaults to: nil)

Returns:



1777
1778
1779
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790
1791
1792
1793
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 1777

def get_thread(message_id, reply_limit = nil, participant_limit = nil, member_limit = nil)
  path = '/api/v2/chat/threads/{message_id}'
  # Replace path parameters
  path = path.gsub('{message_id}', message_id.to_s)
  # Build query parameters
  query_params = {}
  query_params['reply_limit'] = reply_limit unless reply_limit.nil?
  query_params['participant_limit'] = participant_limit unless participant_limit.nil?
  query_params['member_limit'] = member_limit unless member_limit.nil?

  # Make the API request
  @client.make_request(
    :get,
    path,
    query_params: query_params
  )
end

#grouped_query_channels(grouped_query_channels_request) ⇒ Models::GroupedQueryChannelsResponse

Query channels grouped into predefined buckets. Only available for enterprise apps.

Parameters:

  • grouped_query_channels_request (GroupedQueryChannelsRequest)

Returns:



227
228
229
230
231
232
233
234
235
236
237
238
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 227

def grouped_query_channels(grouped_query_channels_request)
  path = '/api/v2/chat/channels/grouped'
  # Build request body
  body = grouped_query_channels_request

  # Make the API request
  @client.make_request(
    :post,
    path,
    body: body
  )
end

#hide_channel(_type, _id, hide_channel_request) ⇒ Models::HideChannelResponse

Marks channel as hidden for current userSends events:- channel.hidden

Parameters:

  • _type (String)
  • _id (String)
  • hide_channel_request (HideChannelRequest)

Returns:



496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 496

def hide_channel(_type, _id, hide_channel_request)
  path = '/api/v2/chat/channels/{type}/{id}/hide'
  # Replace path parameters
  path = path.gsub('{type}', _type.to_s)
  path = path.gsub('{id}', _id.to_s)
  # Build request body
  body = hide_channel_request

  # Make the API request
  @client.make_request(
    :post,
    path,
    body: body
  )
end

#list_channel_types ⇒ Models::ListChannelTypesResponse

Lists all available channel types

Returns:



742
743
744
745
746
747
748
749
750
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 742

def list_channel_types()
  path = '/api/v2/chat/channeltypes'

  # Make the API request
  @client.make_request(
    :get,
    path
  )
end

#list_commands ⇒ Models::ListCommandsResponse

Returns all custom commands

Returns:



824
825
826
827
828
829
830
831
832
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 824

def list_commands()
  path = '/api/v2/chat/commands'

  # Make the API request
  @client.make_request(
    :get,
    path
  )
end

#mark_channels_read(mark_channels_read_request) ⇒ Models::MarkReadResponse

Marks channels as read up to the specific message. If no channels is given, mark all channel as readSends events:- message.read

Parameters:

  • mark_channels_read_request (MarkChannelsReadRequest)

Returns:



244
245
246
247
248
249
250
251
252
253
254
255
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 244

def mark_channels_read(mark_channels_read_request)
  path = '/api/v2/chat/channels/read'
  # Build request body
  body = mark_channels_read_request

  # Make the API request
  @client.make_request(
    :post,
    path,
    body: body
  )
end

#mark_delivered(mark_delivered_request, user_id = nil) ⇒ Models::MarkDeliveredResponse

Mark the status of a channel message delivered.

Parameters:

  • mark_delivered_request (MarkDeliveredRequest)
  • user_id (String) (defaults to: nil)

Returns:



206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 206

def mark_delivered(mark_delivered_request, user_id = nil)
  path = '/api/v2/chat/channels/delivered'
  # Build query parameters
  query_params = {}
  query_params['user_id'] = user_id unless user_id.nil?
  # Build request body
  body = mark_delivered_request

  # Make the API request
  @client.make_request(
    :post,
    path,
    query_params: query_params,
    body: body
  )
end

#mark_read(_type, _id, mark_read_request) ⇒ Models::MarkReadResponse

Marks channel as read up to the specific messageSends events:- message.read

Parameters:

  • _type (String)
  • _id (String)
  • mark_read_request (MarkReadRequest)

Returns:



657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 657

def mark_read(_type, _id, mark_read_request)
  path = '/api/v2/chat/channels/{type}/{id}/read'
  # Replace path parameters
  path = path.gsub('{type}', _type.to_s)
  path = path.gsub('{id}', _id.to_s)
  # Build request body
  body = mark_read_request

  # Make the API request
  @client.make_request(
    :post,
    path,
    body: body
  )
end

#mark_unread(_type, _id, mark_unread_request) ⇒ Models::Response

Marks channel as unread from a specific message

Parameters:

  • _type (String)
  • _id (String)
  • mark_unread_request (MarkUnreadRequest)

Returns:



723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 723

def mark_unread(_type, _id, mark_unread_request)
  path = '/api/v2/chat/channels/{type}/{id}/unread'
  # Replace path parameters
  path = path.gsub('{type}', _type.to_s)
  path = path.gsub('{id}', _id.to_s)
  # Build request body
  body = mark_unread_request

  # Make the API request
  @client.make_request(
    :post,
    path,
    body: body
  )
end

#mute_channel(mute_channel_request) ⇒ Models::MuteChannelResponse

Mutes channel for userSends events:- channel.muted

Parameters:

  • mute_channel_request (MuteChannelRequest)

Returns:



1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 1407

def mute_channel(mute_channel_request)
  path = '/api/v2/chat/moderation/mute/channel'
  # Build request body
  body = mute_channel_request

  # Make the API request
  @client.make_request(
    :post,
    path,
    body: body
  )
end

#query_banned_users(payload = nil) ⇒ Models::QueryBannedUsersResponse

Find and filter channel scoped or global user bans

Parameters:

  • payload (QueryBannedUsersPayload) (defaults to: nil)

Returns:



1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 1441

def query_banned_users(payload = nil)
  path = '/api/v2/chat/query_banned_users'
  # Build query parameters
  query_params = {}
  query_params['payload'] = payload unless payload.nil?

  # Make the API request
  @client.make_request(
    :get,
    path,
    query_params: query_params
  )
end

#query_campaigns(query_campaigns_request) ⇒ Models::QueryCampaignsResponse

Query campaigns with filter query

Parameters:

  • query_campaigns_request (QueryCampaignsRequest)

Returns:



36
37
38
39
40
41
42
43
44
45
46
47
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 36

def query_campaigns(query_campaigns_request)
  path = '/api/v2/chat/campaigns/query'
  # Build request body
  body = query_campaigns_request

  # Make the API request
  @client.make_request(
    :post,
    path,
    body: body
  )
end

#query_channels(query_channels_request) ⇒ Models::QueryChannelsResponse

Query channels with filter query

Parameters:

  • query_channels_request (QueryChannelsRequest)

Returns:



154
155
156
157
158
159
160
161
162
163
164
165
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 154

def query_channels(query_channels_request)
  path = '/api/v2/chat/channels'
  # Build request body
  body = query_channels_request

  # Make the API request
  @client.make_request(
    :post,
    path,
    body: body
  )
end

#query_drafts(query_drafts_request) ⇒ Models::QueryDraftsResponse

Queries draft messages for a user

Parameters:

  • query_drafts_request (QueryDraftsRequest)

Returns:



907
908
909
910
911
912
913
914
915
916
917
918
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 907

def query_drafts(query_drafts_request)
  path = '/api/v2/chat/drafts/query'
  # Build request body
  body = query_drafts_request

  # Make the API request
  @client.make_request(
    :post,
    path,
    body: body
  )
end

#query_future_channel_bans(payload = nil) ⇒ Models::QueryFutureChannelBansResponse

Find and filter future channel bans created by the authenticated user

Parameters:

  • payload (QueryFutureChannelBansPayload) (defaults to: nil)

Returns:



1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 1459

def query_future_channel_bans(payload = nil)
  path = '/api/v2/chat/query_future_channel_bans'
  # Build query parameters
  query_params = {}
  query_params['payload'] = payload unless payload.nil?

  # Make the API request
  @client.make_request(
    :get,
    path,
    query_params: query_params
  )
end

#query_members(payload = nil) ⇒ Models::MembersResponse

Find and filter channel members

Parameters:

  • payload (QueryMembersPayload) (defaults to: nil)

Returns:



941
942
943
944
945
946
947
948
949
950
951
952
953
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 941

def query_members(payload = nil)
  path = '/api/v2/chat/members'
  # Build query parameters
  query_params = {}
  query_params['payload'] = payload unless payload.nil?

  # Make the API request
  @client.make_request(
    :get,
    path,
    query_params: query_params
  )
end

#query_message_flags(payload = nil) ⇒ Models::QueryMessageFlagsResponse

Find and filter message flags

Parameters:

  • payload (QueryMessageFlagsPayload) (defaults to: nil)

Returns:



1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 1389

def query_message_flags(payload = nil)
  path = '/api/v2/chat/moderation/flags/message'
  # Build query parameters
  query_params = {}
  query_params['payload'] = payload unless payload.nil?

  # Make the API request
  @client.make_request(
    :get,
    path,
    query_params: query_params
  )
end

#query_message_history(query_message_history_request) ⇒ Models::QueryMessageHistoryResponse

Queries history for one message

Parameters:

  • query_message_history_request (QueryMessageHistoryRequest)

Returns:



959
960
961
962
963
964
965
966
967
968
969
970
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 959

def query_message_history(query_message_history_request)
  path = '/api/v2/chat/messages/history'
  # Build request body
  body = query_message_history_request

  # Make the API request
  @client.make_request(
    :post,
    path,
    body: body
  )
end

#query_reactions(_id, query_reactions_request) ⇒ Models::QueryReactionsResponse

Get reactions on a message

Parameters:

  • _id (String)
  • query_reactions_request (QueryReactionsRequest)

Returns:



1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 1189

def query_reactions(_id, query_reactions_request)
  path = '/api/v2/chat/messages/{id}/reactions'
  # Replace path parameters
  path = path.gsub('{id}', _id.to_s)
  # Build request body
  body = query_reactions_request

  # Make the API request
  @client.make_request(
    :post,
    path,
    body: body
  )
end

#query_reminders(query_reminders_request) ⇒ Models::QueryRemindersResponse

Queries reminders

Parameters:

  • query_reminders_request (QueryRemindersRequest)

Returns:



1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 1477

def query_reminders(query_reminders_request)
  path = '/api/v2/chat/reminders/query'
  # Build request body
  body = query_reminders_request

  # Make the API request
  @client.make_request(
    :post,
    path,
    body: body
  )
end

#query_segment_targets(_id, query_segment_targets_request) ⇒ Models::QuerySegmentTargetsResponse

Query segment targets

Parameters:

  • _id (String)
  • query_segment_targets_request (QuerySegmentTargetsRequest)

Returns:



1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 1721

def query_segment_targets(_id, query_segment_targets_request)
  path = '/api/v2/chat/segments/{id}/targets/query'
  # Replace path parameters
  path = path.gsub('{id}', _id.to_s)
  # Build request body
  body = query_segment_targets_request

  # Make the API request
  @client.make_request(
    :post,
    path,
    body: body
  )
end

#query_segments(query_segments_request) ⇒ Models::QuerySegmentsResponse

Query segments

Parameters:

  • query_segments_request (QuerySegmentsRequest)

Returns:



1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 1593

def query_segments(query_segments_request)
  path = '/api/v2/chat/segments/query'
  # Build request body
  body = query_segments_request

  # Make the API request
  @client.make_request(
    :post,
    path,
    body: body
  )
end

#query_team_usage_stats(query_team_usage_stats_request) ⇒ Models::QueryTeamUsageStatsResponse

Retrieve team-level usage statistics from the warehouse database.Returns all 16 metrics grouped by team with cursor-based pagination.Date Range Options (mutually exclusive):- Use 'month' parameter (YYYY-MM format) for monthly aggregated values- Use 'start_date'/'end_date' parameters (YYYY-MM-DD format) for daily breakdown- If neither provided, defaults to current month (monthly mode)This endpoint is server-side only.

Parameters:

  • query_team_usage_stats_request (QueryTeamUsageStatsRequest)

Returns:



1740
1741
1742
1743
1744
1745
1746
1747
1748
1749
1750
1751
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 1740

def query_team_usage_stats(query_team_usage_stats_request)
  path = '/api/v2/chat/stats/team_usage'
  # Build request body
  body = query_team_usage_stats_request

  # Make the API request
  @client.make_request(
    :post,
    path,
    body: body
  )
end

#query_threads(query_threads_request) ⇒ Models::QueryThreadsResponse

Returns the list of threads for specific user

Parameters:

  • query_threads_request (QueryThreadsRequest)

Returns:



1757
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 1757

def query_threads(query_threads_request)
  path = '/api/v2/chat/threads'
  # Build request body
  body = query_threads_request

  # Make the API request
  @client.make_request(
    :post,
    path,
    body: body
  )
end

#run_message_action(_id, message_action_request) ⇒ Models::MessageActionResponse

Executes message command action with given parametersSends events:- message.new

Parameters:

  • _id (String)
  • message_action_request (MessageActionRequest)

Returns:



1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 1063

def run_message_action(_id, message_action_request)
  path = '/api/v2/chat/messages/{id}/action'
  # Replace path parameters
  path = path.gsub('{id}', _id.to_s)
  # Build request body
  body = message_action_request

  # Make the API request
  @client.make_request(
    :post,
    path,
    body: body
  )
end

#search(payload = nil) ⇒ Models::SearchResponse

Search messages across channels

Parameters:

  • payload (SearchPayload) (defaults to: nil)

Returns:



1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 1558

def search(payload = nil)
  path = '/api/v2/chat/search'
  # Build query parameters
  query_params = {}
  query_params['payload'] = payload unless payload.nil?

  # Make the API request
  @client.make_request(
    :get,
    path,
    query_params: query_params
  )
end

#segment_target_exists(_id, target_id) ⇒ Models::Response

Check whether a target exists in a segment. Returns 200 if the target exists, 404 otherwise

Parameters:

  • _id (String)
  • target_id (String)

Returns:



1703
1704
1705
1706
1707
1708
1709
1710
1711
1712
1713
1714
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 1703

def segment_target_exists(_id, target_id)
  path = '/api/v2/chat/segments/{id}/target/{target_id}'
  # Replace path parameters
  path = path.gsub('{id}', _id.to_s)
  path = path.gsub('{target_id}', target_id.to_s)

  # Make the API request
  @client.make_request(
    :get,
    path
  )
end

#send_event(_type, _id, send_event_request) ⇒ Models::EventResponse

Sends event to the channel

Parameters:

  • _type (String)
  • _id (String)
  • send_event_request (SendEventRequest)

Returns:



429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 429

def send_event(_type, _id, send_event_request)
  path = '/api/v2/chat/channels/{type}/{id}/event'
  # Replace path parameters
  path = path.gsub('{type}', _type.to_s)
  path = path.gsub('{id}', _id.to_s)
  # Build request body
  body = send_event_request

  # Make the API request
  @client.make_request(
    :post,
    path,
    body: body
  )
end

#send_message(_type, _id, send_message_request) ⇒ Models::SendMessageResponse

Sends new message to the specified channelSends events:- message.new- message.updated

Parameters:

  • _type (String)
  • _id (String)
  • send_message_request (SendMessageRequest)

Returns:



590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 590

def send_message(_type, _id, send_message_request)
  path = '/api/v2/chat/channels/{type}/{id}/message'
  # Replace path parameters
  path = path.gsub('{type}', _type.to_s)
  path = path.gsub('{id}', _id.to_s)
  # Build request body
  body = send_message_request

  # Make the API request
  @client.make_request(
    :post,
    path,
    body: body
  )
end

#send_reaction(_id, send_reaction_request) ⇒ Models::SendReactionResponse

Sends reaction to specified messageSends events:- reaction.new- reaction.updated

Parameters:

  • _id (String)
  • send_reaction_request (SendReactionRequest)

Returns:



1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 1123

def send_reaction(_id, send_reaction_request)
  path = '/api/v2/chat/messages/{id}/reaction'
  # Replace path parameters
  path = path.gsub('{id}', _id.to_s)
  # Build request body
  body = send_reaction_request

  # Make the API request
  @client.make_request(
    :post,
    path,
    body: body
  )
end

#send_user_custom_event(user_id, send_user_custom_event_request) ⇒ Models::Response

Sends a custom event to a userSends events:- *

Parameters:

  • user_id (String)
  • send_user_custom_event_request (SendUserCustomEventRequest)

Returns:



1855
1856
1857
1858
1859
1860
1861
1862
1863
1864
1865
1866
1867
1868
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 1855

def send_user_custom_event(user_id, send_user_custom_event_request)
  path = '/api/v2/chat/users/{user_id}/event'
  # Replace path parameters
  path = path.gsub('{user_id}', user_id.to_s)
  # Build request body
  body = send_user_custom_event_request

  # Make the API request
  @client.make_request(
    :post,
    path,
    body: body
  )
end

#set_retention_policy(set_retention_policy_request) ⇒ Models::SetRetentionPolicyResponse

Creates or updates a retention policy for the app. Server-side only.

Parameters:

  • set_retention_policy_request (SetRetentionPolicyRequest)

Returns:



1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 1507

def set_retention_policy(set_retention_policy_request)
  path = '/api/v2/chat/retention_policy'
  # Build request body
  body = set_retention_policy_request

  # Make the API request
  @client.make_request(
    :post,
    path,
    body: body
  )
end

#show_channel(_type, _id, show_channel_request) ⇒ Models::ShowChannelResponse

Shows previously hidden channelSends events:- channel.visible

Parameters:

  • _type (String)
  • _id (String)
  • show_channel_request (ShowChannelRequest)

Returns:



679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 679

def show_channel(_type, _id, show_channel_request)
  path = '/api/v2/chat/channels/{type}/{id}/show'
  # Replace path parameters
  path = path.gsub('{type}', _type.to_s)
  path = path.gsub('{id}', _id.to_s)
  # Build request body
  body = show_channel_request

  # Make the API request
  @client.make_request(
    :post,
    path,
    body: body
  )
end

#start_campaign(_id, start_campaign_request) ⇒ Models::StartCampaignResponse

Starts or schedules a campaign

Parameters:

  • _id (String)
  • start_campaign_request (StartCampaignRequest)

Returns:



115
116
117
118
119
120
121
122
123
124
125
126
127
128
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 115

def start_campaign(_id, start_campaign_request)
  path = '/api/v2/chat/campaigns/{id}/start'
  # Replace path parameters
  path = path.gsub('{id}', _id.to_s)
  # Build request body
  body = start_campaign_request

  # Make the API request
  @client.make_request(
    :post,
    path,
    body: body
  )
end

#stop_campaign(_id, stop_campaign_request) ⇒ Models::CampaignResponse

Stops a campaign

Parameters:

  • _id (String)
  • stop_campaign_request (StopCampaignRequest)

Returns:



135
136
137
138
139
140
141
142
143
144
145
146
147
148
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 135

def stop_campaign(_id, stop_campaign_request)
  path = '/api/v2/chat/campaigns/{id}/stop'
  # Replace path parameters
  path = path.gsub('{id}', _id.to_s)
  # Build request body
  body = stop_campaign_request

  # Make the API request
  @client.make_request(
    :post,
    path,
    body: body
  )
end

#translate_message(_id, translate_message_request) ⇒ Models::MessageActionResponse

Translates message to a given language using automated translation softwareSends events:- message.updated

Parameters:

  • _id (String)
  • translate_message_request (TranslateMessageRequest)

Returns:



1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 1209

def translate_message(_id, translate_message_request)
  path = '/api/v2/chat/messages/{id}/translate'
  # Replace path parameters
  path = path.gsub('{id}', _id.to_s)
  # Build request body
  body = translate_message_request

  # Make the API request
  @client.make_request(
    :post,
    path,
    body: body
  )
end

#truncate_channel(_type, _id, truncate_channel_request) ⇒ Models::TruncateChannelResponse

Truncates messages from a channel. Can be applied to the entire channel or scoped to specific members.Sends events:- channel.truncated

Parameters:

  • _type (String)
  • _id (String)
  • truncate_channel_request (TruncateChannelRequest)

Returns:



701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 701

def truncate_channel(_type, _id, truncate_channel_request)
  path = '/api/v2/chat/channels/{type}/{id}/truncate'
  # Replace path parameters
  path = path.gsub('{type}', _type.to_s)
  path = path.gsub('{id}', _id.to_s)
  # Build request body
  body = truncate_channel_request

  # Make the API request
  @client.make_request(
    :post,
    path,
    body: body
  )
end

#undelete_message(_id, undelete_message_request) ⇒ Models::UndeleteMessageResponse

Undelete a message that was previously soft-deletedSends events:- message.undeleted

Parameters:

  • _id (String)
  • undelete_message_request (UndeleteMessageRequest)

Returns:



1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 1229

def undelete_message(_id, undelete_message_request)
  path = '/api/v2/chat/messages/{id}/undelete'
  # Replace path parameters
  path = path.gsub('{id}', _id.to_s)
  # Build request body
  body = undelete_message_request

  # Make the API request
  @client.make_request(
    :post,
    path,
    body: body
  )
end

#unmute_channel(unmute_channel_request) ⇒ Models::UnmuteResponse

Unmutes channel for userSends events:- channel.unmuted

Parameters:

  • unmute_channel_request (UnmuteChannelRequest)

Returns:



1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 1424

def unmute_channel(unmute_channel_request)
  path = '/api/v2/chat/moderation/unmute/channel'
  # Build request body
  body = unmute_channel_request

  # Make the API request
  @client.make_request(
    :post,
    path,
    body: body
  )
end

#unread_counts(user_id = nil) ⇒ Models::WrappedUnreadCountsResponse

Fetch unread counts for a single user

Parameters:

  • user_id (String) (defaults to: nil)

Returns:



1819
1820
1821
1822
1823
1824
1825
1826
1827
1828
1829
1830
1831
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 1819

def unread_counts(user_id = nil)
  path = '/api/v2/chat/unread'
  # Build query parameters
  query_params = {}
  query_params['user_id'] = user_id unless user_id.nil?

  # Make the API request
  @client.make_request(
    :get,
    path,
    query_params: query_params
  )
end

#unread_counts_batch(unread_counts_batch_request) ⇒ Models::UnreadCountsBatchResponse

Fetch unread counts in batch for multiple users in one call

Parameters:

  • unread_counts_batch_request (UnreadCountsBatchRequest)

Returns:



1837
1838
1839
1840
1841
1842
1843
1844
1845
1846
1847
1848
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 1837

def unread_counts_batch(unread_counts_batch_request)
  path = '/api/v2/chat/unread_batch'
  # Build request body
  body = unread_counts_batch_request

  # Make the API request
  @client.make_request(
    :post,
    path,
    body: body
  )
end

#update_campaign(_id, update_campaign_request) ⇒ Models::CampaignResponse

Updates a campaign

Parameters:

  • _id (String)
  • update_campaign_request (UpdateCampaignRequest)

Returns:



95
96
97
98
99
100
101
102
103
104
105
106
107
108
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 95

def update_campaign(_id, update_campaign_request)
  path = '/api/v2/chat/campaigns/{id}'
  # Replace path parameters
  path = path.gsub('{id}', _id.to_s)
  # Build request body
  body = update_campaign_request

  # Make the API request
  @client.make_request(
    :put,
    path,
    body: body
  )
end

#update_channel(_type, _id, update_channel_request) ⇒ Models::UpdateChannelResponse

Change channel dataSends events:- channel.updated- member.added- member.removed- member.updated- message.new

Parameters:

  • _type (String)
  • _id (String)
  • update_channel_request (UpdateChannelRequest)

Returns:



357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 357

def update_channel(_type, _id, update_channel_request)
  path = '/api/v2/chat/channels/{type}/{id}'
  # Replace path parameters
  path = path.gsub('{type}', _type.to_s)
  path = path.gsub('{id}', _id.to_s)
  # Build request body
  body = update_channel_request

  # Make the API request
  @client.make_request(
    :post,
    path,
    body: body
  )
end

#update_channel_partial(_type, _id, update_channel_partial_request) ⇒ Models::UpdateChannelPartialResponse

Updates certain fields of the channelSends events:- channel.updated

Parameters:

  • _type (String)
  • _id (String)
  • update_channel_partial_request (UpdateChannelPartialRequest)

Returns:



335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 335

def update_channel_partial(_type, _id, update_channel_partial_request)
  path = '/api/v2/chat/channels/{type}/{id}'
  # Replace path parameters
  path = path.gsub('{type}', _type.to_s)
  path = path.gsub('{id}', _id.to_s)
  # Build request body
  body = update_channel_partial_request

  # Make the API request
  @client.make_request(
    :patch,
    path,
    body: body
  )
end

#update_channel_type(name, update_channel_type_request) ⇒ Models::UpdateChannelTypeResponse

Updates channel type

Parameters:

  • name (String)
  • update_channel_type_request (UpdateChannelTypeRequest)

Returns:



806
807
808
809
810
811
812
813
814
815
816
817
818
819
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 806

def update_channel_type(name, update_channel_type_request)
  path = '/api/v2/chat/channeltypes/{name}'
  # Replace path parameters
  path = path.gsub('{name}', name.to_s)
  # Build request body
  body = update_channel_type_request

  # Make the API request
  @client.make_request(
    :put,
    path,
    body: body
  )
end

#update_command(name, update_command_request) ⇒ Models::UpdateCommandResponse

Updates custom chat command

Parameters:

  • name (String)
  • update_command_request (UpdateCommandRequest)

Returns:



888
889
890
891
892
893
894
895
896
897
898
899
900
901
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 888

def update_command(name, update_command_request)
  path = '/api/v2/chat/commands/{name}'
  # Replace path parameters
  path = path.gsub('{name}', name.to_s)
  # Build request body
  body = update_command_request

  # Make the API request
  @client.make_request(
    :put,
    path,
    body: body
  )
end

#update_member_partial(_type, _id, update_member_partial_request, user_id = nil) ⇒ Models::UpdateMemberPartialResponse

Parameters:

  • _type (String)
  • _id (String)
  • update_member_partial_request (UpdateMemberPartialRequest)
  • user_id (String) (defaults to: nil)

Returns:



564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 564

def update_member_partial(_type, _id, update_member_partial_request, user_id = nil)
  path = '/api/v2/chat/channels/{type}/{id}/member'
  # Replace path parameters
  path = path.gsub('{type}', _type.to_s)
  path = path.gsub('{id}', _id.to_s)
  # Build query parameters
  query_params = {}
  query_params['user_id'] = user_id unless user_id.nil?
  # Build request body
  body = update_member_partial_request

  # Make the API request
  @client.make_request(
    :patch,
    path,
    query_params: query_params,
    body: body
  )
end

#update_message(_id, update_message_request) ⇒ Models::UpdateMessageResponse

Updates message with new dataSends events:- message.updated

Parameters:

  • _id (String)
  • update_message_request (UpdateMessageRequest)

Returns:



1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 1023

def update_message(_id, update_message_request)
  path = '/api/v2/chat/messages/{id}'
  # Replace path parameters
  path = path.gsub('{id}', _id.to_s)
  # Build request body
  body = update_message_request

  # Make the API request
  @client.make_request(
    :post,
    path,
    body: body
  )
end

#update_message_partial(_id, update_message_partial_request) ⇒ Models::UpdateMessagePartialResponse

Updates certain fields of the messageSends events:- message.updated

Parameters:

  • _id (String)
  • update_message_partial_request (UpdateMessagePartialRequest)

Returns:



1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 1043

def update_message_partial(_id, update_message_partial_request)
  path = '/api/v2/chat/messages/{id}'
  # Replace path parameters
  path = path.gsub('{id}', _id.to_s)
  # Build request body
  body = update_message_partial_request

  # Make the API request
  @client.make_request(
    :put,
    path,
    body: body
  )
end

#update_reminder(message_id, update_reminder_request) ⇒ Models::UpdateReminderResponse

Updates an existing reminderSends events:- reminder.updated

Parameters:

  • message_id (String)
  • update_reminder_request (UpdateReminderRequest)

Returns:



1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 1317

def update_reminder(message_id, update_reminder_request)
  path = '/api/v2/chat/messages/{message_id}/reminders'
  # Replace path parameters
  path = path.gsub('{message_id}', message_id.to_s)
  # Build request body
  body = update_reminder_request

  # Make the API request
  @client.make_request(
    :patch,
    path,
    body: body
  )
end

#update_segment(_id, update_segment_request) ⇒ Models::UpdateSegmentResponse

Update an existing segment

Parameters:

  • _id (String)
  • update_segment_request (UpdateSegmentRequest)

Returns:



1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 1643

def update_segment(_id, update_segment_request)
  path = '/api/v2/chat/segments/{id}'
  # Replace path parameters
  path = path.gsub('{id}', _id.to_s)
  # Build request body
  body = update_segment_request

  # Make the API request
  @client.make_request(
    :put,
    path,
    body: body
  )
end

#update_thread_partial(message_id, update_thread_partial_request) ⇒ Models::UpdateThreadPartialResponse

Updates certain fields of the threadSends events:- thread.updated

Parameters:

  • message_id (String)
  • update_thread_partial_request (UpdateThreadPartialRequest)

Returns:



1800
1801
1802
1803
1804
1805
1806
1807
1808
1809
1810
1811
1812
1813
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 1800

def update_thread_partial(message_id, update_thread_partial_request)
  path = '/api/v2/chat/threads/{message_id}'
  # Replace path parameters
  path = path.gsub('{message_id}', message_id.to_s)
  # Build request body
  body = update_thread_partial_request

  # Make the API request
  @client.make_request(
    :patch,
    path,
    body: body
  )
end

#upload_channel_file(_type, _id, upload_channel_file_request) ⇒ Models::UploadChannelFileResponse

Uploads file

Parameters:

  • _type (String)
  • _id (String)
  • upload_channel_file_request (UploadChannelFileRequest)

Returns:



474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 474

def upload_channel_file(_type, _id, upload_channel_file_request)
  path = '/api/v2/chat/channels/{type}/{id}/file'
  # Replace path parameters
  path = path.gsub('{type}', _type.to_s)
  path = path.gsub('{id}', _id.to_s)
  # Build request body
  body = upload_channel_file_request

  # Make the API request
  @client.make_request(
    :post,
    path,
    body: body
  )
end

#upload_channel_image(_type, _id, upload_channel_request) ⇒ Models::UploadChannelResponse

Uploads image

Parameters:

  • _type (String)
  • _id (String)
  • upload_channel_request (UploadChannelRequest)

Returns:



541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
 
# File 'lib/getstream_ruby/generated/chat_client.rb', line 541

def upload_channel_image(_type, _id, upload_channel_request)
  path = '/api/v2/chat/channels/{type}/{id}/image'
  # Replace path parameters
  path = path.gsub('{type}', _type.to_s)
  path = path.gsub('{id}', _id.to_s)
  # Build request body
  body = upload_channel_request

  # Make the API request
  @client.make_request(
    :post,
    path,
    body: body
  )
end