Deleting Channels

val channelClient = client.channel("messaging", "general")

channelClient.delete().enqueue { result ->
  if (result is Result.Success) {
    val channel = result.value
  } else {
    // Handle Result.Failure
  }
}

const destroy = await channel.delete();

use GetStream\ChatClient;
use GetStream\GeneratedModels as Models;

$client = new ChatClient("{{ api_key }}", "{{ api_secret }}");

$client->deleteChannel("messaging", "general", false);

await channel.delete();

import Stream Chat

let controller = chatClient.channelController(for: .init(type: .messaging, id: "general"))

controller.deleteChannel { error in
  if let error = error {
    // handle error
    print(error)
  }
}

Channel->Delete();

require 'getstream_ruby'

Models = GetStream::Generated::Models

client.chat.delete_channel("messaging", "general")

# Get a channel
channel = client.chat.channel("messaging", "general")

channel.delete()

channel := client.Chat().Channel("messaging", "general")

channel.Delete(ctx, &getstream.DeleteChannelRequest{})

using GetStream;
using GetStream.Models;

var client = new StreamClient("{{ api_key }}", "{{ api_secret }}");
var chat = new ChatClient(client);

var channelId = "channel-id";

// Soft delete
await chat.DeleteChannelAsync("messaging", channelId);

// Hard delete
await chat.DeleteChannelAsync("messaging", channelId,
    new { hard_delete = "true" });

// Soft delete channel
await channel.DeleteAsync();

// Backend SDK
chat.deleteChannel(channel.getType(), channel.getId(),
    DeleteChannelRequest.builder().build()).execute();

// Hard delete
chat.deleteChannel(channel.getType(), channel.getId(),
    DeleteChannelRequest.builder().HardDelete(true).build()).execute();

// client-side soft delete
const response = await client.deleteChannels([cid1, cid2]);
// client-side hard delete
const response = await client.deleteChannels([cid1, cid2], {
  hard_delete: true,
});
const result = response.result; // holds deletion result

// server-side soft delete
const response = await serverClient.deleteChannels([cid1, cid2]);
// server-side hard delete
const response = await serverClient.deleteChannels([cid1, cid2], {
  hard_delete: true,
});

const result = await serverClient.getTask(response.task_id);
if (result["status"] === "completed") {
  // success!
}

// soft deletion
resp, _ := client.Chat().DeleteChannels(ctx, &getstream.DeleteChannelsRequest{
	Cids: []string{cid1, cid2},
})

// hard deletion
resp, _ = client.Chat().DeleteChannels(ctx, &getstream.DeleteChannelsRequest{
	Cids:       []string{cid1, cid2},
	HardDelete: getstream.PtrTo(true),
})

taskResp, err := client.GetTask(ctx, *resp.Data.TaskID, &getstream.GetTaskRequest{})
if err != nil {
	// handle error
}
if taskResp.Data.Status == "completed" {
	// success!
}

# soft deletion
response = client.chat.delete_channels(cids=[cid1, cid2])
# hard deletion
response = client.chat.delete_channels(cids=[cid1, cid2], hard_delete=True)

task_response = client.get_task(id=response.data.task_id)
if task_response.data.status == "completed":
    # success!
    pass

require 'getstream_ruby'

Models = GetStream::Generated::Models

# soft deletion
response = client.chat.delete_channels(Models::DeleteChannelsRequest.new(
  cids: [cid1, cid2]
))

# hard deletion
response = client.chat.delete_channels(Models::DeleteChannelsRequest.new(
  cids: [cid1, cid2],
  hard_delete: true
))

task_response = client.common.get_task(response.task_id)
if task_response.status == 'completed'
  # success!
end

// soft deletion
$response = $client->deleteChannels(new Models\DeleteChannelsRequest(
    cids: ["messaging:channel-1", "messaging:channel-2"],
));

// hard deletion
$response = $client->deleteChannels(new Models\DeleteChannelsRequest(
    cids: ["messaging:channel-1", "messaging:channel-2"],
    hardDelete: true,
));

$taskResponse = $client->getTask($response->getData()->taskID);

// soft deletion
var response = chat.deleteChannels(DeleteChannelsRequest.builder()
    .cids(List.of(cid1, cid2))
    .build()).execute();

// hard deletion
var response = chat.deleteChannels(DeleteChannelsRequest.builder()
    .cids(List.of(cid1, cid2))
    .hardDelete(true)
    .build()).execute();

var taskResponse = client.getTask(response.getData().getTaskId()).execute();
// "completed".equals(taskResponse.getData().getStatus());

using GetStream;
using GetStream.Models;

var client = new StreamClient("{{ api_key }}", "{{ api_secret }}");
var chat = new ChatClient(client);

// Soft deletion
var resp = await chat.DeleteChannelsAsync(new DeleteChannelsRequest
{
    Cids = new List<string> { "messaging:channel-1", "messaging:channel-2" },
    HardDelete = false
});

// Hard deletion
resp = await chat.DeleteChannelsAsync(new DeleteChannelsRequest
{
    Cids = new List<string> { "messaging:channel-1", "messaging:channel-2" },
    HardDelete = true
});

// Hard delete removes the channel entirely from the database while soft delete removes the from users to see but it's still accessible via server-side SDK as an archive
await Client.DeleteMultipleChannelsAsync(new[] { channel, channel2 }, isHardDelete: true);