moderation.go

// Code generated by GetStream internal OpenAPI code generator. DO NOT EDIT.
package getstream

import (
	"context"
)

type ModerationClient struct {
	client *Client
}

func NewModerationClient(client *Client) *ModerationClient {
	return &ModerationClient{
		client: client,
	}
}

// Returns moderation action configs grouped by entity type, sorted by order ascending. Supports fetching DB-configured actions, hardcoded defaults, or both.
func (c *ModerationClient) GetActionConfig(ctx context.Context, request *GetActionConfigRequest) (*StreamResponse[GetActionConfigResponse], error) {
	var result GetActionConfigResponse
	params := extractQueryParams(request)
	res, err := MakeRequest[any, GetActionConfigResponse](c.client, ctx, "GET", "/api/v2/moderation/action_config", params, nil, &result, nil)
	return res, err
}

// Create a new moderation action config entry or update an existing one. Action configs control the action buttons displayed in the moderation dashboard for each entity type.
func (c *ModerationClient) UpsertActionConfig(ctx context.Context, request *UpsertActionConfigRequest) (*StreamResponse[UpsertActionConfigResponse], error) {
	var result UpsertActionConfigResponse
	res, err := MakeRequest[UpsertActionConfigRequest, UpsertActionConfigResponse](c.client, ctx, "POST", "/api/v2/moderation/action_config", nil, request, &result, nil)
	return res, err
}

// Create or update multiple moderation action config entries in a single request. Omit the ID field to create; provide an ID to update.
func (c *ModerationClient) BulkUpsertActionConfig(ctx context.Context, request *BulkUpsertActionConfigRequest) (*StreamResponse[BulkUpsertActionConfigResponse], error) {
	var result BulkUpsertActionConfigResponse
	res, err := MakeRequest[BulkUpsertActionConfigRequest, BulkUpsertActionConfigResponse](c.client, ctx, "POST", "/api/v2/moderation/action_config/bulk", nil, request, &result, nil)
	return res, err
}

// Delete multiple moderation action config entries by UUID in a single request.
func (c *ModerationClient) BulkDeleteActionConfig(ctx context.Context, request *BulkDeleteActionConfigRequest) (*StreamResponse[BulkDeleteActionConfigResponse], error) {
	var result BulkDeleteActionConfigResponse
	res, err := MakeRequest[BulkDeleteActionConfigRequest, BulkDeleteActionConfigResponse](c.client, ctx, "POST", "/api/v2/moderation/action_config/bulk_delete", nil, request, &result, nil)
	return res, err
}

// Delete a specific moderation action config entry by its UUID.
func (c *ModerationClient) DeleteActionConfig(ctx context.Context, id string, request *DeleteActionConfigRequest) (*StreamResponse[DeleteActionConfigResponse], error) {
	var result DeleteActionConfigResponse
	pathParams := map[string]string{
		"id": id,
	}
	params := extractQueryParams(request)
	res, err := MakeRequest[any, DeleteActionConfigResponse](c.client, ctx, "DELETE", "/api/v2/moderation/action_config/{id}", params, nil, &result, pathParams)
	return res, err
}

// Insert a moderation action log entry. Server-side only. Used by product services to log moderation-related actions.
func (c *ModerationClient) InsertActionLog(ctx context.Context, request *InsertActionLogRequest) (*StreamResponse[InsertActionLogResponse], error) {
	var result InsertActionLogResponse
	res, err := MakeRequest[InsertActionLogRequest, InsertActionLogResponse](c.client, ctx, "POST", "/api/v2/moderation/action_logs", nil, request, &result, nil)
	return res, err
}

// Moderate named text fields and raw image bytes via multipart/form-data. Returns a per-field lightweight verdict.
func (c *ModerationClient) Analyze(ctx context.Context, request *AnalyzeRequest) (*StreamResponse[AnalyzeResponse], error) {
	var result AnalyzeResponse
	res, err := MakeRequest[AnalyzeRequest, AnalyzeResponse](c.client, ctx, "POST", "/api/v2/moderation/analyze", nil, request, &result, nil)
	return res, err
}

// Appeal against the moderation decision
func (c *ModerationClient) Appeal(ctx context.Context, request *AppealRequest) (*StreamResponse[AppealResponse], error) {
	var result AppealResponse
	res, err := MakeRequest[AppealRequest, AppealResponse](c.client, ctx, "POST", "/api/v2/moderation/appeal", nil, request, &result, nil)
	return res, err
}

// Retrieve a specific appeal item by its ID
func (c *ModerationClient) GetAppeal(ctx context.Context, id string, request *GetAppealRequest) (*StreamResponse[GetAppealResponse], error) {
	var result GetAppealResponse
	pathParams := map[string]string{
		"id": id,
	}
	res, err := MakeRequest[any, GetAppealResponse](c.client, ctx, "GET", "/api/v2/moderation/appeal/{id}", nil, nil, &result, pathParams)
	return res, err
}

// Query Appeals
func (c *ModerationClient) QueryAppeals(ctx context.Context, request *QueryAppealsRequest) (*StreamResponse[QueryAppealsResponse], error) {
	var result QueryAppealsResponse
	res, err := MakeRequest[QueryAppealsRequest, QueryAppealsResponse](c.client, ctx, "POST", "/api/v2/moderation/appeals", nil, request, &result, nil)
	return res, err
}

// Process multiple appeals in a single request by applying the specified action to each. Supported actions: unban, restore, unblock, mark_reviewed, reject_appeal. Each appeal goes through the same path as a single submit_action call.
func (c *ModerationClient) BulkActionAppeals(ctx context.Context, request *BulkActionAppealsRequest) (*StreamResponse[BulkActionAppealsResponse], error) {
	var result BulkActionAppealsResponse
	res, err := MakeRequest[BulkActionAppealsRequest, BulkActionAppealsResponse](c.client, ctx, "POST", "/api/v2/moderation/appeals/bulk_action", nil, request, &result, nil)
	return res, err
}

// Ban a user from a channel or the entire app
func (c *ModerationClient) Ban(ctx context.Context, request *BanRequest) (*StreamResponse[ModerationBanResponse], error) {
	var result ModerationBanResponse
	res, err := MakeRequest[BanRequest, ModerationBanResponse](c.client, ctx, "POST", "/api/v2/moderation/ban", nil, request, &result, nil)
	return res, err
}

// Moderate multiple images in bulk using a CSV file
func (c *ModerationClient) BulkImageModeration(ctx context.Context, request *BulkImageModerationRequest) (*StreamResponse[BulkImageModerationResponse], error) {
	var result BulkImageModerationResponse
	res, err := MakeRequest[BulkImageModerationRequest, BulkImageModerationResponse](c.client, ctx, "POST", "/api/v2/moderation/bulk_image_moderation", nil, request, &result, nil)
	return res, err
}

// Enable or disable moderation bypass for a user. This endpoint is server-side only.
func (c *ModerationClient) Bypass(ctx context.Context, request *BypassRequest) (*StreamResponse[BypassResponse], error) {
	var result BypassResponse
	res, err := MakeRequest[BypassRequest, BypassResponse](c.client, ctx, "POST", "/api/v2/moderation/bypass", nil, request, &result, nil)
	return res, err
}

// Run moderation checks on the provided content
func (c *ModerationClient) Check(ctx context.Context, request *CheckRequest) (*StreamResponse[CheckResponse], error) {
	var result CheckResponse
	res, err := MakeRequest[CheckRequest, CheckResponse](c.client, ctx, "POST", "/api/v2/moderation/check", nil, request, &result, nil)
	return res, err
}

// Verifies that the configured IAM role ARN can access private S3 images for moderation. Optionally accepts a stream+s3:// URL to check access to a specific object.
func (c *ModerationClient) CheckS3Access(ctx context.Context, request *CheckS3AccessRequest) (*StreamResponse[CheckS3AccessResponse], error) {
	var result CheckS3AccessResponse
	res, err := MakeRequest[CheckS3AccessRequest, CheckS3AccessResponse](c.client, ctx, "POST", "/api/v2/moderation/check_s3_access", nil, request, &result, nil)
	return res, err
}

// Create a new moderation configuration or update an existing one. Configure settings for content filtering, AI analysis, toxicity detection, and other moderation features.
func (c *ModerationClient) UpsertConfig(ctx context.Context, request *UpsertConfigRequest) (*StreamResponse[UpsertConfigResponse], error) {
	var result UpsertConfigResponse
	res, err := MakeRequest[UpsertConfigRequest, UpsertConfigResponse](c.client, ctx, "POST", "/api/v2/moderation/config", nil, request, &result, nil)
	return res, err
}

// Delete a specific moderation policy by its name
func (c *ModerationClient) DeleteConfig(ctx context.Context, key string, request *DeleteConfigRequest) (*StreamResponse[DeleteModerationConfigResponse], error) {
	var result DeleteModerationConfigResponse
	pathParams := map[string]string{
		"key": key,
	}
	params := extractQueryParams(request)
	res, err := MakeRequest[any, DeleteModerationConfigResponse](c.client, ctx, "DELETE", "/api/v2/moderation/config/{key}", params, nil, &result, pathParams)
	return res, err
}

// Retrieve a specific moderation configuration by its key and team. This configuration contains settings for various moderation features like toxicity detection, AI analysis, and filtering rules.
func (c *ModerationClient) GetConfig(ctx context.Context, key string, request *GetConfigRequest) (*StreamResponse[GetConfigResponse], error) {
	var result GetConfigResponse
	pathParams := map[string]string{
		"key": key,
	}
	params := extractQueryParams(request)
	res, err := MakeRequest[any, GetConfigResponse](c.client, ctx, "GET", "/api/v2/moderation/config/{key}", params, nil, &result, pathParams)
	return res, err
}

// Search and filter moderation configurations across your application. This endpoint is designed for building moderation dashboards and managing multiple configuration sets.
func (c *ModerationClient) QueryModerationConfigs(ctx context.Context, request *QueryModerationConfigsRequest) (*StreamResponse[QueryModerationConfigsResponse], error) {
	var result QueryModerationConfigsResponse
	res, err := MakeRequest[QueryModerationConfigsRequest, QueryModerationConfigsResponse](c.client, ctx, "POST", "/api/v2/moderation/configs", nil, request, &result, nil)
	return res, err
}

// Custom check, add your own AI model reports to the review queue
func (c *ModerationClient) CustomCheck(ctx context.Context, request *CustomCheckRequest) (*StreamResponse[CustomCheckResponse], error) {
	var result CustomCheckResponse
	res, err := MakeRequest[CustomCheckRequest, CustomCheckResponse](c.client, ctx, "POST", "/api/v2/moderation/custom_check", nil, request, &result, nil)
	return res, err
}

// List moderation feedback submissions that have an item matching the filter, with those items, sorting and pagination. Server-side only.
func (c *ModerationClient) QueryModerationFeedback(ctx context.Context, request *QueryModerationFeedbackRequest) (*StreamResponse[QueryModerationFeedbackResponse], error) {
	var result QueryModerationFeedbackResponse
	res, err := MakeRequest[QueryModerationFeedbackRequest, QueryModerationFeedbackResponse](c.client, ctx, "POST", "/api/v2/moderation/feedback_items", nil, request, &result, nil)
	return res, err
}

// Delete a specific moderation template by its name
func (c *ModerationClient) V2DeleteTemplate(ctx context.Context, request *V2DeleteTemplateRequest) (*StreamResponse[DeleteModerationTemplateResponse], error) {
	var result DeleteModerationTemplateResponse
	params := extractQueryParams(request)
	res, err := MakeRequest[any, DeleteModerationTemplateResponse](c.client, ctx, "DELETE", "/api/v2/moderation/feeds_moderation_template", params, nil, &result, nil)
	return res, err
}

// Retrieve a list of feed moderation templates that define preset moderation rules and configurations. Limited to 100 templates per request.
func (c *ModerationClient) V2QueryTemplates(ctx context.Context, request *V2QueryTemplatesRequest) (*StreamResponse[QueryFeedModerationTemplatesResponse], error) {
	var result QueryFeedModerationTemplatesResponse
	res, err := MakeRequest[any, QueryFeedModerationTemplatesResponse](c.client, ctx, "GET", "/api/v2/moderation/feeds_moderation_template", nil, nil, &result, nil)
	return res, err
}

// Upsert feeds template for moderation
func (c *ModerationClient) V2UpsertTemplate(ctx context.Context, request *V2UpsertTemplateRequest) (*StreamResponse[UpsertModerationTemplateResponse], error) {
	var result UpsertModerationTemplateResponse
	res, err := MakeRequest[V2UpsertTemplateRequest, UpsertModerationTemplateResponse](c.client, ctx, "POST", "/api/v2/moderation/feeds_moderation_template", nil, request, &result, nil)
	return res, err
}

// Flag any type of content (messages, users, channels, activities) for moderation review. Supports custom content types and additional metadata for flagged content.
func (c *ModerationClient) Flag(ctx context.Context, request *FlagRequest) (*StreamResponse[FlagItemResponse], error) {
	var result FlagItemResponse
	res, err := MakeRequest[FlagRequest, FlagItemResponse](c.client, ctx, "POST", "/api/v2/moderation/flag", nil, request, &result, nil)
	return res, err
}

// Returns the number of moderation flags created against a specific user's content. Optionally filter by entity type.
func (c *ModerationClient) GetFlagCount(ctx context.Context, request *GetFlagCountRequest) (*StreamResponse[GetFlagCountResponse], error) {
	var result GetFlagCountResponse
	res, err := MakeRequest[GetFlagCountRequest, GetFlagCountResponse](c.client, ctx, "POST", "/api/v2/moderation/flag_count", nil, request, &result, nil)
	return res, err
}

// Query flags associated with moderation items. This is used for building a moderation dashboard.
func (c *ModerationClient) QueryModerationFlags(ctx context.Context, request *QueryModerationFlagsRequest) (*StreamResponse[QueryModerationFlagsResponse], error) {
	var result QueryModerationFlagsResponse
	res, err := MakeRequest[QueryModerationFlagsRequest, QueryModerationFlagsResponse](c.client, ctx, "POST", "/api/v2/moderation/flags", nil, request, &result, nil)
	return res, err
}

// Run moderation on text and return labels
func (c *ModerationClient) Labels(ctx context.Context, request *LabelsRequest) (*StreamResponse[LabelsResponse], error) {
	var result LabelsResponse
	res, err := MakeRequest[LabelsRequest, LabelsResponse](c.client, ctx, "POST", "/api/v2/moderation/labels", nil, request, &result, nil)
	return res, err
}

// Search and filter moderation label results with support for pagination and sorting. View the history of moderation labels applied to content.
func (c *ModerationClient) QueryLabelResults(ctx context.Context, request *QueryLabelResultsRequest) (*StreamResponse[QueryLabelResultsResponse], error) {
	var result QueryLabelResultsResponse
	res, err := MakeRequest[QueryLabelResultsRequest, QueryLabelResultsResponse](c.client, ctx, "POST", "/api/v2/moderation/labels/results", nil, request, &result, nil)
	return res, err
}

// Search and filter moderation action logs with support for pagination. View the history of moderation actions taken, including who performed them and when.
func (c *ModerationClient) QueryModerationLogs(ctx context.Context, request *QueryModerationLogsRequest) (*StreamResponse[QueryModerationLogsResponse], error) {
	var result QueryModerationLogsResponse
	res, err := MakeRequest[QueryModerationLogsRequest, QueryModerationLogsResponse](c.client, ctx, "POST", "/api/v2/moderation/logs", nil, request, &result, nil)
	return res, err
}

// Create or update a moderation rule that can apply app-wide or to specific moderation configs
func (c *ModerationClient) UpsertModerationRule(ctx context.Context, request *UpsertModerationRuleRequest) (*StreamResponse[UpsertModerationRuleResponse], error) {
	var result UpsertModerationRuleResponse
	res, err := MakeRequest[UpsertModerationRuleRequest, UpsertModerationRuleResponse](c.client, ctx, "POST", "/api/v2/moderation/moderation_rule", nil, request, &result, nil)
	return res, err
}

// Delete an existing moderation rule
func (c *ModerationClient) DeleteModerationRule(ctx context.Context, id string, request *DeleteModerationRuleRequest) (*StreamResponse[DeleteModerationRuleResponse], error) {
	var result DeleteModerationRuleResponse
	pathParams := map[string]string{
		"id": id,
	}
	params := extractQueryParams(request)
	res, err := MakeRequest[any, DeleteModerationRuleResponse](c.client, ctx, "DELETE", "/api/v2/moderation/moderation_rule/{id}", params, nil, &result, pathParams)
	return res, err
}

// Get a specific moderation rule by ID
func (c *ModerationClient) GetModerationRule(ctx context.Context, id string, request *GetModerationRuleRequest) (*StreamResponse[GetModerationRuleResponse], error) {
	var result GetModerationRuleResponse
	pathParams := map[string]string{
		"id": id,
	}
	res, err := MakeRequest[any, GetModerationRuleResponse](c.client, ctx, "GET", "/api/v2/moderation/moderation_rule/{id}", nil, nil, &result, pathParams)
	return res, err
}

// Search and filter moderation rules across your application. This endpoint is designed for building moderation dashboards and managing multiple rule sets.
func (c *ModerationClient) QueryModerationRules(ctx context.Context, request *QueryModerationRulesRequest) (*StreamResponse[QueryModerationRulesResponse], error) {
	var result QueryModerationRulesResponse
	res, err := MakeRequest[QueryModerationRulesRequest, QueryModerationRulesResponse](c.client, ctx, "POST", "/api/v2/moderation/moderation_rules", nil, request, &result, nil)
	return res, err
}

// Mute a user. Mutes are generally not visible to the user you mute, while block is something you notice.
func (c *ModerationClient) Mute(ctx context.Context, request *MuteRequest) (*StreamResponse[MuteResponse], error) {
	var result MuteResponse
	res, err := MakeRequest[MuteRequest, MuteResponse](c.client, ctx, "POST", "/api/v2/moderation/mute", nil, request, &result, nil)
	return res, err
}

func (c *ModerationClient) GetPolicyTestRun(ctx context.Context, id string, request *GetPolicyTestRunRequest) (*StreamResponse[PolicyTestRunResponse], error) {
	var result PolicyTestRunResponse
	pathParams := map[string]string{
		"id": id,
	}
	res, err := MakeRequest[any, PolicyTestRunResponse](c.client, ctx, "GET", "/api/v2/moderation/policy_tests/runs/{id}", nil, nil, &result, pathParams)
	return res, err
}

func (c *ModerationClient) ListPolicyTestSets(ctx context.Context, request *ListPolicyTestSetsRequest) (*StreamResponse[PolicyTestSetListResponse], error) {
	var result PolicyTestSetListResponse
	params := extractQueryParams(request)
	res, err := MakeRequest[any, PolicyTestSetListResponse](c.client, ctx, "GET", "/api/v2/moderation/policy_tests/sets", params, nil, &result, nil)
	return res, err
}

// Save a labeled set of messages that can be re-run against the moderation policy.
func (c *ModerationClient) CreatePolicyTestSet(ctx context.Context, request *CreatePolicyTestSetRequest) (*StreamResponse[PolicyTestSetResponse], error) {
	var result PolicyTestSetResponse
	res, err := MakeRequest[CreatePolicyTestSetRequest, PolicyTestSetResponse](c.client, ctx, "POST", "/api/v2/moderation/policy_tests/sets", nil, request, &result, nil)
	return res, err
}

func (c *ModerationClient) DeletePolicyTestSet(ctx context.Context, id string, request *DeletePolicyTestSetRequest) (*StreamResponse[Response], error) {
	var result Response
	pathParams := map[string]string{
		"id": id,
	}
	res, err := MakeRequest[any, Response](c.client, ctx, "DELETE", "/api/v2/moderation/policy_tests/sets/{id}", nil, nil, &result, pathParams)
	return res, err
}

func (c *ModerationClient) GetPolicyTestSet(ctx context.Context, id string, request *GetPolicyTestSetRequest) (*StreamResponse[PolicyTestSetResponse], error) {
	var result PolicyTestSetResponse
	pathParams := map[string]string{
		"id": id,
	}
	res, err := MakeRequest[any, PolicyTestSetResponse](c.client, ctx, "GET", "/api/v2/moderation/policy_tests/sets/{id}", nil, nil, &result, pathParams)
	return res, err
}

// Enqueue a background run of the set against the saved live moderation config.
func (c *ModerationClient) StartPolicyTestRun(ctx context.Context, id string, request *StartPolicyTestRunRequest) (*StreamResponse[PolicyTestRunResponse], error) {
	var result PolicyTestRunResponse
	pathParams := map[string]string{
		"id": id,
	}
	res, err := MakeRequest[any, PolicyTestRunResponse](c.client, ctx, "POST", "/api/v2/moderation/policy_tests/sets/{id}/runs", nil, nil, &result, pathParams)
	return res, err
}

func (c *ModerationClient) ListQueues(ctx context.Context, request *ListQueuesRequest) (*StreamResponse[ListQueuesResponse], error) {
	var result ListQueuesResponse
	params := extractQueryParams(request)
	res, err := MakeRequest[any, ListQueuesResponse](c.client, ctx, "GET", "/api/v2/moderation/queues", params, nil, &result, nil)
	return res, err
}

func (c *ModerationClient) CreateQueue(ctx context.Context, request *CreateQueueRequest) (*StreamResponse[QueueResponse], error) {
	var result QueueResponse
	res, err := MakeRequest[CreateQueueRequest, QueueResponse](c.client, ctx, "POST", "/api/v2/moderation/queues", nil, request, &result, nil)
	return res, err
}

func (c *ModerationClient) GetQueue(ctx context.Context, id string, request *GetQueueRequest) (*StreamResponse[QueueResponse], error) {
	var result QueueResponse
	pathParams := map[string]string{
		"id": id,
	}
	params := extractQueryParams(request)
	res, err := MakeRequest[any, QueueResponse](c.client, ctx, "GET", "/api/v2/moderation/queues/{id}", params, nil, &result, pathParams)
	return res, err
}

func (c *ModerationClient) UpdateQueue(ctx context.Context, id string, request *UpdateQueueRequest) (*StreamResponse[QueueResponse], error) {
	var result QueueResponse
	pathParams := map[string]string{
		"id": id,
	}
	res, err := MakeRequest[UpdateQueueRequest, QueueResponse](c.client, ctx, "PATCH", "/api/v2/moderation/queues/{id}", nil, request, &result, pathParams)
	return res, err
}

func (c *ModerationClient) DeleteQueue(ctx context.Context, id string, request *DeleteQueueRequest) (*StreamResponse[QueueResponse], error) {
	var result QueueResponse
	pathParams := map[string]string{
		"id": id,
	}
	res, err := MakeRequest[DeleteQueueRequest, QueueResponse](c.client, ctx, "POST", "/api/v2/moderation/queues/{id}/delete", nil, request, &result, pathParams)
	return res, err
}

// Authorize revealing a review queue item's blurred media. CSAM can only be revealed by users with the RevealProtectedMedia permission. Reveals of blurred CSAM or gore are recorded in the moderation action logs.
func (c *ModerationClient) RevealMedia(ctx context.Context, request *RevealMediaRequest) (*StreamResponse[RevealMediaResponse], error) {
	var result RevealMediaResponse
	res, err := MakeRequest[RevealMediaRequest, RevealMediaResponse](c.client, ctx, "POST", "/api/v2/moderation/reveal_media", nil, request, &result, nil)
	return res, err
}

// Query review queue items allows you to filter the review queue items. This is used for building a moderation dashboard.
func (c *ModerationClient) QueryReviewQueue(ctx context.Context, request *QueryReviewQueueRequest) (*StreamResponse[QueryReviewQueueResponse], error) {
	var result QueryReviewQueueResponse
	res, err := MakeRequest[QueryReviewQueueRequest, QueryReviewQueueResponse](c.client, ctx, "POST", "/api/v2/moderation/review_queue", nil, request, &result, nil)
	return res, err
}

// Retrieve a specific review queue item by its ID
func (c *ModerationClient) GetReviewQueueItem(ctx context.Context, id string, request *GetReviewQueueItemRequest) (*StreamResponse[GetReviewQueueItemResponse], error) {
	var result GetReviewQueueItemResponse
	pathParams := map[string]string{
		"id": id,
	}
	res, err := MakeRequest[any, GetReviewQueueItemResponse](c.client, ctx, "GET", "/api/v2/moderation/review_queue/{id}", nil, nil, &result, pathParams)
	return res, err
}

// Retrieve a setup session for an app
func (c *ModerationClient) GetSetupSession(ctx context.Context, request *GetSetupSessionRequest) (*StreamResponse[GetSetupSessionResponse], error) {
	var result GetSetupSessionResponse
	res, err := MakeRequest[any, GetSetupSessionResponse](c.client, ctx, "GET", "/api/v2/moderation/setup", nil, nil, &result, nil)
	return res, err
}

// Update a setup session for an app
func (c *ModerationClient) UpsertSetupSession(ctx context.Context, request *UpsertSetupSessionRequest) (*StreamResponse[UpsertSetupSessionResponse], error) {
	var result UpsertSetupSessionResponse
	res, err := MakeRequest[UpsertSetupSessionRequest, UpsertSetupSessionResponse](c.client, ctx, "POST", "/api/v2/moderation/setup", nil, request, &result, nil)
	return res, err
}

// Take action on flagged content, such as marking content as safe, deleting content, banning users, or executing custom moderation actions. Supports various action types with configurable parameters.
func (c *ModerationClient) SubmitAction(ctx context.Context, request *SubmitActionRequest) (*StreamResponse[SubmitActionResponse], error) {
	var result SubmitActionResponse
	res, err := MakeRequest[SubmitActionRequest, SubmitActionResponse](c.client, ctx, "POST", "/api/v2/moderation/submit_action", nil, request, &result, nil)
	return res, err
}

// Forward a moderator-supplied correction to the moderation feedback pipeline, optionally marking the referenced flags as false positives. Server-side only.
func (c *ModerationClient) SubmitModerationFeedback(ctx context.Context, request *SubmitModerationFeedbackRequest) (*StreamResponse[SubmitModerationFeedbackResponse], error) {
	var result SubmitModerationFeedbackResponse
	res, err := MakeRequest[SubmitModerationFeedbackRequest, SubmitModerationFeedbackResponse](c.client, ctx, "POST", "/api/v2/moderation/submit_moderation_feedback", nil, request, &result, nil)
	return res, err
}

// Unban a user from a channel or globally.
func (c *ModerationClient) Unban(ctx context.Context, request *UnbanRequest) (*StreamResponse[UnbanResponse], error) {
	var result UnbanResponse
	params := extractQueryParams(request)
	res, err := MakeRequest[UnbanRequest, UnbanResponse](c.client, ctx, "POST", "/api/v2/moderation/unban", params, request, &result, nil)
	return res, err
}

// Unmute a user
func (c *ModerationClient) Unmute(ctx context.Context, request *UnmuteRequest) (*StreamResponse[UnmuteResponse], error) {
	var result UnmuteResponse
	res, err := MakeRequest[UnmuteRequest, UnmuteResponse](c.client, ctx, "POST", "/api/v2/moderation/unmute", nil, request, &result, nil)
	return res, err
}