Moderation

Stream Feeds has support for moderation, allowing you to manage user interactions, content moderation, and platform safety. It's accessible through the client.moderation property.

Overview

val client = FeedsClient(context = context, apiKey = apiKey, user = user, tokenProvider = tokenProvider)
val moderation = client.moderation

client, err := getstream.NewClient("key", "secret")
if err != nil {
	// Handle error
}

moderation := client.Moderation()

ActivityFeedbackRequest moderationRequest =
    ActivityFeedbackRequest.builder()
        .report(true)
        .reason("inappropriate_content")
        .userID(testUserId2) // Different user reporting
        .build();

ActivityFeedbackResponse moderationResponse =
    feeds.activityFeedback(activityId, moderationRequest).execute().getData();

use GetStream\ClientBuilder;

$moderationClient = (new ClientBuilder())
    ->apiKey($apiKey)
    ->apiSecret($apiSecret)
    ->buildModerationClient();

require 'getstream_ruby'

client = GetStreamRuby.manual(
  api_key: 'api_key',
  api_secret: 'api_secret'
)

moderation = client.moderation

// Note: Moderation typically requires admin permissions
// This test demonstrates the API structure
Console.WriteLine($"Activity {activityId} would be moderated here");
// In a real scenario, you would call moderation endpoints

moderation_response = self.client.feeds.activity_feedback(
    activity_id,
    report=True,
    reason="inappropriate_content",
    user_id=self.test_user_id_2,  # Different user reporting
)

User Moderation

Ban Users

Ban a user from the platform with various options including timeout, shadow bans, and IP bans.

let banRequest = BanRequest(
    targetUserId: "user-123",
    reason: "Violation of community guidelines",
    timeout: 3600, // 1 hour in seconds
    shadow: false,
    ipBan: false
)

let response = try await client.moderation.ban(banRequest: banRequest)
print("User banned for: \(response.duration)")

val banRequest = BanRequest(
    targetUserId = "user-123",
    reason = "Violation of community guidelines",
    timeout = 3600, // 1 hour in seconds
    shadow = false,
    ipBan = false
)

val response: Result<BanResponse> = client.moderation.ban(banRequest = banRequest)
println("User banned for: ${response.getOrNull()?.duration}")

await client.moderation.ban({
  target_user_id: "user-123",
  reason: "Violation of community guidelines",
  timeout: 3600, // 1 hour in seconds
  shadow: false,
  ip_ban: false,
});

await client.moderation.ban({
  target_user_id: "user-123",
  reason: "Violation of community guidelines",
  timeout: 3600, // 1 hour in seconds
  shadow: false,
  ip_ban: false,
});

await client.moderation.ban({
  target_user_id: "user-123",
  reason: "Violation of community guidelines",
  timeout: 3600, // 1 hour in seconds
  shadow: false,
  ip_ban: false,
});

const banRequest = BanRequest(
  targetUserId: 'user-123',
  reason: 'Violation of community guidelines',
  timeout: 3600, // 1 hour in seconds
  shadow: false,
  ipBan: false,
);

final response = await client.moderation.ban(banRequest: banRequest);
print('User banned for: ${response.getOrThrow().duration}');

await client.moderation.ban({
  target_user_id: "user-123",
  banned_by_id: "<banned by user id>",
  reason: "Violation of community guidelines",
  timeout: 3600, // 1 hour in seconds
  shadow: false,
  ip_ban: false,
});

request := &getstream.BanRequest{
	TargetUserID: "user123",
	Reason:       getstream.PtrTo("spam"),
	Timeout:      getstream.PtrTo(60), // 60 minutes
	BannedByID:   getstream.PtrTo("moderator456"),
}

_, err := client.Moderation().Ban(context.Background(), request)

ActivityFeedbackRequest moderationRequest =
    ActivityFeedbackRequest.builder()
        .report(true)
        .reason("inappropriate_content")
        .userID(testUserId2) // Different user reporting
        .build();

ActivityFeedbackResponse moderationResponse =
    feeds.activityFeedback(activityId, moderationRequest).execute().getData();

$banRequest = new GeneratedModels\BanRequest(
    targetUserID: "user123",
    reason: "Violation of community guidelines",
    timeout: 60, // 1 hour in minutes
    shadow: false,
    ipBan: false,
    bannedByID: "eric"
);

$response = $moderationClient->ban($banRequest);

// Note: Moderation typically requires admin permissions
// This test demonstrates the API structure
Console.WriteLine($"Activity {activityId} would be moderated here");
// In a real scenario, you would call moderation endpoints

moderation_response = self.client.feeds.activity_feedback(
    activity_id,
    report=True,
    reason="inappropriate_content",
    user_id=self.test_user_id_2,  # Different user reporting
)

Parameters:

targetUserId: The ID of the user to ban
reason: Optional reason for the ban
timeout: Optional timeout in seconds (null for permanent ban)
shadow: Whether to perform a shadow ban (user doesn't know they're banned)
ipBan: Whether to ban the user's IP address
bannedBy: Optional user who performed the ban
deleteMessages: Whether to delete user's messages

Mute Users

Mute one or more users to prevent them from interacting with your content.

let muteRequest = MuteRequest(
    targetIds: ["user-123", "user-456"],
    timeout: 86400 // 24 hours in seconds
)

let response = try await client.moderation.mute(muteRequest: muteRequest)

val muteRequest = MuteRequest(
    targetIds = listOf("user-123", "user-456"),
    timeout = 86400 // 24 hours in seconds
)

val response: Result<MuteResponse> = client.moderation.mute(muteRequest = muteRequest)

const muteRequest = MuteRequest(
  targetIds: ['user-123', 'user-456'],
  timeout: 86400, // 24 hours in seconds
);

final response = await client.moderation.mute(muteRequest: muteRequest);

client.moderation.mute({
  target_ids: ["user-123", "user-456"],
  user_id: "<moderator id>",
  timeout: 86400, // 24 hours in seconds
});

request := &getstream.MuteRequest{
	TargetIds: []string{"user123", "user456"},
	Timeout:   getstream.PtrTo(30), // 30 minutes
	UserID:    getstream.PtrTo("moderator789"),
}

_, err := client.Moderation().Mute(context.Background(), request)

ActivityFeedbackRequest moderationRequest =
    ActivityFeedbackRequest.builder()
        .report(true)
        .reason("inappropriate_content")
        .userID(testUserId2) // Different user reporting
        .build();

ActivityFeedbackResponse moderationResponse =
    feeds.activityFeedback(activityId, moderationRequest).execute().getData();

$muteRequest = new GeneratedModels\MuteRequest(
    targetIds: ["user123", "user456"],
    // 24 hours in minutes
    timeout: 1440,
    userID: "moderator"
);

$response = $moderationClient->mute($muteRequest);

// Note: Moderation typically requires admin permissions
// This test demonstrates the API structure
Console.WriteLine($"Activity {activityId} would be moderated here");
// In a real scenario, you would call moderation endpoints

moderation_response = self.client.feeds.activity_feedback(
    activity_id,
    report=True,
    reason="inappropriate_content",
    user_id=self.test_user_id_2,  # Different user reporting
)

Parameters:

targetIds: Array of user IDs to mute
timeout: Optional timeout in seconds (null for permanent mute)

Block Users

Block a user to prevent them from following you or seeing your content.

let blockRequest = BlockUsersRequest(blockedUserId: "user-123")
let response = try await client.moderation.blockUsers(blockUsersRequest: blockRequest)

val blockRequest = BlockUsersRequest(blockedUserId = "user-123")
val response: Result<BlockUsersResponse> = client.moderation.blockUser(blockRequest)

const blockRequest = BlockUsersRequest(blockedUserId: 'user-123');
final response = await client.moderation.blockUsers(blockUsersRequest: blockRequest);

// Coming soon

ActivityFeedbackRequest moderationRequest =
    ActivityFeedbackRequest.builder()
        .report(true)
        .reason("inappropriate_content")
        .userID(testUserId2) // Different user reporting
        .build();

ActivityFeedbackResponse moderationResponse =
    feeds.activityFeedback(activityId, moderationRequest).execute().getData();

$blockRequest = new GeneratedModels\BlockUsersRequest(
    blockedUserID: "user123",
    userID: "moderator"
);

$response = $moderationClient->blockUsers($blockRequest);

// Note: Moderation typically requires admin permissions
// This test demonstrates the API structure
Console.WriteLine($"Activity {activityId} would be moderated here");
// In a real scenario, you would call moderation endpoints

moderation_response = self.client.feeds.activity_feedback(
    activity_id,
    report=True,
    reason="inappropriate_content",
    user_id=self.test_user_id_2,  # Different user reporting
)

Unblock Users

Unblock a previously blocked user.

let unblockRequest = UnblockUsersRequest(blockedUserId: "user-123")
let response = try await client.moderation.unblockUsers(unblockUsersRequest: unblockRequest)

val unblockRequest = UnblockUsersRequest(blockedUserId = "user-123")
val response: Result<UnblockUsersResponse> = client.moderation.unblockUser(unblockRequest)

const unblockRequest = UnblockUsersRequest(blockedUserId: 'user-123');
final response = await client.moderation.unblockUsers(unblockUsersRequest: unblockRequest);

// Coming soon

ActivityFeedbackRequest moderationRequest =
    ActivityFeedbackRequest.builder()
        .report(true)
        .reason("inappropriate_content")
        .userID(testUserId2) // Different user reporting
        .build();

ActivityFeedbackResponse moderationResponse =
    feeds.activityFeedback(activityId, moderationRequest).execute().getData();

$request = new GeneratedModels\UnblockUsersRequest(
    blockedUserID: "user123",
    userID: "moderator"
);

$response = $moderationClient->unblockUsers($request);

// Note: Moderation typically requires admin permissions
// This test demonstrates the API structure
Console.WriteLine($"Activity {activityId} would be moderated here");
// In a real scenario, you would call moderation endpoints

moderation_response = self.client.feeds.activity_feedback(
    activity_id,
    report=True,
    reason="inappropriate_content",
    user_id=self.test_user_id_2,  # Different user reporting
)

Get Blocked Users

Retrieve a list of users you have blocked.

let blockedUsers = try await client.moderation.getBlockedUsers()
for user in blockedUsers.users {
    print("Blocked user: \(user.id)")
}

val blockedUsers: Result<GetBlockedUsersResponse> = client.moderation.getBlockedUsers()
blockedUsers.getOrNull()?.blocks?.forEach { block ->
    println("Blocked user: ${block.user.id}")
}

final blockedUsers = await client.moderation.getBlockedUsers();
for (final user in blockedUsers.getOrThrow().blocks) {
  print('Blocked user: ${user.blockedUserId}');
}

response, err := client.GetBlockedUsers(ctx, &GetBlockedUsersRequest{UserID: 'user_id'})

ActivityFeedbackRequest moderationRequest =
    ActivityFeedbackRequest.builder()
        .report(true)
        .reason("inappropriate_content")
        .userID(testUserId2) // Different user reporting
        .build();

ActivityFeedbackResponse moderationResponse =
    feeds.activityFeedback(activityId, moderationRequest).execute().getData();

// Note: Moderation typically requires admin permissions
// This test demonstrates the API structure
Console.WriteLine($"Activity {activityId} would be moderated here");
// In a real scenario, you would call moderation endpoints

moderation_response = self.client.feeds.activity_feedback(
    activity_id,
    report=True,
    reason="inappropriate_content",
    user_id=self.test_user_id_2,  # Different user reporting
)

Content Moderation

Flag Content

Flag inappropriate content for moderation review.

let flagRequest = FlagRequest(
    entityId: "activity-123",
    entityType: "stream:feeds:v3:activity",
    reason: "Inappropriate content",
    entityCreatorId: "user-456"
)

let response = try await client.moderation.flag(flagRequest: flagRequest)

val flagRequest = FlagRequest(
    entityId = "activity-123",
    entityType = "stream:feeds:v3:activity",
    reason = "Inappropriate content",
    entityCreatorId = "user-456"
)

val response: Result<FlagResponse> = client.moderation.flag(flagRequest = flagRequest)

await client.moderation.flag({
  entity_type: "stream:feeds:v3:activity",
  entity_id: "activity_123",
  reason: "Inappropriate content",
});

await client.moderation.flag({
  entity_type: "stream:feeds:v3:activity",
  entity_id: "activity_123",
  reason: "Inappropriate content",
});

await client.moderation.flag({
  entity_type: "stream:feeds:v3:activity",
  entity_id: "activity_123",
  reason: "Inappropriate content",
});

const flagRequest = FlagRequest(
  entityId: 'activity-123',
  entityType: 'activity',
  reason: 'Inappropriate content',
  entityCreatorId: 'user-456',
);

final response = await client.moderation.flag(flagRequest: flagRequest);

await client.moderation.flag({
  entity_type: "stream:feeds:v3:activity",
  entity_id: "activity_123",
  reason: "Inappropriate content",
  user_id: "<moderator user id>",
});

request := &getstream.FlagRequest{
	EntityType:      "stream:feeds:v3:activity",
	EntityID:        "activity123",
	EntityCreatorID: getstream.PtrTo("user456"),
	Reason:          getstream.PtrTo("harassment"),
	UserID:          getstream.PtrTo("reporter789"),
}

_, err := client.Moderation().Flag(context.Background(), request)

ActivityFeedbackRequest moderationRequest =
    ActivityFeedbackRequest.builder()
        .report(true)
        .reason("inappropriate_content")
        .userID(testUserId2) // Different user reporting
        .build();

ActivityFeedbackResponse moderationResponse =
    feeds.activityFeedback(activityId, moderationRequest).execute().getData();

$flagRequest = new GeneratedModels\FlagRequest(
    entityID: "activity-123",
    entityType: "stream:feeds:v3:activity",
    reason: "Inappropriate content",
    entityCreatorID: "user-456",
    userID: "moderator"
);

$response = $moderationClient->flag($flagRequest);

// Note: Moderation typically requires admin permissions
// This test demonstrates the API structure
Console.WriteLine($"Activity {activityId} would be moderated here");
// In a real scenario, you would call moderation endpoints

moderation_response = self.client.feeds.activity_feedback(
    activity_id,
    report=True,
    reason="inappropriate_content",
    user_id=self.test_user_id_2,  # Different user reporting
)

Parameters:

entityId: The ID of the content to flag
entityType: The type of content (e.g., "stream:feeds:v3:activity", "stream:feeds:v3:comment")
reason: Optional reason for flagging
entityCreatorId: Optional ID of the content creator
custom: Optional custom data for the flag

Submit Moderation Actions

Submit moderation actions for flagged content.

let actionRequest = SubmitActionRequest(
    // Action details for moderation
)

let response = try await client.moderation.submitAction(submitActionRequest: actionRequest)

val actionRequest = SubmitActionRequest(
    // Action details for moderation
)

val response: Result<SubmitActionResponse> = client.moderation.submitAction(submitActionRequest = actionRequest)

const actionRequest = SubmitActionRequest(
  // Action details for moderation
);

final response = await client.moderation.submitAction(submitActionRequest: actionRequest);

request := &getstream.SubmitActionRequest{
	ItemID:     "review_item_123",
	ActionType: "mark_reviewed",
	UserID:     getstream.PtrTo("moderator456"),
}

_, err := client.Moderation().SubmitAction(context.Background(), request)

ActivityFeedbackRequest moderationRequest =
    ActivityFeedbackRequest.builder()
        .report(true)
        .reason("inappropriate_content")
        .userID(testUserId2) // Different user reporting
        .build();

ActivityFeedbackResponse moderationResponse =
    feeds.activityFeedback(activityId, moderationRequest).execute().getData();

$actionRequest = new GeneratedModels\SubmitActionRequest(
    // Action details for moderation
    userID: "moderator"
);

$response = $moderationClient->submitAction($actionRequest);

// Note: Moderation typically requires admin permissions
// This test demonstrates the API structure
Console.WriteLine($"Activity {activityId} would be moderated here");
// In a real scenario, you would call moderation endpoints

moderation_response = self.client.feeds.activity_feedback(
    activity_id,
    report=True,
    reason="inappropriate_content",
    user_id=self.test_user_id_2,  # Different user reporting
)

Review Queue

Query Review Queue

Retrieve items in the moderation review queue.

let queryRequest = QueryReviewQueueRequest(
    // Query parameters for filtering and pagination
)

let reviewQueue = try await client.moderation.queryReviewQueue(queryReviewQueueRequest: queryRequest)

val queryRequest = QueryReviewQueueRequest(
    // Query parameters for filtering and pagination
)

val reviewQueue: Result<QueryReviewQueueResponse> = client.moderation.queryReviewQueue(queryRequest)

const queryRequest = QueryReviewQueueRequest(
    // Query parameters for filtering and pagination
    );

final reviewQueue = await client.moderation
    .queryReviewQueue(queryReviewQueueRequest: queryRequest);

request := &getstream.QueryReviewQueueRequest{
	Filter: map[string]any{
		"status": "pending",
	},
	Limit: getstream.PtrTo(25),
}

_, err := client.Moderation().QueryReviewQueue(context.Background(), request)

ActivityFeedbackRequest moderationRequest =
    ActivityFeedbackRequest.builder()
        .report(true)
        .reason("inappropriate_content")
        .userID(testUserId2) // Different user reporting
        .build();

ActivityFeedbackResponse moderationResponse =
    feeds.activityFeedback(activityId, moderationRequest).execute().getData();

$queryRequest = new GeneratedModels\QueryReviewQueueRequest(
    limit: 10,
    lockItems: false,
    userID: "moderator"
);

$response = $moderationClient->queryReviewQueue($queryRequest);

// Note: Moderation typically requires admin permissions
// This test demonstrates the API structure
Console.WriteLine($"Activity {activityId} would be moderated here");
// In a real scenario, you would call moderation endpoints

moderation_response = self.client.feeds.activity_feedback(
    activity_id,
    report=True,
    reason="inappropriate_content",
    user_id=self.test_user_id_2,  # Different user reporting
)

Configuration Management

Upsert Moderation Configuration

Create or update moderation configuration settings.

let configRequest = UpsertConfigRequest(
    // Configuration details
)

let response = try await client.moderation.upsertConfig(upsertConfigRequest: configRequest)

val configRequest = UpsertConfigRequest(
    // Configuration details
)

val response: Result<UpsertConfigResponse> = client.moderation.upsertConfig(configRequest)

client.moderation.upsertConfig({
    key: 'feeds',
    block_list_config: {
        enabled: true,
        rules: [
        // Names of existing block lists
        { name: blocklistName, action: 'remove' },
        { name: flagBlocklistName, action: 'flag' },
        { name: shadowBlocklistName, action: 'shadow' },
        { name: bounceBlocklistName, action: 'bounce' },
        ],
    },
    ai_image_config: {
        enabled: true,
        rules: [{ label: 'Non-Explicit Nudity', action: 'remove', min_confidence: 0 }],
        ocr_rules: [{ label: 'Non-Explicit Nudity', action: 'remove' }],
    },
}),

client.moderation.upsertConfig({
    key: 'feeds',
    block_list_config: {
        enabled: true,
        rules: [
        // Names of existing block lists
        { name: blocklistName, action: 'remove' },
        { name: flagBlocklistName, action: 'flag' },
        { name: shadowBlocklistName, action: 'shadow' },
        { name: bounceBlocklistName, action: 'bounce' },
        ],
    },
    ai_image_config: {
        enabled: true,
        rules: [{ label: 'Non-Explicit Nudity', action: 'remove', min_confidence: 0 }],
        ocr_rules: [{ label: 'Non-Explicit Nudity', action: 'remove' }],
    },
}),

client.moderation.upsertConfig({
    key: 'feeds',
    block_list_config: {
        enabled: true,
        rules: [
        // Names of existing block lists
        { name: blocklistName, action: 'remove' },
        { name: flagBlocklistName, action: 'flag' },
        { name: shadowBlocklistName, action: 'shadow' },
        { name: bounceBlocklistName, action: 'bounce' },
        ],
    },
    ai_image_config: {
        enabled: true,
        rules: [{ label: 'Non-Explicit Nudity', action: 'remove', min_confidence: 0 }],
        ocr_rules: [{ label: 'Non-Explicit Nudity', action: 'remove' }],
    },
}),

const upsertRequest = UpsertConfigRequest(
  // Configuration details for moderation
);

final response = await client.moderation.upsertConfig(upsertRequest);

client.moderation.upsertConfig({
    key: 'feeds',
    block_list_config: {
        enabled: true,
        rules: [
        // Names of existing block lists
        { name: blocklistName, action: 'remove' },
        { name: flagBlocklistName, action: 'flag' },
        { name: shadowBlocklistName, action: 'shadow' },
        { name: bounceBlocklistName, action: 'bounce' },
        ],
    },
    ai_image_config: {
        enabled: true,
        rules: [{ label: 'Non-Explicit Nudity', action: 'remove', min_confidence: 0 }],
        ocr_rules: [{ label: 'Non-Explicit Nudity', action: 'remove' }],
    },
}),

request := &getstream.UpsertConfigRequest{
	Key: "chat:messaging:general",
	AutomodToxicityConfig: &getstream.AutomodToxicityConfig{
		Enabled: getstream.PtrTo(true),
		Rules: []getstream.AutomodRule{
			{
				Label:     "toxic",
				Threshold: 0.8,
				Action:    "remove",
			},
		},
	},
}

_, err := client.Moderation().UpsertConfig(context.Background(), request)

ActivityFeedbackRequest moderationRequest =
    ActivityFeedbackRequest.builder()
        .report(true)
        .reason("inappropriate_content")
        .userID(testUserId2) // Different user reporting
        .build();

ActivityFeedbackResponse moderationResponse =
    feeds.activityFeedback(activityId, moderationRequest).execute().getData();

$configRequest = new GeneratedModels\UpsertConfigRequest(
    key: "feeds",
    blockListConfig: new GeneratedModels\BlockListConfig(
        enabled: true,
        rules: [
            new GeneratedModels\BlockListRule(
                name: "blocklist",
                action: "remove",
            )
        ]
    ),
    userID: "moderator"
);

$response = $moderationClient->upsertConfig($configRequest);

// Note: Moderation typically requires admin permissions
// This test demonstrates the API structure
Console.WriteLine($"Activity {activityId} would be moderated here");
// In a real scenario, you would call moderation endpoints

moderation_response = self.client.feeds.activity_feedback(
    activity_id,
    report=True,
    reason="inappropriate_content",
    user_id=self.test_user_id_2,  # Different user reporting
)

Get Moderation Configuration

Retrieve a specific moderation configuration.

request := &getstream.GetConfigRequest{
	Team: getstream.PtrTo(""),
}

_, err := client.Moderation().GetConfig(context.Background(), "feeds", request)

ActivityFeedbackRequest moderationRequest =
    ActivityFeedbackRequest.builder()
        .report(true)
        .reason("inappropriate_content")
        .userID(testUserId2) // Different user reporting
        .build();

ActivityFeedbackResponse moderationResponse =
    feeds.activityFeedback(activityId, moderationRequest).execute().getData();

// Note: Moderation typically requires admin permissions
// This test demonstrates the API structure
Console.WriteLine($"Activity {activityId} would be moderated here");
// In a real scenario, you would call moderation endpoints

moderation_response = self.client.feeds.activity_feedback(
    activity_id,
    report=True,
    reason="inappropriate_content",
    user_id=self.test_user_id_2,  # Different user reporting
)

Parameters:

key: The configuration key to retrieve
team: Optional team identifier

Delete Moderation Configuration

Remove a moderation configuration.

val response: Result<DeleteModerationConfigResponse> = client.moderation.deleteConfig(key = "automod_settings", team = "team-123")

request := &getstream.DeleteConfigRequest{
}

_, err := client.Moderation().DeleteConfig(context.Background(), "feeds", request)

ActivityFeedbackRequest moderationRequest =
    ActivityFeedbackRequest.builder()
        .report(true)
        .reason("inappropriate_content")
        .userID(testUserId2) // Different user reporting
        .build();

ActivityFeedbackResponse moderationResponse =
    feeds.activityFeedback(activityId, moderationRequest).execute().getData();

// Note: Moderation typically requires admin permissions
// This test demonstrates the API structure
Console.WriteLine($"Activity {activityId} would be moderated here");
// In a real scenario, you would call moderation endpoints

moderation_response = self.client.feeds.activity_feedback(
    activity_id,
    report=True,
    reason="inappropriate_content",
    user_id=self.test_user_id_2,  # Different user reporting
)

Query Moderation Configurations

Search and filter moderation configurations.

let queryRequest = QueryModerationConfigsRequest(
    // Query parameters for filtering and pagination
)

let configs = try await client.moderation.queryModerationConfigs(queryModerationConfigsRequest: queryRequest)

val queryRequest = QueryModerationConfigsRequest(
    // Query parameters for filtering and pagination
)

val configs: Result<QueryModerationConfigsResponse> = client.moderation.queryModerationConfigs(queryModerationConfigsRequest = queryRequest)

const queryRequest = ModerationConfigsQuery(
    // Query parameters for filtering and pagination
    );

final configs = await client.moderation
    .queryModerationConfigs(queryModerationConfigsRequest: queryRequest);

request := &getstream.QueryModerationConfigsRequest{
	Filter: map[string]any{
		"key": map[string]any{
			"$in": []string{"feeds", "automod"},
		},
	},
	Limit: getstream.PtrTo(10),
}

_, err := client.Moderation().QueryModerationConfigs(context.Background(), request)

ActivityFeedbackRequest moderationRequest =
    ActivityFeedbackRequest.builder()
        .report(true)
        .reason("inappropriate_content")
        .userID(testUserId2) // Different user reporting
        .build();

ActivityFeedbackResponse moderationResponse =
    feeds.activityFeedback(activityId, moderationRequest).execute().getData();

$queryRequest = new GeneratedModels\QueryModerationConfigsRequest(
    limit: 10,
    filter: (object)[
        "key" => (object)['$in' => ["feeds", "automod"]]
    ]
);

$response = $moderationClient->queryModerationConfigs($queryRequest);

// Note: Moderation typically requires admin permissions
// This test demonstrates the API structure
Console.WriteLine($"Activity {activityId} would be moderated here");
// In a real scenario, you would call moderation endpoints

moderation_response = self.client.feeds.activity_feedback(
    activity_id,
    report=True,
    reason="inappropriate_content",
    user_id=self.test_user_id_2,  # Different user reporting
)

Moderation Config Queryable Built-In Fields

name	type	description	supported operations	example
`key`	string or list of strings	The configuration key identifier	`$eq`, `$ne`, `$gt`, `$gte`, `$lt`, `$lte`, `$in`, `$nin`, `$exists`, `$autocomplete`	`{ key: { $autocomplete: 'spam' } }`
`team`	string or list of strings	The team identifier for multi-tenant applications	`$eq`, `$ne`, `$gt`, `$gte`, `$lt`, `$lte`, `$in`, `$nin`, `$exists`	`{ team: { $eq: 'team_123' } }`
`created_at`	string, must be formatted as an RFC3339 timestamp	The time the configuration was created	`$eq`, `$gt`, `$gte`, `$lt`, `$lte`	`{ created_at: { $gte: '2023-12-04T09:30:20.45Z' } }`
`updated_at`	string, must be formatted as an RFC3339 timestamp	The time the configuration was last updated	`$eq`, `$gt`, `$gte`, `$lt`, `$lte`	`{ updated_at: { $gte: '2023-12-04T09:30:20.45Z' } }`

Error Handling

All moderation methods can throw errors. Handle them appropriately:

do {
    let response = try await client.moderation.ban(banRequest: banRequest)
    print("User banned successfully")
} catch {
    print("Failed to ban user: \(error)")
}

// Functions that can result in errors, return Kotlin `Result` objects
val result: Result<BanResponse> = client.moderation.ban(banRequest)

try {
  const response = await client.moderation.ban({
    target_user_id: "user-123",
    reason: "Violation of community guidelines",
    timeout: 3600, // 1 hour in seconds
    shadow: false,
    ip_ban: false,
  });

  console.log(`Banned successfully`);
} catch (e) {
  console.error(`Failed to ban user, error: ${e}`);
}

try {
  const response = await client.moderation.ban({
    target_user_id: "user-123",
    reason: "Violation of community guidelines",
    timeout: 3600, // 1 hour in seconds
    shadow: false,
    ip_ban: false,
  });

  console.log(`Banned successfully`);
} catch (e) {
  console.error(`Failed to ban user, error: ${e}`);
}

try {
  const response = await client.moderation.ban({
    target_user_id: "user-123",
    reason: "Violation of community guidelines",
    timeout: 3600, // 1 hour in seconds
    shadow: false,
    ip_ban: false,
  });

  console.log(`Banned successfully`);
} catch (e) {
  console.error(`Failed to ban user, error: ${e}`);
}

final response = await client.moderation.ban(banRequest: banRequest);

switch (response) {
  case Success(data: final banResponse):
    print('User banned for: ${banResponse.duration}');
  case Failure(error: final error):
    print('Error banning user: $error');
}

try {
  const response = await client.moderation.ban({
    target_user_id: "user-123",
    banned_by_id: "<banned by user id>",
    reason: "Violation of community guidelines",
    timeout: 3600, // 1 hour in seconds
    shadow: false,
    ip_ban: false,
  });

  console.log(`Banned successfully`);
} catch (e) {
  console.error(`Failed to ban user, error: ${e}`);
}

request := &getstream.BanRequest{
	TargetUserID: "user123",
	Reason:       getstream.PtrTo("spam"),
	Timeout:      getstream.PtrTo(60),
	BannedByID:   getstream.PtrTo("moderator456"),
}

_, err := client.Moderation().Ban(context.Background(), request)
if err != nil {
	// Handle error
	log.Printf("Failed to ban user: %v", err)
}

ActivityFeedbackRequest moderationRequest =
    ActivityFeedbackRequest.builder()
        .report(true)
        .reason("inappropriate_content")
        .userID(testUserId2) // Different user reporting
        .build();

ActivityFeedbackResponse moderationResponse =
    feeds.activityFeedback(activityId, moderationRequest).execute().getData();

try {
    $banRequest = new GeneratedModels\BanRequest(
        targetUserID: "user-123",
        reason: "Violation of community guidelines",
        timeout: 60, // 1 hour in minutes
        shadow: false,
        ipBan: false,
        bannedByID: "moderator"
    );

    $response = $moderationClient->ban($banRequest);
    echo "User banned successfully\n";
} catch (Exception $e) {
    echo "Failed to ban user: " . $e->getResponseBody() . "\n";
}

// Note: Moderation typically requires admin permissions
// This test demonstrates the API structure
Console.WriteLine($"Activity {activityId} would be moderated here");
// In a real scenario, you would call moderation endpoints

moderation_response = self.client.feeds.activity_feedback(
    activity_id,
    report=True,
    reason="inappropriate_content",
    user_id=self.test_user_id_2,  # Different user reporting
)

Event Handling

Collections