@helyx/module-moderation 1.0.1

package/dist/components.js

@@ -0,0 +1,381 @@
+import { HELYX_SERVICE_NAMES, } from "@helyx/sdk";
+import { MODERATION_COMPONENT_IDS } from "./constants.js";
+import { MODERATION_MODULE_ID } from "./constants.js";
+import { claimModerationConfirmation, moderationPermissionForAction, } from "./action-support.js";
+const CONFIRMATION_PURPOSE = "moderation.staff-action-confirmation";
+const CONFIRMATION_TTL_MS = 60_000;
+export function createModerationInteractions(service, threadControls) {
+    return {
+        buttons: [
+            {
+                customIdPrefix: MODERATION_COMPONENT_IDS.confirm,
+                acknowledgement: "deferred-ephemeral",
+                execute: (context) => confirmModerationAction(context, service),
+            },
+            {
+                customIdPrefix: MODERATION_COMPONENT_IDS.cancel,
+                acknowledgement: "deferred-ephemeral",
+                execute: cancelModerationAction,
+            },
+            ...[
+                [MODERATION_COMPONENT_IDS.threadKick, "kick"],
+                [MODERATION_COMPONENT_IDS.threadBan, "ban"],
+                [MODERATION_COMPONENT_IDS.threadUnmute, "unmute"],
+                [MODERATION_COMPONENT_IDS.threadNoFurtherAction, "no_further_action"],
+                [MODERATION_COMPONENT_IDS.threadClose, "close"],
+                [MODERATION_COMPONENT_IDS.threadCloseDelete, "close_delete"],
+            ].map(([prefix, action]) => ({
+                customIdPrefix: prefix,
+                acknowledgement: "deferred-ephemeral",
+                execute: (context) => threadControls.executeControl(context, action, componentToken(context.customId, prefix)),
+            })),
+        ],
+    };
+}
+export async function requestModerationConfirmation(context, draft, _service) {
+    const session = await sessionService(context).create({
+        guildId: draft.guildId,
+        userId: context.userId,
+        purpose: CONFIRMATION_PURPOSE,
+        state: { step: 0, draftRevision: 1, draft: serialiseDraft(draft) },
+        expiresAt: new Date(Date.now() + CONFIRMATION_TTL_MS),
+        replace: false,
+    });
+    await context.reply({
+        ephemeral: true,
+        embed: {
+            title: "Confirm moderation action",
+            description: [
+                `**Member:** ${draft.subjectDisplayName} (${draft.subjectUserId})`,
+                `**Action:** ${actionLabel(draft)}`,
+                `**Reason:** ${draft.reason}`,
+                "Confirm within 60 seconds. Access, membership and hierarchy are checked again before Discord is changed.",
+            ].join("\n"),
+            color: 0xf59e0b,
+        },
+        buttons: [
+            {
+                type: "button",
+                customId: `${MODERATION_COMPONENT_IDS.confirm}${session.sessionId}`,
+                label: "Confirm action",
+                style: "danger",
+            },
+            {
+                type: "button",
+                customId: `${MODERATION_COMPONENT_IDS.cancel}${session.sessionId}`,
+                label: "Cancel",
+                style: "secondary",
+            },
+        ],
+    });
+    void _service;
+}
+async function confirmModerationAction(context, service) {
+    try {
+        const sessionId = componentToken(context.customId, MODERATION_COMPONENT_IDS.confirm);
+        const session = await sessionService(context).get(sessionId);
+        if (!session || !validSession(context, session))
+            throw new Error("This moderation confirmation expired. Run the command again.");
+        const draft = parseDraft(session.state, context);
+        await claimModerationConfirmation(context, session, CONFIRMATION_PURPOSE).catch(() => {
+            throw new Error("This moderation confirmation expired. Run the command again.");
+        });
+        if (!(await service.canExecuteStaffAction(context.services, draft)))
+            throw new Error("The action is no longer allowed. Check access, membership and role hierarchy.");
+        const result = await service.executeStaffAction(context.services, draft);
+        await sessionService(context)
+            .delete(sessionId)
+            .catch(() => undefined);
+        await context.reply(resultMessage(result));
+    }
+    catch (error) {
+        await context.reply(errorMessage(error));
+    }
+}
+async function cancelModerationAction(context) {
+    try {
+        const sessionId = componentToken(context.customId, MODERATION_COMPONENT_IDS.cancel);
+        const session = await sessionService(context).get(sessionId);
+        if (!session || !validSession(context, session))
+            throw new Error("This moderation confirmation already expired.");
+        await claimModerationConfirmation(context, session, CONFIRMATION_PURPOSE).catch(() => {
+            throw new Error("This moderation confirmation already expired.");
+        });
+        await sessionService(context).delete(sessionId);
+        await context.reply(textMessage("Moderation action cancelled.", 0x64748b));
+    }
+    catch (error) {
+        await context.reply(errorMessage(error));
+    }
+}
+function validSession(context, session) {
+    return Boolean(session &&
+        context.serverId &&
+        session.guildId === context.serverId &&
+        session.userId === context.userId &&
+        session.purpose === CONFIRMATION_PURPOSE &&
+        session.expiresAt.getTime() > Date.now() &&
+        session.state.step === 0 &&
+        session.state.draftRevision === 1);
+}
+function parseDraft(state, context) {
+    const value = state.draft;
+    if (!record(value))
+        throw new Error("The moderation confirmation is invalid.");
+    const actor = parseActor(value.actor);
+    const action = value.action;
+    const permissionId = value.permissionId;
+    if (typeof value.operationKey !== "string" ||
+        typeof value.guildId !== "string" ||
+        typeof value.subjectUserId !== "string" ||
+        typeof value.subjectDisplayName !== "string" ||
+        typeof value.reason !== "string" ||
+        !isAction(action) ||
+        typeof permissionId !== "string")
+        throw new Error("The moderation confirmation is invalid.");
+    const draft = {
+        operationKey: value.operationKey,
+        guildId: value.guildId,
+        actor,
+        permissionId: permissionId,
+        action,
+        subjectUserId: value.subjectUserId,
+        subjectDisplayName: value.subjectDisplayName,
+        reason: value.reason,
+        ...(typeof value.privateNote === "string"
+            ? { privateNote: value.privateNote }
+            : {}),
+        ...(record(value.evidenceMessage) &&
+            typeof value.evidenceMessage.channelId === "string" &&
+            typeof value.evidenceMessage.messageId === "string"
+            ? {
+                evidenceMessage: {
+                    channelId: value.evidenceMessage.channelId,
+                    messageId: value.evidenceMessage.messageId,
+                },
+            }
+            : {}),
+        ...(typeof value.requestedDurationSeconds === "number"
+            ? { requestedDurationSeconds: value.requestedDurationSeconds }
+            : {}),
+        ...(typeof value.deleteMessageSeconds === "number"
+            ? { deleteMessageSeconds: value.deleteMessageSeconds }
+            : {}),
+        ...(Array.isArray(value.demoteRoleIds)
+            ? { demoteRoleIds: value.demoteRoleIds.filter(isString) }
+            : {}),
+    };
+    if (draft.guildId !== context.serverId ||
+        draft.actor.userId !== context.userId ||
+        draft.permissionId !== moderationPermissionForAction(draft.action))
+        throw new Error("The moderation confirmation is invalid.");
+    return draft;
+}
+function serialiseDraft(draft) {
+    return {
+        ...draft,
+        actor: {
+            ...draft.actor,
+            roleIds: [...draft.actor.roleIds],
+            permissions: [...draft.actor.permissions],
+        },
+        ...(draft.demoteRoleIds ? { demoteRoleIds: [...draft.demoteRoleIds] } : {}),
+    };
+}
+function parseActor(input) {
+    if (!record(input) ||
+        typeof input.userId !== "string" ||
+        !Array.isArray(input.roleIds) ||
+        !Array.isArray(input.permissions) ||
+        typeof input.isServerOwner !== "boolean" ||
+        typeof input.isAdministrator !== "boolean")
+        throw new Error("The moderation confirmation actor is invalid.");
+    return {
+        userId: input.userId,
+        roleIds: input.roleIds.filter(isString),
+        permissions: input.permissions.filter(isString),
+        isServerOwner: input.isServerOwner,
+        isAdministrator: input.isAdministrator,
+        ...(typeof input.highestRolePosition === "number"
+            ? { highestRolePosition: input.highestRolePosition }
+            : {}),
+    };
+}
+function isAction(input) {
+    return [
+        "warn",
+        "timeout",
+        "timeout_remove",
+        "kick",
+        "ban",
+        "demote",
+        "unban",
+    ].includes(input);
+}
+function actionLabel(draft) {
+    if (draft.action === "timeout")
+        return `Timeout for ${draft.requestedDurationSeconds} seconds`;
+    if (draft.action === "ban")
+        return `Ban (delete ${draft.deleteMessageSeconds ?? 0} seconds of messages)`;
+    if (draft.action === "demote")
+        return `Demote by removing ${(draft.demoteRoleIds ?? []).length} role(s)`;
+    return draft.action.replace("_", " ");
+}
+function sessionService(context) {
+    return context.services.get(HELYX_SERVICE_NAMES.sessions);
+}
+function componentToken(customId, prefix) {
+    if (!customId?.startsWith(prefix))
+        throw new Error("This control is invalid.");
+    const token = customId.slice(prefix.length);
+    if (!/^[A-Za-z0-9_-]{16,100}$/u.test(token))
+        throw new Error("This control is invalid.");
+    return token;
+}
+function resultMessage(result) {
+    return textMessage(result.outcome === "applied"
+        ? `Moderation action applied. Case ${result.caseNumber}.`
+        : result.outcome === "review_required"
+            ? `Case ${result.caseNumber} needs staff review.`
+            : "The moderation action was not applied.", result.outcome === "applied" ? 0x16a34a : 0xf59e0b);
+}
+function errorMessage(error) {
+    return textMessage(error instanceof Error && safeComponentError(error.message)
+        ? error.message
+        : "Moderation is temporarily unavailable. Nothing was changed.", 0xdc2626);
+}
+function safeComponentError(message) {
+    return SAFE_COMPONENT_ERRORS.has(message);
+}
+const SAFE_COMPONENT_ERRORS = new Set([
+    "This moderation confirmation expired. Run the command again.",
+    "This moderation confirmation already expired.",
+    "The moderation confirmation is invalid.",
+    "The moderation confirmation actor is invalid.",
+    "The action is no longer allowed. Check access, membership and role hierarchy.",
+    "This control is invalid.",
+]);
+function textMessage(content, accentColor) {
+    return {
+        ephemeral: true,
+        componentsV2: { accentColor, text: [{ content, markdown: false }] },
+    };
+}
+function record(input) {
+    return Boolean(input) && typeof input === "object" && !Array.isArray(input);
+}
+function isString(input) {
+    return typeof input === "string";
+}
+export async function currentThreadActor(context, permissionId) {
+    if (!context.serverId)
+        return null;
+    const member = await context.services
+        .get(HELYX_SERVICE_NAMES.memberEnforcement)
+        .inspectMember({ guildId: context.serverId, memberUserId: context.userId });
+    if (member.outcome !== "present")
+        return null;
+    const actor = {
+        userId: context.userId,
+        roleIds: member.roleIds,
+        permissions: member.effectivePermissionNames,
+        isServerOwner: member.isGuildOwner,
+        isAdministrator: member.isAdministrator,
+    };
+    const allowed = await context.services
+        .get(HELYX_SERVICE_NAMES.resourceAuthorization)
+        .canUse({
+        guildId: context.serverId,
+        moduleId: MODERATION_MODULE_ID,
+        permissionId,
+        actor,
+    });
+    return allowed ? actor : null;
+}
+export function initialThreadControls(token, timedOut) {
+    return {
+        suppressNotifications: true,
+        buttons: [
+            threadButton(MODERATION_COMPONENT_IDS.threadKick, token, "Kick", "danger"),
+            threadButton(MODERATION_COMPONENT_IDS.threadBan, token, "Ban", "danger"),
+            ...(timedOut
+                ? [
+                    threadButton(MODERATION_COMPONENT_IDS.threadUnmute, token, "Unmute", "primary"),
+                ]
+                : []),
+            threadButton(MODERATION_COMPONENT_IDS.threadNoFurtherAction, token, "No Further Action", "secondary"),
+        ],
+    };
+}
+export function closeThreadControl(token) {
+    return {
+        suppressNotifications: true,
+        buttons: [
+            threadButton(MODERATION_COMPONENT_IDS.threadClose, token, "Close", "secondary"),
+            threadButton(MODERATION_COMPONENT_IDS.threadCloseDelete, token, "Close and delete", "danger"),
+        ],
+    };
+}
+function threadButton(prefix, token, label, style) {
+    return {
+        type: "button",
+        customId: `${prefix}${token}`,
+        label,
+        style,
+    };
+}
+export function notificationThreadMessage(roleIds, subjectUserId, staffUserIds = []) {
+    return {
+        componentsV2: {
+            text: [
+                {
+                    content: [
+                        ...(roleIds.length || staffUserIds.length
+                            ? [
+                                `**Staff:** ${[
+                                    ...roleIds.map((id) => `<@&${id}>`),
+                                    ...staffUserIds.map((id) => `<@${id}>`),
+                                ].join(" ")}`,
+                            ]
+                            : []),
+                        ...(subjectUserId ? [`**User:** <@${subjectUserId}>`] : []),
+                    ].join("\n") || "Moderation staff notification",
+                    markdown: true,
+                },
+            ],
+        },
+        allowedRoleMentionIds: roleIds,
+        allowedUserMentionIds: [
+            ...new Set([...staffUserIds, ...(subjectUserId ? [subjectUserId] : [])]),
+        ],
+        suppressEmbeds: true,
+    };
+}
+export function safeViolationThreadMessage(content) {
+    return {
+        componentsV2: { text: [{ content, markdown: false }] },
+        allowedRoleMentionIds: [],
+        allowedUserMentionIds: [],
+        suppressEmbeds: true,
+    };
+}
+export function violationOpeningMessage(roleIds, subjectUserId, opening, controls, staffUserIds = []) {
+    const notification = notificationThreadMessage(roleIds, subjectUserId, staffUserIds);
+    return {
+        ...notification,
+        componentsV2: {
+            text: [
+                ...notification.componentsV2.text,
+                { content: opening, markdown: false },
+            ],
+        },
+        ...(controls.buttons ? { buttons: controls.buttons } : {}),
+    };
+}
+export function privateThreadControlMessage(content) {
+    return {
+        ephemeral: true,
+        componentsV2: { text: [{ content, markdown: false }] },
+    };
+}
+//# sourceMappingURL=components.js.map

package/dist/configuration.d.ts

@@ -0,0 +1,16 @@
+import { type ViolationThreadLayout } from "@helyx/sdk";
+export interface ModerationConfiguration {
+    warningDirectMessageEnabled: boolean;
+    warningDirectMessageTemplate: string;
+    caseRetentionDays: number;
+    violationThreadChannelId: string | null;
+    violationAccessRoleId: string | null;
+    violationModeratorRoleIds: readonly string[];
+    violationModeratorUserIds: readonly string[];
+    violationCaseNamePrefix: string;
+    violationMessageLayout: ViolationThreadLayout;
+    violationOpeningMessageTemplate: string;
+}
+export declare const DEFAULT_MODERATION_CONFIGURATION: ModerationConfiguration;
+export declare function parseModerationConfiguration(input: unknown): ModerationConfiguration;
+//# sourceMappingURL=configuration.d.ts.map

package/dist/configuration.js

@@ -0,0 +1,94 @@
+import { DashboardActionValidationError, VIOLATION_THREAD_LAYOUTS, } from "@helyx/sdk";
+import { MODERATION_LIMITS } from "./constants.js";
+export const DEFAULT_MODERATION_CONFIGURATION = Object.freeze({
+    warningDirectMessageEnabled: false,
+    warningDirectMessageTemplate: "You have received a moderation warning in {{serverName}}. Case: {{caseNumber}}.",
+    caseRetentionDays: 365,
+    violationThreadChannelId: null,
+    violationAccessRoleId: null,
+    violationModeratorRoleIds: [],
+    violationModeratorUserIds: [],
+    violationCaseNamePrefix: "moderation-case",
+    violationMessageLayout: "three_containers",
+    violationOpeningMessageTemplate: "A moderation case has been opened so staff can discuss this violation with you.",
+});
+export function parseModerationConfiguration(input) {
+    if (!isObject(input))
+        return { ...DEFAULT_MODERATION_CONFIGURATION };
+    const configuration = {
+        warningDirectMessageEnabled: booleanValue(input.warningDirectMessageEnabled, DEFAULT_MODERATION_CONFIGURATION.warningDirectMessageEnabled),
+        warningDirectMessageTemplate: boundedString(input.warningDirectMessageTemplate, DEFAULT_MODERATION_CONFIGURATION.warningDirectMessageTemplate, MODERATION_LIMITS.warningTemplateMaxCharacters),
+        caseRetentionDays: boundedInteger(input.caseRetentionDays, MODERATION_LIMITS.caseRetentionMinimumDays, MODERATION_LIMITS.caseRetentionMaximumDays, DEFAULT_MODERATION_CONFIGURATION.caseRetentionDays),
+        violationThreadChannelId: optionalDiscordId(input.violationThreadChannelId, "violationThreadChannelId"),
+        violationAccessRoleId: optionalDiscordId(input.violationAccessRoleId, "violationAccessRoleId"),
+        violationModeratorRoleIds: discordIdList(input.violationModeratorRoleIds, MODERATION_LIMITS.moderatorRoles, "violationModeratorRoleIds"),
+        violationModeratorUserIds: discordIdList(input.violationModeratorUserIds, MODERATION_LIMITS.moderatorUsers, "violationModeratorUserIds"),
+        violationCaseNamePrefix: caseNamePrefix(input.violationCaseNamePrefix),
+        violationMessageLayout: messageLayout(input.violationMessageLayout),
+        violationOpeningMessageTemplate: boundedString(input.violationOpeningMessageTemplate, DEFAULT_MODERATION_CONFIGURATION.violationOpeningMessageTemplate, MODERATION_LIMITS.openingTemplateMaxCharacters),
+    };
+    if (configuration.warningDirectMessageEnabled &&
+        !configuration.warningDirectMessageTemplate.trim())
+        throw new DashboardActionValidationError("A warning direct-message template is required while delivery is enabled.");
+    if (configuration.violationThreadChannelId &&
+        configuration.violationAccessRoleId &&
+        !configuration.violationOpeningMessageTemplate.trim())
+        throw new DashboardActionValidationError("Enter an opening message for the configured violation channel.");
+    return configuration;
+}
+function messageLayout(value) {
+    if (value === undefined)
+        return DEFAULT_MODERATION_CONFIGURATION.violationMessageLayout;
+    if (!VIOLATION_THREAD_LAYOUTS.includes(value))
+        throw new DashboardActionValidationError("Choose a supported thread message layout.");
+    return value;
+}
+function caseNamePrefix(value) {
+    const prefix = boundedString(value, DEFAULT_MODERATION_CONFIGURATION.violationCaseNamePrefix, 80).trim();
+    if (!prefix || /[\p{Cc}\p{Cf}]/u.test(prefix))
+        throw new DashboardActionValidationError("Enter a case name prefix without line breaks or hidden control characters.");
+    return prefix;
+}
+function isObject(input) {
+    return Boolean(input) && typeof input === "object" && !Array.isArray(input);
+}
+function booleanValue(value, fallback) {
+    if (value === undefined)
+        return fallback;
+    if (typeof value !== "boolean")
+        throw new DashboardActionValidationError("Moderation configuration requires boolean values.");
+    return value;
+}
+function boundedString(value, fallback, maximum) {
+    if (value === undefined)
+        return fallback;
+    if (typeof value !== "string" || value.length > maximum)
+        throw new DashboardActionValidationError("Moderation configuration contains an invalid template.");
+    return value;
+}
+function boundedInteger(value, minimum, maximum, fallback) {
+    if (value === undefined)
+        return fallback;
+    if (!Number.isInteger(value) ||
+        value < minimum ||
+        value > maximum)
+        throw new DashboardActionValidationError("Moderation configuration contains an invalid integer.");
+    return value;
+}
+function optionalDiscordId(value, key) {
+    if (value === undefined || value === null || value === "")
+        return null;
+    if (typeof value !== "string" || !/^\d{17,20}$/u.test(value))
+        throw new DashboardActionValidationError(`Moderation configuration contains an invalid ${key}.`);
+    return value;
+}
+function discordIdList(value, maximum, key) {
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value) ||
+        value.length > maximum ||
+        value.some((item) => typeof item !== "string" || !/^\d{17,20}$/u.test(item)))
+        throw new DashboardActionValidationError(`Moderation configuration contains an invalid ${key}.`);
+    return [...new Set(value)];
+}
+//# sourceMappingURL=configuration.js.map

package/dist/constants.d.ts

@@ -0,0 +1,53 @@
+export declare const MODERATION_MODULE_ID = "helyx.moderation";
+export declare const MODERATION_CASE_ACTIONS: {
+    readonly mute: "moderation.cases.timeout";
+    readonly unmute: "moderation.cases.timeout-remove";
+    readonly kick: "moderation.cases.kick";
+    readonly ban: "moderation.cases.ban";
+    readonly demote: "moderation.cases.demote";
+    readonly "no-further-action": "moderation.cases.resolve";
+    readonly "close-thread": "moderation.cases.close-thread";
+    readonly "close-and-delete-thread": "moderation.cases.close-and-delete-thread";
+};
+export declare const MODERATION_COMMAND_IDS: Readonly<{
+    readonly warn: "moderation.warn";
+    readonly timeout: "moderation.timeout";
+    readonly timeoutRemove: "moderation.timeout-remove";
+    readonly kick: "moderation.kick";
+    readonly ban: "moderation.ban";
+    readonly demote: "moderation.demote";
+    readonly unban: "moderation.unban";
+    readonly history: "moderation.history";
+}>;
+export declare const MODERATION_COMPONENT_IDS: Readonly<{
+    readonly confirm: "helyx.moderation.confirm:";
+    readonly cancel: "helyx.moderation.cancel:";
+    readonly threadKick: "helyx.moderation.thread-kick:";
+    readonly threadBan: "helyx.moderation.thread-ban:";
+    readonly threadUnmute: "helyx.moderation.thread-unmute:";
+    readonly threadNoFurtherAction: "helyx.moderation.thread-no-further-action:";
+    readonly threadClose: "helyx.moderation.thread-close:";
+    readonly threadCloseDelete: "helyx.moderation.thread-close-delete:";
+}>;
+export declare const MODERATION_TASK_KINDS: Readonly<{
+    readonly threadDelivery: "moderation.thread-delivery";
+    readonly actionReconcile: "moderation.action-reconcile";
+    readonly threadAccessReconcile: "moderation.thread-access-reconcile";
+}>;
+export declare const MODERATION_LIMITS: Readonly<{
+    readonly reasonMinCharacters: 10;
+    readonly reasonMaxCharacters: 500;
+    readonly privateNoteMaxCharacters: 1000;
+    readonly warningTemplateMaxCharacters: 2000;
+    readonly openingTemplateMaxCharacters: 2000;
+    readonly moderatorRoles: 10;
+    readonly moderatorUsers: 10;
+    readonly demotionRoles: 10;
+    readonly casePageSize: 50;
+    readonly caseDateWindowDays: 31;
+    readonly caseRetentionMinimumDays: 30;
+    readonly caseRetentionMaximumDays: 730;
+    readonly timeoutMinimumSeconds: 60;
+    readonly timeoutMaximumSeconds: 2419200;
+}>;
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.js

@@ -0,0 +1,53 @@
+export const MODERATION_MODULE_ID = "helyx.moderation";
+export const MODERATION_CASE_ACTIONS = {
+    mute: "moderation.cases.timeout",
+    unmute: "moderation.cases.timeout-remove",
+    kick: "moderation.cases.kick",
+    ban: "moderation.cases.ban",
+    demote: "moderation.cases.demote",
+    "no-further-action": "moderation.cases.resolve",
+    "close-thread": "moderation.cases.close-thread",
+    "close-and-delete-thread": "moderation.cases.close-and-delete-thread",
+};
+export const MODERATION_COMMAND_IDS = Object.freeze({
+    warn: "moderation.warn",
+    timeout: "moderation.timeout",
+    timeoutRemove: "moderation.timeout-remove",
+    kick: "moderation.kick",
+    ban: "moderation.ban",
+    demote: "moderation.demote",
+    unban: "moderation.unban",
+    history: "moderation.history",
+});
+export const MODERATION_COMPONENT_IDS = Object.freeze({
+    confirm: "helyx.moderation.confirm:",
+    cancel: "helyx.moderation.cancel:",
+    threadKick: "helyx.moderation.thread-kick:",
+    threadBan: "helyx.moderation.thread-ban:",
+    threadUnmute: "helyx.moderation.thread-unmute:",
+    threadNoFurtherAction: "helyx.moderation.thread-no-further-action:",
+    threadClose: "helyx.moderation.thread-close:",
+    threadCloseDelete: "helyx.moderation.thread-close-delete:",
+});
+export const MODERATION_TASK_KINDS = Object.freeze({
+    threadDelivery: "moderation.thread-delivery",
+    actionReconcile: "moderation.action-reconcile",
+    threadAccessReconcile: "moderation.thread-access-reconcile",
+});
+export const MODERATION_LIMITS = Object.freeze({
+    reasonMinCharacters: 10,
+    reasonMaxCharacters: 500,
+    privateNoteMaxCharacters: 1_000,
+    warningTemplateMaxCharacters: 2_000,
+    openingTemplateMaxCharacters: 2_000,
+    moderatorRoles: 10,
+    moderatorUsers: 10,
+    demotionRoles: 10,
+    casePageSize: 50,
+    caseDateWindowDays: 31,
+    caseRetentionMinimumDays: 30,
+    caseRetentionMaximumDays: 730,
+    timeoutMinimumSeconds: 60,
+    timeoutMaximumSeconds: 2_419_200,
+});
+//# sourceMappingURL=constants.js.map