@helyx/bot 1.5.1 → 1.5.3

package/dist/guild-command-worker.js

@@ -12,6 +12,10 @@ export class GuildCommandWorker {
     #installations;
     #availability;
     #modules;
+    #commandRestrictions;
+    #commandCatalogue;
+    #commandPolicyDelivery;
+    #catalogueReady = false;
     #logger;
     #workerId;
     #fencingToken;
@@ -41,6 +45,9 @@ export class GuildCommandWorker {
         this.#installations = repositories.installations;
         this.#availability = repositories.availability;
         this.#modules = input.modules;
+        this.#commandRestrictions = input.commandRestrictions;
+        this.#commandCatalogue = input.commandCatalogue;
+        this.#commandPolicyDelivery = input.commandPolicyDelivery;
         this.#logger = input.logger;
         this.#workerId = input.workerId ?? `guild-command:${randomUUID()}`;
         this.#fencingToken = input.fencingToken;
@@ -62,6 +69,16 @@ export class GuildCommandWorker {
     async runOnce() {
         if (this.#stopping)
             return;
+        await this.#commandRestrictions?.recheck();
+        try {
+            await this.#commandCatalogue?.recheck();
+            this.#catalogueReady = this.#commandCatalogue !== undefined;
+        }
+        catch {
+            this.#catalogueReady = false;
+            this.#logger.warn({ event: "guild_commands.catalogue_unavailable" }, "Command catalogue recovery is unavailable");
+            return;
+        }
         const capacity = Math.max(0, this.#concurrency - this.#active.size);
         if (capacity === 0)
             return;
@@ -154,12 +171,15 @@ export class GuildCommandWorker {
         const heartbeat = setInterval(renew, Math.max(1_000, Math.floor(this.#leaseMs / 3)));
         heartbeat.unref();
         try {
-            const [enabled, availability, state] = await Promise.all([
+            const [enabled, availability, state, rootMappings] = await Promise.all([
                 this.#installations.listEnabledModules(request.guildId),
                 this.#availability.list(),
                 this.#repository.getState(request.applicationId, request.guildId),
+                this.#repository.listRootMappings(request.applicationId, request.guildId),
             ]);
-            if (!state || state.desiredRevision !== request.requestedRevision) {
+            if (!state ||
+                state.desiredRevision !== request.requestedRevision ||
+                rootMappings.some(({ desiredRevision }) => desiredRevision > request.requestedRevision)) {
                 await this.#repository.completeDryRun({
                     request,
                     workerId: this.#workerId,
@@ -174,6 +194,35 @@ export class GuildCommandWorker {
                 });
                 return;
             }
+            const currentPolicy = await this.#commandRestrictions?.getPolicy();
+            for (const mapping of rootMappings) {
+                if (mapping.canonicalRoot !== "nexus")
+                    throw new GuildCommandLiveError("unsupported_root_mapping");
+                if (mapping.desiredRoot === "nexus")
+                    continue;
+                const policy = currentPolicy ??
+                    this.#modules.find(({ manifest }) => manifest.id === "helyx.nexus-core")?.nexusCommandNamePolicy;
+                const result = policy?.evaluate({
+                    guildId: request.guildId,
+                    proposedName: mapping.desiredRoot,
+                });
+                if (!policy?.version ||
+                    !result ||
+                    result.state === "unconfigured" ||
+                    result.policyVersion !== policy.version)
+                    throw new GuildCommandLiveError("command_name_policy_unavailable");
+                if (result.state === "blocked")
+                    throw new GuildCommandLiveError("command_name_blocked");
+            }
+            let reservedCommandNames = [];
+            const catalogueReady = this.#catalogueReady;
+            try {
+                reservedCommandNames =
+                    (await this.#commandCatalogue?.getReservedCommandNames()) ?? [];
+            }
+            catch {
+                throw new GuildCommandLiveError("command_catalogue_unavailable");
+            }
             const projection = projectGuildCommands({
                 modules: this.#modules,
                 enabledModuleIds: new Set(enabled.map(({ moduleId }) => moduleId)),
@@ -182,7 +231,16 @@ export class GuildCommandWorker {
                     .map(({ moduleId }) => moduleId)),
                 profile: state.visibilityProfile,
                 includeInternalCommands: request.guildId === this.#internalGuildId,
+                rootMappings,
+                reservedCommandNames,
             });
+            await this.#validatePolicyDelivery(projection, currentPolicy?.version ??
+                this.#modules.find(({ manifest }) => manifest.id === "helyx.nexus-core")?.nexusCommandNamePolicy?.version ??
+                undefined);
+            if (!catalogueReady &&
+                rootMappings.some(({ desiredRoot }) => desiredRoot !== "nexus") &&
+                projection.definitions.some(({ ownerModuleId }) => ownerModuleId === "helyx.nexus-core"))
+                throw new GuildCommandLiveError("command_catalogue_unavailable");
             if (this.#discord?.canWrite(request.guildId) &&
                 leaseAlive &&
                 !this.#controller.signal.aborted) {
@@ -216,7 +274,8 @@ export class GuildCommandWorker {
                 if (safeCode === "discord_observation_failed" ||
                     safeCode === "discord_rate_limited" ||
                     safeCode === "discord_write_ambiguous" ||
-                    safeCode === "discord_write_mismatch")
+                    safeCode === "discord_write_mismatch" ||
+                    safeCode === "command_policy_unverified")
                     await this.#repository.defer({
                         request,
                         workerId: this.#workerId,
@@ -276,6 +335,20 @@ export class GuildCommandWorker {
             leaseMs: this.#leaseMs,
             verificationDelayMs: 1_000,
             signal: this.#controller.signal,
+            validateWrite: async () => {
+                let reservedCommandNames = [];
+                if (this.#commandCatalogue) {
+                    try {
+                        reservedCommandNames =
+                            await this.#commandCatalogue.getReservedCommandNames();
+                    }
+                    catch {
+                        throw new GuildCommandLiveError("command_catalogue_unavailable");
+                    }
+                }
+                const policyVersion = await this.#validateCurrentNexusProjection(projection, reservedCommandNames, request.guildId);
+                await this.#validatePolicyDelivery(projection, policyVersion);
+            },
         });
         if (!result)
             return;
@@ -291,6 +364,44 @@ export class GuildCommandWorker {
             outcome: result.outcome,
         }, "Guild commands reconciled");
     }
+    async #validatePolicyDelivery(projection, policyVersion) {
+        if (!this.#commandPolicyDelivery ||
+            !projection.definitions.some(({ ownerModuleId, name }) => ownerModuleId === "helyx.nexus-core" && name !== "nexus"))
+            return;
+        try {
+            const gate = await this.#commandPolicyDelivery.readGate();
+            if (gate.ready &&
+                policyVersion === `command-restrictions:${String(gate.revision)}`)
+                return;
+        }
+        catch {
+            /* A read failure cannot authorize an unverified custom root. */
+        }
+        throw new GuildCommandLiveError("command_policy_unverified");
+    }
+    async #validateCurrentNexusProjection(projection, reservedCommandNames, guildId) {
+        const names = projection.definitions
+            .filter(({ ownerModuleId, name }) => ownerModuleId === "helyx.nexus-core" && name !== "nexus")
+            .map(({ name }) => name);
+        if (!names.length)
+            return undefined;
+        const policy = (await this.#commandRestrictions?.getPolicy()) ??
+            this.#modules.find(({ manifest }) => manifest.id === "helyx.nexus-core")
+                ?.nexusCommandNamePolicy;
+        for (const name of names) {
+            if (reservedCommandNames.includes(name))
+                throw new GuildCommandLiveError("command_name_reserved");
+            const result = policy?.evaluate({ guildId, proposedName: name });
+            if (!policy?.version ||
+                !result ||
+                result.state === "unconfigured" ||
+                result.policyVersion !== policy.version)
+                throw new GuildCommandLiveError("command_name_policy_unavailable");
+            if (result.state === "blocked")
+                throw new GuildCommandLiveError("command_name_blocked");
+        }
+        return policy?.version ?? undefined;
+    }
 }
 export async function reconcileLiveGuildCommands(input) {
     let observed;
@@ -302,6 +413,68 @@ export async function reconcileLiveGuildCommands(input) {
             ? "discord_rate_limited"
             : "discord_observation_failed");
     }
+    // A name match is not an ownership match. Delete a tracked Nexus ID before
+    // the ordinary bulk writer can reuse it for a different module's root.
+    const handedOffRoots = new Set();
+    const retiredDuringRun = new Set();
+    if (diffGuildCommands(input.projection, observed).conflicts.length > 0)
+        throw new GuildCommandLiveError("discord_command_conflict");
+    const handoffs = (input.projection.rootMappings ?? []).filter((mapping) => mapping.observedRoot !== null &&
+        mapping.observedCommandId !== null &&
+        input.projection.definitions.some(({ name, type, ownerModuleId }) => type === 1 &&
+            name === mapping.observedRoot &&
+            ownerModuleId !== "helyx.nexus-core"));
+    for (const mapping of handoffs) {
+        if (mapping.applicationId !== input.request.applicationId ||
+            mapping.guildId !== input.request.guildId ||
+            mapping.canonicalRoot !== "nexus")
+            throw new GuildCommandLiveError("unsupported_root_mapping");
+        if (!(await currentLease()))
+            return null;
+        handedOffRoots.add(mapping.observedRoot);
+        retiredDuringRun.add(mapping.observedCommandId);
+        observed = await removeTrackedId(mapping.observedCommandId, mapping.observedRoot);
+        if (!(await currentLease()))
+            return null;
+        let retired;
+        try {
+            retired = await input.repository.retireRootObservation({
+                request: input.request,
+                workerId: input.workerId,
+                fencingToken: input.fencingToken,
+                canonicalRoot: mapping.canonicalRoot,
+                settingsRevision: mapping.settingsRevision,
+                desiredRevision: mapping.desiredRevision,
+                expectedObservedRoot: mapping.observedRoot,
+                expectedObservedCommandId: mapping.observedCommandId,
+            });
+        }
+        catch {
+            throw new GuildCommandLiveError("discord_write_ambiguous");
+        }
+        if (!retired)
+            return null;
+    }
+    // A previous attempt may have committed retirement and then crashed before
+    // installing the new owner. The scoped ledger also protects that retry path.
+    for (const command of [...observed]) {
+        if (!command.id ||
+            !/^\d{17,20}$/u.test(command.id) ||
+            (command.type ?? 1) !== 1 ||
+            !input.projection.definitions.some(({ name, type, ownerModuleId }) => type === 1 &&
+                name === command.name &&
+                ownerModuleId !== "helyx.nexus-core"))
+            continue;
+        if (await input.repository.isRetiredRootCommandId(input.request.applicationId, input.request.guildId, command.id)) {
+            if (!(await currentLease()))
+                return null;
+            handedOffRoots.add(command.name);
+            retiredDuringRun.add(command.id);
+            observed = await removeTrackedId(command.id, command.name);
+            if (!(await currentLease()))
+                return null;
+        }
+    }
     const diff = diffGuildCommands(input.projection, observed);
     if (diff.conflicts.length > 0)
         throw new GuildCommandLiveError("discord_command_conflict");
@@ -326,11 +499,19 @@ export async function reconcileLiveGuildCommands(input) {
             throw error;
         }
     }
-    const current = await input.repository.isLeaseCurrent({
-        request: input.request,
-        workerId: input.workerId,
-        fencingToken: input.fencingToken,
-    });
+    let current;
+    try {
+        current = await currentLease();
+    }
+    catch (error) {
+        if (ledgerId)
+            await input.repository.settleCreation({
+                ledgerId,
+                state: "released",
+                observedReference: "write_not_started",
+            });
+        throw error;
+    }
     if (!current || input.signal?.aborted) {
         if (ledgerId)
             await input.repository.settleCreation({
@@ -385,26 +566,175 @@ export async function reconcileLiveGuildCommands(input) {
                 });
             throw new GuildCommandLiveError("discord_write_mismatch");
         }
+        observed = written;
     }
-    const outcome = await input.repository.completeLive({
-        request: input.request,
-        workerId: input.workerId,
-        fencingToken: input.fencingToken,
-        definitionHash: input.projection.definitionHash,
-        rootCount: input.projection.rootCount,
-        subcommandCount: input.projection.subcommandCount,
-        observedDefinitionHash: input.projection.definitionHash,
-        installedRootCount: input.projection.rootCount,
-        createdCount: diff.create.length,
-        updatedCount: diff.update.length,
-        removedCount: diff.remove.length,
-        createdCommands: diff.create.map(({ name }) => `/${name}`),
-        updatedCommands: diff.update.map(({ name }) => `/${name}`),
-        removedCommands: diff.remove.map(({ name }) => `/${name}`),
-        ...(ledgerId ? { ledgerId } : {}),
-        observedReference: `discord:guild:${input.request.guildId}:roots:${input.projection.rootCount}`,
-    });
+    const rootMappings = input.projection.rootMappings ?? [];
+    if (rootMappings.length > 0) {
+        // A successful replacement response alone does not activate a new route.
+        // Read the full collection back before recording its actual Discord ID.
+        try {
+            observed = await input.discord.observe(input.request.guildId);
+        }
+        catch {
+            if (ledgerId)
+                await input.repository.settleCreation({
+                    ledgerId,
+                    state: "committed",
+                    observedReference: `discord:guild:${input.request.guildId}:root_readback_ambiguous`,
+                });
+            throw new GuildCommandLiveError("discord_observation_failed");
+        }
+        if (!hasNoChanges(diffGuildCommands(input.projection, observed))) {
+            if (ledgerId)
+                await input.repository.settleCreation({
+                    ledgerId,
+                    state: "committed",
+                    observedReference: `discord:guild:${input.request.guildId}:root_readback_mismatch`,
+                });
+            throw new GuildCommandLiveError("discord_write_mismatch");
+        }
+    }
+    const rootObservations = [];
+    try {
+        await input.validateWrite?.();
+        for (const command of observed) {
+            if (handedOffRoots.has(command.name) &&
+                (!command.id ||
+                    !/^\d{17,20}$/u.test(command.id) ||
+                    (command.application_id !== undefined &&
+                        command.application_id !== input.request.applicationId) ||
+                    (command.guild_id !== undefined &&
+                        command.guild_id !== input.request.guildId)))
+                throw new GuildCommandLiveError("discord_observation_failed");
+            if (command.id && retiredDuringRun.has(command.id))
+                throw new GuildCommandLiveError("discord_write_mismatch");
+            if (command.id &&
+                /^\d{17,20}$/u.test(command.id) &&
+                input.projection.definitions.some(({ name, type, ownerModuleId }) => type === 1 &&
+                    name === command.name &&
+                    ownerModuleId !== "helyx.nexus-core") &&
+                (await input.repository.isRetiredRootCommandId(input.request.applicationId, input.request.guildId, command.id)))
+                throw new GuildCommandLiveError("discord_write_mismatch");
+        }
+    }
+    catch (error) {
+        if (ledgerId)
+            await retainCreatedCapacity();
+        throw error instanceof GuildCommandLiveError
+            ? error
+            : new GuildCommandLiveError("discord_observation_failed");
+    }
+    for (const mapping of rootMappings) {
+        const projected = input.projection.definitions.find(({ name, type, ownerModuleId }) => name === mapping.desiredRoot &&
+            type === 1 &&
+            ownerModuleId === "helyx.nexus-core");
+        const actual = projected
+            ? observed.find(({ name, type }) => name === mapping.desiredRoot && (type ?? 1) === 1)
+            : undefined;
+        if (projected && (!actual?.id || !/^\d{17,20}$/u.test(actual.id))) {
+            if (ledgerId)
+                await input.repository.settleCreation({
+                    ledgerId,
+                    state: "committed",
+                    observedReference: `discord:guild:${input.request.guildId}:root_id_unverified`,
+                });
+            throw new GuildCommandLiveError("discord_observation_failed");
+        }
+        rootObservations.push({
+            canonicalRoot: mapping.canonicalRoot,
+            desiredRevision: mapping.desiredRevision,
+            settingsRevision: mapping.settingsRevision,
+            observedRoot: actual?.name ?? null,
+            observedCommandId: actual?.id ?? null,
+        });
+    }
+    let outcome;
+    try {
+        outcome = await input.repository.completeLive({
+            request: input.request,
+            workerId: input.workerId,
+            fencingToken: input.fencingToken,
+            definitionHash: input.projection.definitionHash,
+            rootCount: input.projection.rootCount,
+            subcommandCount: input.projection.subcommandCount,
+            observedDefinitionHash: input.projection.definitionHash,
+            installedRootCount: input.projection.rootCount,
+            createdCount: diff.create.length,
+            updatedCount: diff.update.length,
+            removedCount: diff.remove.length,
+            createdCommands: diff.create.map(({ name }) => `/${name}`),
+            updatedCommands: diff.update.map(({ name }) => `/${name}`),
+            removedCommands: diff.remove.map(({ name }) => `/${name}`),
+            ...(rootObservations.length > 0 ? { rootObservations } : {}),
+            ...(ledgerId ? { ledgerId } : {}),
+            observedReference: `discord:guild:${input.request.guildId}:roots:${input.projection.rootCount}`,
+        });
+    }
+    catch (error) {
+        if (ledgerId)
+            await retainCreatedCapacity();
+        throw error;
+    }
+    if (ledgerId && outcome !== "completed")
+        await retainCreatedCapacity();
     return { outcome, diff };
+    async function currentLease() {
+        if (input.signal?.aborted ||
+            !(await input.repository.isLeaseCurrent({
+                request: input.request,
+                workerId: input.workerId,
+                fencingToken: input.fencingToken,
+            })))
+            return false;
+        // Final freshness must follow every potentially delayed catalogue/lease read.
+        await input.validateWrite?.();
+        return !input.signal?.aborted;
+    }
+    async function removeTrackedId(commandId, expectedName) {
+        const target = observed.find(({ id }) => id === commandId);
+        if (observed.some(({ name, id }) => name === expectedName && !id) ||
+            (target &&
+                (target.name !== expectedName ||
+                    (target.type ?? 1) !== 1 ||
+                    (target.application_id !== undefined &&
+                        target.application_id !== input.request.applicationId) ||
+                    (target.guild_id !== undefined &&
+                        target.guild_id !== input.request.guildId))))
+            throw new GuildCommandLiveError("discord_observation_failed");
+        if (!target)
+            return observed;
+        try {
+            await input.discord.remove(input.request.guildId, commandId);
+        }
+        catch {
+            /* A timeout or 404 is settled only by the independent readback. */
+        }
+        let readback;
+        try {
+            readback = await input.discord.observe(input.request.guildId);
+        }
+        catch {
+            throw new GuildCommandLiveError("discord_observation_failed");
+        }
+        if (readback.some(({ id }) => id === commandId) ||
+            readback.some(({ name, id }) => name === expectedName && !id))
+            throw new GuildCommandLiveError("discord_write_mismatch");
+        return readback;
+    }
+    async function retainCreatedCapacity() {
+        // Discord was already written or read back successfully. A failed/fenced
+        // completion must not release real creations when its reservation expires.
+        try {
+            await input.repository.settleCreation({
+                ledgerId: ledgerId,
+                state: "committed",
+                observedReference: `discord:guild:${input.request.guildId}:completion_unacknowledged`,
+            });
+        }
+        catch {
+            // Preserve the original completion error; durable retry still owns it.
+        }
+    }
 }
 class GuildCommandLiveError extends Error {
     safeCode;

package/dist/guild-message-protection-author-roles.d.ts

@@ -0,0 +1,7 @@
+import type { Message } from "discord.js";
+/** Pinned cache compatibility: public member.roles.cache silently omits uncached assigned IDs. */
+export declare function snapshotProtectionAuthorRoles(message: Message, webhook: boolean): Readonly<{
+    authorRoleIds: readonly string[];
+    authorRolesResolved: boolean;
+}>;
+//# sourceMappingURL=guild-message-protection-author-roles.d.ts.map

package/dist/guild-message-protection-author-roles.js

@@ -0,0 +1,93 @@
+const maximumAssignedRoles = 250; // Private snapshot bound, not a Discord product limit.
+const maximumPublishedRoles = 250;
+const snowflake = /^\d{17,20}$/u;
+const unknown = Object.freeze({
+    authorRoleIds: Object.freeze([]),
+    authorRolesResolved: false,
+});
+const webhookRoles = Object.freeze({
+    authorRoleIds: Object.freeze([]),
+    authorRolesResolved: true,
+});
+/** Pinned cache compatibility: public member.roles.cache silently omits uncached assigned IDs. */
+export function snapshotProtectionAuthorRoles(message, webhook) {
+    if (webhook)
+        return webhookRoles;
+    try {
+        const guildId = message.guildId, authorId = message.author.id;
+        const client = message.client, guild = message.guild, member = message.member;
+        if (!guildId ||
+            !snowflake.test(guildId) ||
+            !snowflake.test(authorId) ||
+            !guild ||
+            !member ||
+            guild.id !== guildId ||
+            guild.client !== client ||
+            guild.available !== true ||
+            client.guilds.cache.get(guildId) !== guild ||
+            member.guild !== guild ||
+            member.client !== client ||
+            member.id !== authorId ||
+            member.user.id !== authorId ||
+            member.partial !== false ||
+            guild.members.cache.get(authorId) !== member)
+            return unknown;
+        const assigned = Reflect.get(member, "_roles");
+        if (!Array.isArray(assigned) || assigned.length > maximumAssignedRoles)
+            return unknown;
+        const length = assigned.length, snapshot = [], seen = new Set();
+        for (let index = 0; index < length; index++) {
+            const id = assigned[index];
+            if (typeof id !== "string" ||
+                !snowflake.test(id) ||
+                id === guildId ||
+                seen.has(id))
+                return unknown;
+            seen.add(id);
+            snapshot.push(id);
+        }
+        if (assigned.length !== length)
+            return unknown;
+        seen.add(guildId);
+        const roles = [];
+        // Role IDs suffice for exemption metadata. No permission bits/names or member fetch.
+        for (const id of seen) {
+            const role = guild.roles.cache.get(id);
+            if (!role ||
+                role.id !== id ||
+                role.guild !== guild ||
+                role.client !== client)
+                return unknown;
+            roles.push({ id, role });
+        }
+        for (const { id, role } of roles) {
+            if (guild.roles.cache.get(id) !== role ||
+                role.id !== id ||
+                role.guild !== guild ||
+                role.client !== client)
+                return unknown;
+        }
+        if (client.guilds.cache.get(guildId) !== guild ||
+            guild.available !== true ||
+            message.guildId !== guildId ||
+            message.author.id !== authorId ||
+            guild.members.cache.get(authorId) !== member ||
+            member.guild !== guild ||
+            member.client !== client ||
+            member.id !== authorId ||
+            member.partial !== false ||
+            Reflect.get(member, "_roles") !== assigned ||
+            assigned.length !== length ||
+            snapshot.some((id, index) => assigned[index] !== id))
+            return unknown;
+        const ids = [...seen].sort();
+        return Object.freeze({
+            authorRoleIds: Object.freeze(ids.slice(0, maximumPublishedRoles)),
+            authorRolesResolved: ids.length <= maximumPublishedRoles,
+        });
+    }
+    catch {
+        return unknown;
+    }
+}
+//# sourceMappingURL=guild-message-protection-author-roles.js.map

package/dist/guild-message-protection-deletion.d.ts

@@ -0,0 +1,21 @@
+import type { GuildMessageProtectionDeletionResult } from "@helyx/sdk";
+import type { Client, GuildBasedChannel } from "discord.js";
+import { type CachedMessageDeletionAuthority, type CachedMessageDeletionScope } from "./cached-message-deletion-authority.js";
+import type { EmergencyDeletionDispatcher } from "./emergency-deletion-dispatcher.js";
+import type { MessageProtectionEligibility } from "./guild-message-protection-delivery.js";
+export type MessageProtectionAuthorityFactory = (source: Readonly<CachedMessageDeletionScope & {
+    channel: GuildBasedChannel;
+}>, isStopped: () => boolean) => CachedMessageDeletionAuthority | undefined;
+/** Separate lexical scope: queued grants never capture an execute/Message environment. */
+export declare function createProtectionDeliveryLifetime(): Readonly<{
+    isStopped: () => boolean;
+    stop: () => void;
+}>;
+/** Explicit private composition only; never derive configuration from mutable client identity. */
+export declare function createMessageProtectionAuthorityFactory(client: Client, expectedApplicationId: string | undefined, eligibility: MessageProtectionEligibility | undefined, deletion: EmergencyDeletionDispatcher | undefined): MessageProtectionAuthorityFactory | undefined;
+/** Handler-local owner; only its content-free grant is handed to the queue. */
+export declare function createProtectionDeletionOperation(input: CachedMessageDeletionScope, deletion: EmergencyDeletionDispatcher | undefined, strict: boolean, captured: CachedMessageDeletionAuthority | undefined, isActive: () => boolean): Readonly<{
+    releaseUnused: () => void;
+    invoke: () => Promise<GuildMessageProtectionDeletionResult>;
+}>;
+//# sourceMappingURL=guild-message-protection-deletion.d.ts.map