@helyx/module-moderation 1.0.1

package/dist/channel-actions.js

@@ -0,0 +1,267 @@
+import { DashboardActionValidationError, HELYX_SERVICE_NAMES, } from "@helyx/sdk";
+import { parseModerationConfiguration } from "./configuration.js";
+import { MODERATION_MODULE_ID } from "./constants.js";
+export function createModerationChannelActions() {
+    return [
+        {
+            id: "check-violation-channel",
+            async execute(context) {
+                const result = await inspectChannel(context.guildId, context.services);
+                return {
+                    title: result.outcome === "allowed"
+                        ? "Channel check complete"
+                        : "Channel needs attention",
+                    description: changes(result),
+                };
+            },
+        },
+        {
+            id: "configure-violation-channel",
+            async inspect(context) {
+                const result = await inspectChannel(context.guildId, context.services);
+                return {
+                    title: result.outcome === "allowed"
+                        ? "Review channel changes"
+                        : "Channel cannot be configured yet",
+                    description: changes(result),
+                    inspectionRevision: result.configurationRevision ?? "unavailable",
+                };
+            },
+            async execute(context, input) {
+                if (!input?.inspectionRevision)
+                    throw new DashboardActionValidationError("Check the channel again before configuring it.");
+                let configuration = await configuredChannel(context.guildId, context.services);
+                const checked = await inspectChannel(context.guildId, context.services);
+                if (checked.outcome !== "allowed")
+                    throw new DashboardActionValidationError(changes(checked));
+                if (checked.configurationRevision !== input.inspectionRevision)
+                    throw new DashboardActionValidationError("The channel changed after the preview. Check it again.");
+                let inspectionRevision = input.inspectionRevision;
+                if (!configuration.accessRoleId) {
+                    configuration = await createAndPersistAccessRole(context, configuration);
+                    const withRole = await inspectChannel(context.guildId, context.services);
+                    if (!withRole.configurationRevision)
+                        throw new DashboardActionValidationError("The new access role could not be checked safely.");
+                    if (withRole.outcome !== "allowed")
+                        throw new DashboardActionValidationError(changes(withRole));
+                    if (withRole.requiredChanges.some((change) => !checked.requiredChanges.includes(change)))
+                        throw new DashboardActionValidationError("The required channel changes changed while the access role was being created. Check the channel again before configuring it.");
+                    inspectionRevision = withRole.configurationRevision;
+                }
+                if (!configuration.accessRoleId)
+                    throw new DashboardActionValidationError("The violation access role is unavailable.");
+                const result = await context.services
+                    .get(HELYX_SERVICE_NAMES.violationThreads)
+                    .configureParent({
+                    guildId: context.guildId,
+                    parentChannelId: configuration.channelId,
+                    accessRoleId: configuration.accessRoleId,
+                    moderatorRoleIds: configuration.moderatorRoleIds,
+                    moderatorUserIds: configuration.moderatorUserIds,
+                    expectedConfigurationRevision: inspectionRevision,
+                    operationKey: `dashboard:${context.correlationId}:configure-violation-channel`,
+                    revalidate: async () => {
+                        if (!(await context.revalidate()))
+                            return false;
+                        const current = await configuredChannel(context.guildId, context.services);
+                        return sameConfiguration(configuration, current);
+                    },
+                });
+                if (result.outcome !== "configured" &&
+                    result.outcome !== "already_configured")
+                    throw new DashboardActionValidationError(configurationFailure(result));
+                await context.services
+                    .get(HELYX_SERVICE_NAMES.audit)
+                    .append({
+                    guildId: context.guildId,
+                    actorUserId: context.actorUserId,
+                    action: "moderation.violation-channel.configured",
+                    source: "dashboard",
+                    correlationId: context.correlationId,
+                    idempotencyKey: `dashboard:${context.correlationId}:configure-audit`,
+                    moduleId: MODERATION_MODULE_ID,
+                    targetType: "discord_channel",
+                    targetId: configuration.channelId,
+                    metadata: {
+                        accessRoleId: configuration.accessRoleId,
+                        configurationRevision: result.configurationRevision,
+                    },
+                });
+                return {
+                    title: "Violation channel configured",
+                    description: result.appliedChanges.join("\n") ||
+                        "The channel was already configured.",
+                };
+            },
+        },
+    ];
+}
+async function inspectChannel(guildId, services) {
+    const configuration = await configuredChannel(guildId, services);
+    return services
+        .get(HELYX_SERVICE_NAMES.violationThreads)
+        .inspectConfiguration({
+        guildId,
+        parentChannelId: configuration.channelId,
+        accessRoleId: configuration.accessRoleId,
+        moderatorRoleIds: configuration.moderatorRoleIds,
+        moderatorUserIds: configuration.moderatorUserIds,
+    });
+}
+async function configuredChannel(guildId, services) {
+    const stored = await services
+        .get(HELYX_SERVICE_NAMES.configuration)
+        .get(guildId, MODERATION_MODULE_ID);
+    const configuration = parseModerationConfiguration(stored?.value);
+    if (!configuration.violationThreadChannelId)
+        throw new DashboardActionValidationError("Select a violation thread channel in Moderation settings first.");
+    return {
+        stored,
+        value: configuration,
+        channelId: configuration.violationThreadChannelId,
+        accessRoleId: configuration.violationAccessRoleId,
+        moderatorRoleIds: [...configuration.violationModeratorRoleIds],
+        moderatorUserIds: [...configuration.violationModeratorUserIds],
+    };
+}
+async function createAndPersistAccessRole(context, checked) {
+    const created = await context.services
+        .get(HELYX_SERVICE_NAMES.violationThreads)
+        .createAccessRole({
+        guildId: context.guildId,
+        name: "Violation",
+        operationKey: `moderation:${context.guildId}:violation-access-role`,
+        revalidate: async () => {
+            if (!(await context.revalidate()))
+                return false;
+            return sameConfiguration(checked, await configuredChannel(context.guildId, context.services));
+        },
+    });
+    if (created.outcome !== "created")
+        throw new DashboardActionValidationError(created.outcome === "missing_permission"
+            ? "Discord denied creation of the Violation role. Check the bot's Manage Roles permission and role hierarchy, then check the channel again."
+            : created.outcome === "no_longer_required"
+                ? "Your access or Moderation settings changed before the Violation role could be created. Reload the settings, then check the channel again."
+                : "Creation of the Violation role could not be confirmed. It may already exist; check the channel again before retrying so Helyx can recover it safely.");
+    return persistAccessRole(context, created.roleId, checked);
+}
+async function persistAccessRole(context, roleId, checked) {
+    const service = context.services.get(HELYX_SERVICE_NAMES.configuration);
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+        const current = await configuredChannel(context.guildId, context.services);
+        if (current.accessRoleId) {
+            if (current.accessRoleId === roleId &&
+                sameChannelAndModerators(current, checked))
+                return current;
+            throw staleChannelConfiguration();
+        }
+        if (!sameConfiguration(current, checked))
+            throw staleChannelConfiguration();
+        if (!(await context.revalidate()))
+            throw new DashboardActionValidationError("Access changed before the role could be saved.");
+        try {
+            await service.update({
+                guildId: context.guildId,
+                moduleId: MODERATION_MODULE_ID,
+                value: { ...current.value, violationAccessRoleId: roleId },
+                expectedVersion: current.stored?.version ?? null,
+                context: {
+                    actorUserId: context.actorUserId,
+                    correlationId: context.correlationId,
+                    source: "dashboard",
+                },
+            });
+            return configuredChannel(context.guildId, context.services);
+        }
+        catch (error) {
+            const afterConflict = await configuredChannel(context.guildId, context.services);
+            if (afterConflict.accessRoleId) {
+                if (afterConflict.accessRoleId === roleId &&
+                    sameChannelAndModerators(afterConflict, checked))
+                    return afterConflict;
+                throw staleChannelConfiguration();
+            }
+            if (!sameConfiguration(afterConflict, checked))
+                throw staleChannelConfiguration();
+            if (attempt === 1)
+                throw error;
+        }
+    }
+    throw new DashboardActionValidationError("The Violation role could not be saved safely.");
+}
+function staleChannelConfiguration() {
+    return new DashboardActionValidationError("Moderation settings changed after the preview. Check the channel again.");
+}
+function sameConfiguration(left, right) {
+    return (left.channelId === right.channelId &&
+        left.accessRoleId === right.accessRoleId &&
+        left.moderatorRoleIds.join(",") === right.moderatorRoleIds.join(",") &&
+        left.moderatorUserIds.join(",") === right.moderatorUserIds.join(","));
+}
+function sameChannelAndModerators(left, right) {
+    return (left.channelId === right.channelId &&
+        left.moderatorRoleIds.join(",") === right.moderatorRoleIds.join(",") &&
+        left.moderatorUserIds.join(",") === right.moderatorUserIds.join(","));
+}
+function changes(result) {
+    if (result.outcome !== "allowed") {
+        if (result.outcome === "channel_missing")
+            return "The selected channel is unavailable or is not a standard text channel. Select an accessible text channel, then check it again.";
+        if (result.missingPermissions.length)
+            return `The bot is missing these permissions: ${result.missingPermissions.map(permissionLabel).join(", ")}. Grant them, then check the channel again.`;
+        if (result.outcome === "role_missing")
+            return "A selected access or moderator role is unavailable. Update the selected roles, then check the channel again.";
+        if (result.outcome === "unsafe_access_role")
+            return "The access role is not suitable: it must be an unmanaged role below the bot, without moderation permissions or access to other private channels. Select a dedicated safe role, then check the channel again.";
+        if (result.safeCode === "moderator_role_unsafe")
+            return "Moderator roles cannot include @everyone or the violation access role. Update the moderator roles, then check the channel again.";
+        if (result.safeCode === "moderator_user_unavailable")
+            return "A notification user is unavailable or is not a human member of this server. Update the selected users, then check the channel again.";
+    }
+    const items = result.requiredChanges.map((change) => change === "create_access_role"
+        ? "Create a dedicated Violation access role."
+        : configurationChangeLabel(change));
+    if (items.length)
+        return items.join("\n");
+    return result.outcome === "allowed"
+        ? "No changes are required."
+        : "The configured channel, access role, or bot permissions are not suitable.";
+}
+function permissionLabel(name) {
+    return name.toLowerCase().replaceAll("_", " ");
+}
+function configurationChangeLabel(change) {
+    if (change === "deny_everyone_view_channel")
+        return "Hide the parent channel from @everyone.";
+    if (change === "deny_access_role_parent_messages")
+        return "Prevent the violation access role from sending messages in the parent channel.";
+    const match = /^allow_(access_role|bot|moderator_user_\d{17,20}|moderator_\d{17,20})_(.+)$/u.exec(change);
+    if (!match)
+        return "Update the reviewed channel permissions.";
+    const target = match[1].startsWith("moderator_user_")
+        ? `moderator user ${match[1].slice("moderator_user_".length)}`
+        : match[1].startsWith("moderator_")
+            ? `moderator role ${match[1].slice("moderator_".length)}`
+            : match[1] === "bot"
+                ? "the bot"
+                : "the violation access role";
+    return `Allow ${target} to ${permissionLabel(match[2])}.`;
+}
+function configurationFailure(result) {
+    if (result.outcome === "stale_inspection")
+        return "The channel or roles changed after the check. Check the channel again before configuring it.";
+    if (result.outcome === "channel_missing")
+        return "The selected text channel is unavailable. Check the channel and the bot's access, then check it again.";
+    if (result.outcome === "role_missing")
+        return "A selected access or moderator role is unavailable. Update the selected roles, then check the channel again.";
+    if (result.outcome === "unsafe_access_role")
+        return "The access role is no longer suitable. Select a dedicated safe role, then check the channel again.";
+    if (result.outcome === "missing_permission")
+        return "Discord denied the channel changes. Check the bot's Manage Channels and Manage Roles permissions and role hierarchy. Some changes may already have applied; check the channel again before retrying.";
+    if (result.safeCode === "revalidation_rejected")
+        return "Your access or Moderation settings changed before configuration. Reload the settings, then check the channel again.";
+    if (result.safeCode === "configuration_recheck_failed")
+        return "Discord accepted the permission requests, but the final channel check did not confirm a usable configuration. Some changes may already have applied; check the channel again before retrying.";
+    return "The channel changes could not be fully confirmed. Some changes may already have applied; check the channel again before retrying.";
+}
+//# sourceMappingURL=channel-actions.js.map

package/dist/commands.d.ts

@@ -0,0 +1,4 @@
+import { type CommandContribution } from "@helyx/sdk";
+import type { ModerationService } from "./service.js";
+export declare function createModerationCommands(service: ModerationService): readonly CommandContribution[];
+//# sourceMappingURL=commands.d.ts.map

package/dist/commands.js

@@ -0,0 +1,309 @@
+import { HELYX_SERVICE_NAMES, } from "@helyx/sdk";
+import { MODERATION_COMMAND_IDS, MODERATION_MODULE_ID } from "./constants.js";
+import { validateBanDeleteMessageSeconds, validateDemotionRoleIds, validateEvidenceReference, validatePrivateNote, validateReason, validateTimeoutSeconds, } from "./domain.js";
+import { requestModerationConfirmation } from "./components.js";
+import { ModerationRepository } from "./repository.js";
+const commonOptions = [
+    {
+        type: "user",
+        name: "member",
+        description: "Member to moderate.",
+        required: true,
+    },
+    {
+        type: "string",
+        name: "reason",
+        description: "Private moderation reason (10-500 characters).",
+        required: true,
+        minLength: 10,
+        maxLength: 500,
+    },
+    {
+        type: "string",
+        name: "message-link",
+        description: "Optional same-server Discord message link.",
+    },
+    {
+        type: "string",
+        name: "private-note",
+        description: "Optional staff-only note.",
+        maxLength: 1_000,
+    },
+];
+export function createModerationCommands(service) {
+    return [
+        {
+            name: "mod",
+            description: "Apply accountable moderation actions and review cases.",
+            registrationPolicy: "enabled-guild",
+            contexts: ["guild"],
+            integrationTypes: ["guild_install"],
+            subcommands: [
+                actionCommand(service, "warn", "Warn a member and create a case."),
+                actionCommand(service, "timeout", "Temporarily stop a member from speaking.", [
+                    ...commonOptions,
+                    {
+                        type: "integer",
+                        name: "duration-minutes",
+                        description: "Timeout duration in minutes (1-40320).",
+                        required: true,
+                        minimum: 1,
+                        maximum: 40_320,
+                    },
+                ]),
+                actionCommand(service, "timeout-remove", "Remove a member timeout."),
+                actionCommand(service, "kick", "Remove a member from this server."),
+                actionCommand(service, "ban", "Ban a user from this server.", [
+                    ...commonOptions,
+                    {
+                        type: "string",
+                        name: "delete-messages",
+                        description: "How much recent message history Discord should delete.",
+                        choices: [
+                            ["Do not delete", "0"],
+                            ["1 hour", "3600"],
+                            ["6 hours", "21600"],
+                            ["24 hours", "86400"],
+                            ["3 days", "259200"],
+                            ["7 days", "604800"],
+                        ].map(([name, value]) => ({ name: name, value: value })),
+                    },
+                ]),
+                actionCommand(service, "demote", "Remove configured roles from a member.", [
+                    ...commonOptions,
+                    ...Array.from({ length: 10 }, (_, index) => ({
+                        type: "role",
+                        name: `role-${index + 1}`,
+                        description: index === 0
+                            ? "Role to remove."
+                            : `Additional role ${index + 1} to remove.`,
+                        required: index === 0,
+                    })),
+                ]),
+                actionCommand(service, "unban", "Remove a user ban."),
+                {
+                    name: "history",
+                    description: "Show recent moderation cases for a member.",
+                    acknowledgement: "deferred-ephemeral",
+                    authorization: "resource-scoped",
+                    permissionId: MODERATION_COMMAND_IDS.history,
+                    rateLimit: { scope: "user", limit: 10, windowSeconds: 60 },
+                    options: [commonOptions[0]],
+                    execute: (context) => executeHistory(context),
+                },
+            ],
+        },
+    ];
+}
+function actionCommand(service, name, description, options = commonOptions) {
+    const permissionId = commandPermission(name);
+    return {
+        name,
+        description,
+        acknowledgement: "deferred-ephemeral",
+        authorization: "resource-scoped",
+        permissionId,
+        rateLimit: { scope: "user", limit: 5, windowSeconds: 60 },
+        options,
+        execute: (context) => executeAction(service, context, name, permissionId),
+    };
+}
+async function executeAction(service, context, name, permissionId) {
+    try {
+        const guildId = requireGuild(context.serverId);
+        if (!(await consumeGuildLimit(context, permissionId, 30)))
+            return;
+        const target = context.getUserOption("member");
+        if (!target)
+            throw new Error("Choose a Discord user.");
+        const privateNote = validatePrivateNote(context.getStringOption("private-note"));
+        const evidenceMessage = sameGuildEvidence(context, guildId);
+        const draft = {
+            operationKey: `discord:${context.interactionId}`,
+            guildId,
+            actor: permissionActor(context),
+            permissionId,
+            action: caseAction(name),
+            subjectUserId: target.id,
+            subjectDisplayName: target.displayName,
+            reason: validateReason(context.getStringOption("reason")),
+            ...(privateNote ? { privateNote } : {}),
+            ...(evidenceMessage ? { evidenceMessage } : {}),
+            ...(name === "timeout"
+                ? {
+                    requestedDurationSeconds: validateTimeoutSeconds((context.getIntegerOption?.("duration-minutes") ?? 0) * 60),
+                }
+                : {}),
+            ...(name === "ban"
+                ? {
+                    deleteMessageSeconds: validateBanDeleteMessageSeconds(Number(context.getStringOption("delete-messages") ?? "0")),
+                }
+                : {}),
+            ...(name === "demote" ? { demoteRoleIds: demotionRoleIds(context) } : {}),
+        };
+        if (!(await service.canExecuteStaffAction(context.services, draft)))
+            throw new Error("The action is no longer allowed. Check access, membership and role hierarchy.");
+        if (requiresConfirmation(draft)) {
+            await requestModerationConfirmation(context, draft, service);
+            return;
+        }
+        await context.reply(resultMessage(await service.executeStaffAction(context.services, draft)));
+    }
+    catch (error) {
+        await context.reply(errorMessage(error));
+    }
+}
+async function executeHistory(context) {
+    const guildId = requireGuild(context.serverId);
+    if (!(await consumeGuildLimit(context, MODERATION_COMMAND_IDS.history, 60)))
+        return;
+    const target = context.getUserOption("member");
+    if (!target)
+        throw new Error("Choose a Discord user.");
+    const page = await new ModerationRepository(context.services).listCases({
+        guildId,
+        search: target.id,
+        limit: 10,
+    });
+    await context.reply({
+        ephemeral: true,
+        componentsV2: {
+            text: [
+                {
+                    content: page.items.length === 0
+                        ? `No moderation cases were found for ${target.displayName}.`
+                        : [
+                            `Recent moderation cases for ${target.displayName}:`,
+                            ...page.items.map((item) => `#${item.caseNumber} · ${item.action.replace("_", " ")} · ${item.state} · ${item.createdAt.toISOString().slice(0, 10)}`),
+                            "Private notes are available only through the separately permissioned dashboard reveal.",
+                        ].join("\n"),
+                    markdown: true,
+                },
+            ],
+        },
+    });
+    void guildId;
+}
+function commandPermission(name) {
+    return name === "timeout-remove"
+        ? MODERATION_COMMAND_IDS.timeoutRemove
+        : MODERATION_COMMAND_IDS[name];
+}
+function caseAction(name) {
+    return name === "timeout-remove"
+        ? "timeout_remove"
+        : name;
+}
+function requiresConfirmation(draft) {
+    return (draft.action === "kick" ||
+        draft.action === "ban" ||
+        draft.action === "demote" ||
+        draft.action === "unban" ||
+        (draft.action === "timeout" &&
+            (draft.requestedDurationSeconds ?? 0) > 86_400));
+}
+function sameGuildEvidence(context, guildId) {
+    const link = context.getStringOption("message-link");
+    if (!link)
+        return undefined;
+    const guildMatch = /^https:\/\/discord(?:app)?\.com\/channels\/(\d{17,20})\//u.exec(link.trim());
+    if (guildMatch?.[1] !== guildId)
+        throw new Error("The message link must belong to this server.");
+    return validateEvidenceReference(link);
+}
+function demotionRoleIds(context) {
+    return validateDemotionRoleIds(Array.from({ length: 10 }, (_, index) => context.getRoleOption(`role-${index + 1}`)?.id).filter((roleId) => Boolean(roleId)));
+}
+function permissionActor(context) {
+    return {
+        userId: context.userId,
+        roleIds: context.userRoleIds,
+        permissions: context.userPermissions ?? [],
+        isServerOwner: context.isServerOwner ?? false,
+        isAdministrator: context.isAdministrator,
+        ...(context.userHighestRolePosition !== undefined
+            ? { highestRolePosition: context.userHighestRolePosition }
+            : {}),
+    };
+}
+async function consumeGuildLimit(context, permissionId, limit) {
+    const guildId = requireGuild(context.serverId);
+    if (!context.services.has(HELYX_SERVICE_NAMES.rateLimits)) {
+        await context.reply(errorText("Moderation rate limits are unavailable."));
+        return false;
+    }
+    const result = await context.services
+        .get(HELYX_SERVICE_NAMES.rateLimits)
+        .consume({
+        scope: "guild",
+        subjectId: guildId,
+        action: `${MODERATION_MODULE_ID}:${permissionId}`,
+        limit,
+        windowSeconds: 60,
+    });
+    if (result.allowed)
+        return true;
+    await context.reply(errorText("This server is sending moderation actions too quickly. Try again shortly."));
+    return false;
+}
+function resultMessage(result) {
+    const caseLabel = result.caseNumber ? ` Case ${result.caseNumber}.` : "";
+    return {
+        ephemeral: true,
+        componentsV2: {
+            accentColor: result.outcome === "applied"
+                ? 0x16a34a
+                : result.outcome === "review_required"
+                    ? 0xf59e0b
+                    : 0xdc2626,
+            text: [
+                {
+                    content: result.outcome === "applied"
+                        ? `Moderation action applied.${caseLabel}`
+                        : result.outcome === "review_required"
+                            ? `The case needs staff review.${caseLabel}`
+                            : `The action was not applied.${caseLabel}`,
+                    markdown: false,
+                },
+            ],
+        },
+    };
+}
+function errorMessage(error) {
+    return errorText(error instanceof Error && safeCommandError(error.message)
+        ? error.message
+        : "Moderation is temporarily unavailable. Nothing was changed.");
+}
+function safeCommandError(message) {
+    return SAFE_COMMAND_ERRORS.has(message);
+}
+const SAFE_COMMAND_ERRORS = new Set([
+    "A reason is required.",
+    "The reason must be between 10 and 500 characters.",
+    "The private note is invalid.",
+    "The private note must be no more than 1,000 characters.",
+    "Timeout duration must be between 1 minute and 28 days.",
+    "The ban message deletion duration is invalid.",
+    "Choose between 1 and 10 valid roles to remove.",
+    "Demotion roles must be unique.",
+    "The message link is invalid.",
+    "The message link must belong to this server.",
+    "Choose a Discord user.",
+    "The action is no longer allowed. Check access, membership and role hierarchy.",
+    "Moderation commands can be used only in a server.",
+]);
+function errorText(content) {
+    return {
+        ephemeral: true,
+        componentsV2: {
+            accentColor: 0xdc2626,
+            text: [{ content, markdown: false }],
+        },
+    };
+}
+function requireGuild(guildId) {
+    if (!guildId)
+        throw new Error("Moderation commands can be used only in a server.");
+    return guildId;
+}
+//# sourceMappingURL=commands.js.map

package/dist/components.d.ts

@@ -0,0 +1,15 @@
+import { type InteractionContributions, type MessageResponse, type ModalCapableInteractionContext, type PermissionActor } from "@helyx/sdk";
+import type { ModerationService, ModerationStaffDraft } from "./service.js";
+export interface ModerationThreadControlRuntime {
+    executeControl(context: ModalCapableInteractionContext, action: "kick" | "ban" | "unmute" | "no_further_action" | "close" | "close_delete", controlToken: string): Promise<void>;
+}
+export declare function createModerationInteractions(service: ModerationService, threadControls: ModerationThreadControlRuntime): InteractionContributions;
+export declare function requestModerationConfirmation(context: ModalCapableInteractionContext, draft: ModerationStaffDraft, _service: ModerationService): Promise<void>;
+export declare function currentThreadActor(context: Pick<ModalCapableInteractionContext, "serverId" | "userId" | "services">, permissionId: string): Promise<PermissionActor | null>;
+export declare function initialThreadControls(token: string, timedOut: boolean): MessageResponse;
+export declare function closeThreadControl(token: string): MessageResponse;
+export declare function notificationThreadMessage(roleIds: readonly string[], subjectUserId?: string, staffUserIds?: readonly string[]): MessageResponse;
+export declare function safeViolationThreadMessage(content: string): MessageResponse;
+export declare function violationOpeningMessage(roleIds: readonly string[], subjectUserId: string, opening: string, controls: MessageResponse, staffUserIds?: readonly string[]): MessageResponse;
+export declare function privateThreadControlMessage(content: string): MessageResponse;
+//# sourceMappingURL=components.d.ts.map