Activity Feeds V3 is in closed alpha — do not use it in production (just yet).

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

let client = FeedsClient(apiKey: apiKey, user: user, token: token)
let moderation = client.moderation

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

const client = new FeedsClient("<API key>");

client.moderation;

const apiKey = "";
const secret = "";
const client = new StreamClient(apiKey, secret);

client.moderation;

moderationResponse, err := feedsClient.ActivityFeedback(ctx, activityID, &getstream.ActivityFeedbackRequest{
	Report: getstream.PtrTo(true),
	Reason: getstream.PtrTo("inappropriate_content"),
	UserID: &testUserID2, // Different user reporting
})

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

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

$moderationResponse = $this->feedsV3Client->activityFeedback(
    $activityId,
    new GeneratedModels\ActivityFeedbackRequest(
        report: true,
        reason: 'inappropriate_content',
        userID: $this->testUserId2 // Different user reporting
    )
);

// 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",
  banned_by_id: "<banned by user id>",
  reason: "Violation of community guidelines",
  timeout: 3600, // 1 hour in seconds
  shadow: false,
  ip_ban: false,
});

moderationResponse, err := feedsClient.ActivityFeedback(ctx, activityID, &getstream.ActivityFeedbackRequest{
	Report: getstream.PtrTo(true),
	Reason: getstream.PtrTo("inappropriate_content"),
	UserID: &testUserID2, // Different user reporting
})

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

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

$moderationResponse = $this->feedsV3Client->activityFeedback(
    $activityId,
    new GeneratedModels\ActivityFeedbackRequest(
        report: true,
        reason: 'inappropriate_content',
        userID: $this->testUserId2 // Different user reporting
    )
);

// 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)

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

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

moderationResponse, err := feedsClient.ActivityFeedback(ctx, activityID, &getstream.ActivityFeedbackRequest{
	Report: getstream.PtrTo(true),
	Reason: getstream.PtrTo("inappropriate_content"),
	UserID: &testUserID2, // Different user reporting
})

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

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

$moderationResponse = $this->feedsV3Client->activityFeedback(
    $activityId,
    new GeneratedModels\ActivityFeedbackRequest(
        report: true,
        reason: 'inappropriate_content',
        userID: $this->testUserId2 // Different user reporting
    )
);

// 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)

await client.blockUsers({
  blocked_user_id: "user-123",
});

await client.blockUsers({
  blocked_user_id: "user-123",
  user_id: "<moderator id>",
});

moderationResponse, err := feedsClient.ActivityFeedback(ctx, activityID, &getstream.ActivityFeedbackRequest{
	Report: getstream.PtrTo(true),
	Reason: getstream.PtrTo("inappropriate_content"),
	UserID: &testUserID2, // Different user reporting
})

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

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

$moderationResponse = $this->feedsV3Client->activityFeedback(
    $activityId,
    new GeneratedModels\ActivityFeedbackRequest(
        report: true,
        reason: 'inappropriate_content',
        userID: $this->testUserId2 // Different user reporting
    )
);

// 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)

client.unblockUsers({
  blocked_user_id: "user-123",
});

client.unblockUsers({
  blocked_user_id: "user-123",
  user_id: "<moderator user id>",
});

moderationResponse, err := feedsClient.ActivityFeedback(ctx, activityID, &getstream.ActivityFeedbackRequest{
	Report: getstream.PtrTo(true),
	Reason: getstream.PtrTo("inappropriate_content"),
	UserID: &testUserID2, // Different user reporting
})

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

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

$moderationResponse = $this->feedsV3Client->activityFeedback(
    $activityId,
    new GeneratedModels\ActivityFeedbackRequest(
        report: true,
        reason: 'inappropriate_content',
        userID: $this->testUserId2 // Different user reporting
    )
);

// 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}")
}

client.getBlockedUsers();

client.getBlockedUsers({ user_id: "<moderator user id>" });

moderationResponse, err := feedsClient.ActivityFeedback(ctx, activityID, &getstream.ActivityFeedbackRequest{
	Report: getstream.PtrTo(true),
	Reason: getstream.PtrTo("inappropriate_content"),
	UserID: &testUserID2, // Different user reporting
})

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

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

$moderationResponse = $this->feedsV3Client->activityFeedback(
    $activityId,
    new GeneratedModels\ActivityFeedbackRequest(
        report: true,
        reason: 'inappropriate_content',
        userID: $this->testUserId2 // Different user reporting
    )
);

// 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: "activity",
    reason: "Inappropriate content",
    entityCreatorId: "user-456"
)

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

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

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

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

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

moderationResponse, err := feedsClient.ActivityFeedback(ctx, activityID, &getstream.ActivityFeedbackRequest{
	Report: getstream.PtrTo(true),
	Reason: getstream.PtrTo("inappropriate_content"),
	UserID: &testUserID2, // Different user reporting
})

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

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

$moderationResponse = $this->feedsV3Client->activityFeedback(
    $activityId,
    new GeneratedModels\ActivityFeedbackRequest(
        report: true,
        reason: 'inappropriate_content',
        userID: $this->testUserId2 // Different user reporting
    )
);

// 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., “activity”, “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)

client.moderation.submitAction({
  // Action details for moderation
});

client.moderation.submitAction({
  // Action details for moderation
  user_id: "<user id>",
});

moderationResponse, err := feedsClient.ActivityFeedback(ctx, activityID, &getstream.ActivityFeedbackRequest{
	Report: getstream.PtrTo(true),
	Reason: getstream.PtrTo("inappropriate_content"),
	UserID: &testUserID2, // Different user reporting
})

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

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

$moderationResponse = $this->feedsV3Client->activityFeedback(
    $activityId,
    new GeneratedModels\ActivityFeedbackRequest(
        report: true,
        reason: 'inappropriate_content',
        userID: $this->testUserId2 // Different user reporting
    )
);

// 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)

client.moderation.queryReviewQueue({
  // Query parameters for filtering and pagination
});

client.moderation.queryReviewQueue({
  // Query parameters for filtering and pagination
  user_id: user.id,
});

moderationResponse, err := feedsClient.ActivityFeedback(ctx, activityID, &getstream.ActivityFeedbackRequest{
	Report: getstream.PtrTo(true),
	Reason: getstream.PtrTo("inappropriate_content"),
	UserID: &testUserID2, // Different user reporting
})

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

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

$moderationResponse = $this->feedsV3Client->activityFeedback(
    $activityId,
    new GeneratedModels\ActivityFeedbackRequest(
        report: true,
        reason: 'inappropriate_content',
        userID: $this->testUserId2 // Different user reporting
    )
);

// 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', team: '' },
        { name: flagBlocklistName, action: 'flag', team: '' },
        { name: shadowBlocklistName, action: 'shadow', team: '' },
        { name: bounceBlocklistName, action: 'bounce', team: '' },
        ],
    },
    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', team: '' },
        { name: flagBlocklistName, action: 'flag', team: '' },
        { name: shadowBlocklistName, action: 'shadow', team: '' },
        { name: bounceBlocklistName, action: 'bounce', team: '' },
        ],
    },
    ai_image_config: {
        enabled: true,
        rules: [{ label: 'Non-Explicit Nudity', action: 'remove', min_confidence: 0 }],
        ocr_rules: [{ label: 'Non-Explicit Nudity', action: 'remove' }],
    },
}),

moderationResponse, err := feedsClient.ActivityFeedback(ctx, activityID, &getstream.ActivityFeedbackRequest{
	Report: getstream.PtrTo(true),
	Reason: getstream.PtrTo("inappropriate_content"),
	UserID: &testUserID2, // Different user reporting
})

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

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

$moderationResponse = $this->feedsV3Client->activityFeedback(
    $activityId,
    new GeneratedModels\ActivityFeedbackRequest(
        report: true,
        reason: 'inappropriate_content',
        userID: $this->testUserId2 // Different user reporting
    )
);

// 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.

let config = try await client.moderation.getConfig(key: "automod_settings", team: "team-123")

val config: Result<GetConfigResponse> = client.moderation.getConfig(key = "automod_settings", team = "team-123")

client.moderation.getConfig({
  key: "feeds",
});

client.moderation.getConfig({
  key: "feeds",
});

moderationResponse, err := feedsClient.ActivityFeedback(ctx, activityID, &getstream.ActivityFeedbackRequest{
	Report: getstream.PtrTo(true),
	Reason: getstream.PtrTo("inappropriate_content"),
	UserID: &testUserID2, // Different user reporting
})

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

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

$moderationResponse = $this->feedsV3Client->activityFeedback(
    $activityId,
    new GeneratedModels\ActivityFeedbackRequest(
        report: true,
        reason: 'inappropriate_content',
        userID: $this->testUserId2 // Different user reporting
    )
);

// 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.

let response = try await client.moderation.deleteConfig(key: "automod_settings", team: "team-123")

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

client.moderation.deleteConfig({
  key: "feeds",
});

client.moderation.deleteConfig({
  key: "feeds",
});

moderationResponse, err := feedsClient.ActivityFeedback(ctx, activityID, &getstream.ActivityFeedbackRequest{
	Report: getstream.PtrTo(true),
	Reason: getstream.PtrTo("inappropriate_content"),
	UserID: &testUserID2, // Different user reporting
})

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

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

$moderationResponse = $this->feedsV3Client->activityFeedback(
    $activityId,
    new GeneratedModels\ActivityFeedbackRequest(
        report: true,
        reason: 'inappropriate_content',
        userID: $this->testUserId2 // Different user reporting
    )
);

// 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)

client.moderation.queryModerationConfigs({
  filter: {
    // Filter params
  },
});

client.moderation.queryModerationConfigs({
  filter: {
    // Filter params
  },
});

moderationResponse, err := feedsClient.ActivityFeedback(ctx, activityID, &getstream.ActivityFeedbackRequest{
	Report: getstream.PtrTo(true),
	Reason: getstream.PtrTo("inappropriate_content"),
	UserID: &testUserID2, // Different user reporting
})

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

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

$moderationResponse = $this->feedsV3Client->activityFeedback(
    $activityId,
    new GeneratedModels\ActivityFeedbackRequest(
        report: true,
        reason: 'inappropriate_content',
        userID: $this->testUserId2 // Different user reporting
    )
);

// 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
)

Error Handling

All moderation methods can throw errors. Handle them appropriately:

// 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",
    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}`);
}

moderationResponse, err := feedsClient.ActivityFeedback(ctx, activityID, &getstream.ActivityFeedbackRequest{
	Report: getstream.PtrTo(true),
	Reason: getstream.PtrTo("inappropriate_content"),
	UserID: &testUserID2, // Different user reporting
})

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

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

$moderationResponse = $this->feedsV3Client->activityFeedback(
    $activityId,
    new GeneratedModels\ActivityFeedbackRequest(
        report: true,
        reason: 'inappropriate_content',
        userID: $this->testUserId2 // Different user reporting
    )
);

// 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
)

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",
    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}`);
}

moderationResponse, err := feedsClient.ActivityFeedback(ctx, activityID, &getstream.ActivityFeedbackRequest{
	Report: getstream.PtrTo(true),
	Reason: getstream.PtrTo("inappropriate_content"),
	UserID: &testUserID2, // Different user reporting
})

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

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

$moderationResponse = $this->feedsV3Client->activityFeedback(
    $activityId,
    new GeneratedModels\ActivityFeedbackRequest(
        report: true,
        reason: 'inappropriate_content',
        userID: $this->testUserId2 // Different user reporting
    )
);

// 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
)

Polls

Import Files