@helyx/bot 0.5.0 → 0.6.2

package/dist/index.js

@@ -1,7 +1,7 @@
 import { parseBotEnvironment } from "@helyx/config";
 import { StatusHeartbeatReporter } from "@helyx/status-client";
 import { safeError, ServiceRegistry } from "@helyx/core";
-import { checkDatabaseConnection, createDatabasePool, AuditRepository, GuildCommandRepository, InteractionSessionRepository, RateLimitRepository, runCoreMigrations, runConfiguredModuleMigrations, } from "@helyx/database";
+import { checkDatabaseConnection, createDatabasePool, AuditRepository, GuildCommandRepository, InteractionSessionRepository, PremiumAllocationRepository, RateLimitRepository, runCoreMigrations, runConfiguredModuleMigrations, } from "@helyx/database";
 import { createRuntime } from "@helyx/framework";
 import { createPlatformServices, gamingStatisticsRecordOwner, achievementContributionRecordOwner, PostgresPrivacyProviderExecutor, PlatformMemberRoleGrantOwnershipService, PostgresMemberRoleGrantOwnershipStore, } from "@helyx/platform";
 import { HELYX_SERVICE_NAMES, } from "@helyx/sdk";
@@ -30,6 +30,9 @@ import { shardHealthSnapshotSchema, } from "./shard-contracts.js";
 import { createSupportModule } from "./support-module.js";
 import { createOAuthModule } from "./oauth-module.js";
 import { createPrivacyModule } from "./privacy-module.js";
+import { REVIEWED_PREMIUM_MODULE_IDS } from "@helyx/module-manifest";
+import { createPremiumActivationModule } from "./premium-activation-module.js";
+import { DiscordPremiumGuildAuthority } from "./premium-guild-authority.js";
 import { HttpOAuthService } from "./oauth-service.js";
 import { DiscordOwnedMessageDeletionService } from "./discord-owned-message-service.js";
 import { DiscordGuildHealthInspection } from "./discord-guild-health.js";
@@ -45,6 +48,8 @@ import { createLocalScheduledTaskRoute, createScheduledTaskRunner, schedulerOper
 import { createLocalNumericWriteBehind } from "./numeric-write-behind.js";
 import { discordRestOptions } from "./discord-rest.js";
 import { discordBotStatusService } from "./status-producer.js";
+import { assertReviewedPremiumCatalogue, requirePremiumProviderEnvironment, } from "./premium-access.js";
+import { enforcePremiumCatalogue, PREMIUM_CATALOGUE_ENFORCEMENT_INTERVAL_MS, } from "./premium-catalogue-enforcement.js";
 export { loadConfiguredModulePackages } from "./modules.js";
 export { resolveModulePackageSpecifiers } from "./module-configuration.js";
 export * from "./control-server.js";
@@ -83,9 +88,7 @@ export async function startBot(processEnvironment = process.env) {
                     },
                 {
                     key: "creator-connections",
-                    state: environment.HELYX_OAUTH_ENABLED
-                        ? "operational"
-                        : "major_outage",
+                    state: "operational",
                     reasonCode: environment.HELYX_OAUTH_ENABLED
                         ? null
                         : "feature_disabled",
@@ -95,7 +98,7 @@ export async function startBot(processEnvironment = process.env) {
             ];
         },
         onError(error) {
-            bootstrapLogger.warn({ event: "status.heartbeat_failed", reason: error.message }, "Status heartbeat could not be delivered");
+            bootstrapLogger.warn({ event: "status.heartbeat_failed", error: safeError(error) }, "Status heartbeat could not be delivered");
         },
     });
     reporter.start();
@@ -128,6 +131,7 @@ async function startUnshardedBot(processEnvironment) {
         : undefined;
     let databaseClosed = false;
     let retentionCleanupTimer;
+    let premiumCatalogueTimer;
     async function closeDatabase() {
         if (databaseClosed)
             return;
@@ -198,6 +202,15 @@ async function startUnshardedBot(processEnvironment) {
             })),
         }, "Module databases ready");
         const featureModules = modulePackages.map(({ definition }) => definition);
+        assertReviewedPremiumCatalogue(featureModules);
+        await enforcePremiumCatalogue(database, bootstrapLogger);
+        premiumCatalogueTimer = setInterval(() => void enforcePremiumCatalogue(database, bootstrapLogger).catch((error) => {
+            bootstrapLogger.warn({
+                event: "premium.catalogue_enforcement_failed",
+                error: safeError(error),
+            }, "Premium module catalogue enforcement failed");
+        }), PREMIUM_CATALOGUE_ENFORCEMENT_INTERVAL_MS);
+        premiumCatalogueTimer.unref();
         const client = new Client({
             rest: discordRestOptions,
             intents: gatewayIntentsForModules(featureModules, environment.HELYX_MESSAGE_CONTENT_ENABLED, environment.HELYX_GUILD_MEMBERS_ENABLED),
@@ -224,6 +237,16 @@ async function startUnshardedBot(processEnvironment) {
             : undefined;
         const supportModule = createSupportModule(cloudConnector);
         const privacyModule = createPrivacyModule();
+        const premiumEnvironment = requirePremiumProviderEnvironment(featureModules, environment.STRIPE_ENVIRONMENT);
+        const premiumActivationModule = !premiumEnvironment
+            ? undefined
+            : createPremiumActivationModule({
+                allocations: new PremiumAllocationRepository(database),
+                authority: new DiscordPremiumGuildAuthority(client),
+                provider: "stripe",
+                providerEnvironment: premiumEnvironment,
+                reviewedPremiumModuleIds: REVIEWED_PREMIUM_MODULE_IDS,
+            });
         const oauthModule = environment.HELYX_OAUTH_ENABLED
             ? createOAuthModule()
             : undefined;
@@ -232,6 +255,7 @@ async function startUnshardedBot(processEnvironment) {
             permissionsModule,
             supportModule,
             privacyModule,
+            ...(premiumActivationModule ? [premiumActivationModule] : []),
             ...(oauthModule ? [oauthModule] : []),
             ...(cloudManagementModule ? [cloudManagementModule] : []),
             ...featureModules,
@@ -305,6 +329,7 @@ async function startUnshardedBot(processEnvironment) {
                     permissionsModule,
                     supportModule,
                     privacyModule,
+                    ...(premiumActivationModule ? [premiumActivationModule] : []),
                     ...(oauthModule ? [oauthModule] : []),
                     ...(cloudManagementModule ? [cloudManagementModule] : []),
                 ].map(({ manifest }) => manifest),
@@ -372,6 +397,7 @@ async function startUnshardedBot(processEnvironment) {
             managementModule.manifest.id,
             permissionsModule.manifest.id,
             supportModule.manifest.id,
+            ...(premiumActivationModule ? [premiumActivationModule.manifest.id] : []),
             ...(oauthModule ? [oauthModule.manifest.id] : []),
             ...(cloudManagementModule ? [cloudManagementModule.manifest.id] : []),
             ...(operationsModule ? [operationsModule.manifest.id] : []),
@@ -386,6 +412,9 @@ async function startUnshardedBot(processEnvironment) {
             prepare: prepareGuilds,
             selfAuthorizingGuildModuleIds: new Set([
                 supportModule.manifest.id,
+                ...(premiumActivationModule
+                    ? [premiumActivationModule.manifest.id]
+                    : []),
                 ...(oauthModule ? [oauthModule.manifest.id] : []),
                 ...(operationsModule ? [operationsModule.manifest.id] : []),
             ]),
@@ -424,6 +453,8 @@ async function startUnshardedBot(processEnvironment) {
             process.off("SIGTERM", onSigterm);
             if (retentionCleanupTimer)
                 clearInterval(retentionCleanupTimer);
+            if (premiumCatalogueTimer)
+                clearInterval(premiumCatalogueTimer);
             await scheduledTasks?.stop().catch((error) => {
                 process.exitCode = 1;
                 bootstrapLogger.error({ event: "scheduler.stop_failed", error: safeError(error) }, "Scheduled task runner shutdown failed");
@@ -587,6 +618,8 @@ async function startUnshardedBot(processEnvironment) {
     catch (error) {
         if (retentionCleanupTimer)
             clearInterval(retentionCleanupTimer);
+        if (premiumCatalogueTimer)
+            clearInterval(premiumCatalogueTimer);
         await closeDatabase().catch((closeError) => {
             bootstrapLogger.error({ event: "database.close_failed", error: safeError(closeError) }, "Database pool cleanup failed");
         });

package/dist/interactions.d.ts

@@ -39,7 +39,7 @@ export declare function sendToChannel(client: Client, channelId: string, respons
 export declare function deleteChannelMessage(client: Client, channelId: string, messageId: string): Promise<void>;
 export declare function editChannelMessage(client: Client, channelId: string, messageId: string, response: MessageResponse): Promise<void>;
 export declare function addChannelMessageReaction(client: Client, channelId: string, messageId: string, emojiIdentifier: string): Promise<void>;
-export declare function authorizeCommand(interaction: ChatInputCommandInteraction, moduleId: string, commandId: string, rateLimit: CommandContribution["rateLimit"], services: ServiceAccess, selfAuthorizingGuildCommand: boolean, resourceScopedCommand?: boolean, requiredModuleName?: string, installationIndependentCommand?: boolean, authorization?: CommandAuthorization): Promise<boolean>;
+export declare function authorizeCommand(interaction: ChatInputCommandInteraction, moduleId: string, commandId: string, rateLimit: CommandContribution["rateLimit"], services: ServiceAccess, selfAuthorizingGuildCommand: boolean, resourceScopedCommand?: boolean, requiredModuleName?: string, installationIndependentCommand?: boolean, authorization?: CommandAuthorization, module?: ModuleDefinition): Promise<boolean>;
 export declare function normalizeDiscordPermission(permission: string): string;
 export declare function toReplyOptions(response: MessageResponse): InteractionReplyOptions;
 export declare function toUpdateOptions(response: MessageResponse): InteractionUpdateOptions;

package/dist/interactions.js

@@ -1,10 +1,11 @@
 import { lookup as lookupDns } from "node:dns/promises";
 import { HELYX_SERVICE_NAMES, NexusEconomyError, UserFacingInteractionError, } from "@helyx/sdk";
-import { canUseCommand } from "@helyx/core";
+import { canUseCommand, safeError } from "@helyx/core";
 import { commandRegistrationPolicy, contributionRegistrationPolicy, } from "./command-registration-policy.js";
 import { ActionRowBuilder, ButtonBuilder, ButtonStyle, ChannelSelectMenuBuilder, EmbedBuilder, Events, GuildMember, ApplicationIntegrationType, ChannelType, InteractionContextType, LabelBuilder, MessageFlags, MentionableSelectMenuBuilder, ModalBuilder, RoleSelectMenuBuilder, Routes, StringSelectMenuBuilder, SlashCommandBuilder, TextInputBuilder, TextInputStyle, UserSelectMenuBuilder, TextDisplayBuilder, PermissionFlagsBits, escapeMarkdown, } from "discord.js";
 import { collectCommandRegistrations, } from "./shared-commands.js";
 import { resolveDirectCommandPath } from "./command-path-contract.js";
+import { canAccessModule, PREMIUM_MODULE_UNAVAILABLE_MESSAGE, } from "./premium-access.js";
 const buttonStyles = {
     primary: ButtonStyle.Primary,
     secondary: ButtonStyle.Secondary,
@@ -110,7 +111,7 @@ export function installInteractions(client, modules, registration, logger, servi
                         !subcommand?.autocomplete ||
                         !ownerModuleId ||
                         !(await authorizeAutocomplete(interaction, ownerModuleId, resolveDirectCommandPath(registered.contribution, subcommand, groupName).permissionId, services, registration.selfAuthorizingGuildModuleIds?.has(ownerModuleId) ??
-                            false, subcommand.authorization === "resource-scoped", isInstallationIndependentModule(modulesById, ownerModuleId), subcommand.authorization))) {
+                            false, subcommand.authorization === "resource-scoped", isInstallationIndependentModule(modulesById, ownerModuleId), subcommand.authorization, requiredCommandModule(modulesById, ownerModuleId)))) {
                         await response.respond([]);
                         return;
                     }
@@ -190,7 +191,7 @@ export function installInteractions(client, modules, registration, logger, servi
                         await interaction.deferReply({ flags: MessageFlags.Ephemeral });
                     }
                     if (await authorizeCommand(interaction, ownerModuleId, permissionId, rateLimit, services, registration.selfAuthorizingGuildModuleIds?.has(ownerModuleId) ??
-                        false, subcommand?.authorization === "resource-scoped", owner?.moduleName, installationIndependentCommand, authorization)) {
+                        false, subcommand?.authorization === "resource-scoped", owner?.moduleName, installationIndependentCommand, authorization, requiredCommandModule(modulesById, ownerModuleId))) {
                         const context = createCommandContext(interaction, services);
                         await execute(context);
                     }
@@ -217,12 +218,7 @@ export function installInteractions(client, modules, registration, logger, servi
                 }
                 if (button &&
                     context &&
-                    button.contribution.authorization === "public") {
-                    await button.contribution.execute(context);
-                }
-                else if (button &&
-                    context &&
-                    (await authorizeComponent(interaction, button.moduleId, services, undefined, isInstallationIndependentModule(modulesById, button.moduleId)))) {
+                    (await authorizeComponent(interaction, button.moduleId, services, undefined, isInstallationIndependentModule(modulesById, button.moduleId), modulesById.get(button.moduleId)))) {
                     await button.contribution.execute(context);
                 }
             }
@@ -239,7 +235,7 @@ export function installInteractions(client, modules, registration, logger, servi
                     await interaction.deferReply({ flags: MessageFlags.Ephemeral });
                 }
                 if (modal &&
-                    (await authorizeComponent(interaction, modal.moduleId, services, undefined, isInstallationIndependentModule(modulesById, modal.moduleId)))) {
+                    (await authorizeComponent(interaction, modal.moduleId, services, undefined, isInstallationIndependentModule(modulesById, modal.moduleId), modulesById.get(modal.moduleId)))) {
                     await modal.contribution.execute(createModalContext(interaction, services));
                 }
             }
@@ -264,7 +260,7 @@ export function installInteractions(client, modules, registration, logger, servi
                 }
                 if (select &&
                     context &&
-                    (await authorizeComponent(interaction, select.moduleId, services, undefined, isInstallationIndependentModule(modulesById, select.moduleId)))) {
+                    (await authorizeComponent(interaction, select.moduleId, services, undefined, isInstallationIndependentModule(modulesById, select.moduleId), modulesById.get(select.moduleId)))) {
                     await select.contribution.execute(context);
                 }
             }
@@ -857,19 +853,31 @@ export async function addChannelMessageReaction(client, channelId, messageId, em
     const message = await channel.messages.fetch(messageId);
     await message.react(emojiIdentifier);
 }
-async function authorizeComponent(interaction, moduleId, services, requiredModuleName, installationIndependent = false) {
+async function authorizeComponent(interaction, moduleId, services, requiredModuleName, installationIndependent = false, module) {
     if (installationIndependent)
         return true;
-    if (!(await moduleIsGloballyAvailable(services, moduleId))) {
+    const installations = interaction.guildId
+        ? services.get(HELYX_SERVICE_NAMES.installations)
+        : undefined;
+    const [globallyAvailable, moduleEnabled, premiumAccessible] = await Promise.all([
+        moduleIsGloballyAvailable(services, moduleId),
+        installations
+            ? installations.isModuleEnabled(interaction.guildId, moduleId)
+            : Promise.resolve(true),
+        interaction.guildId && module
+            ? canAccessModule(services, interaction.guildId, module)
+            : Promise.resolve(true),
+    ]);
+    if (!globallyAvailable) {
         await replyEphemeralText(interaction, GLOBAL_MODULE_UNAVAILABLE_MESSAGE);
         return false;
     }
-    if (!interaction.guildId)
-        return true;
-    const installations = services.get(HELYX_SERVICE_NAMES.installations);
-    if (await installations.isModuleEnabled(interaction.guildId, moduleId)) {
-        return true;
+    if (!premiumAccessible) {
+        await replyEphemeralText(interaction, PREMIUM_MODULE_UNAVAILABLE_MESSAGE);
+        return false;
     }
+    if (moduleEnabled)
+        return true;
     await replyEphemeralText(interaction, requiredModuleName
         ? `This command needs ${requiredModuleName}. Ask a server administrator to enable it in the Helyx dashboard.`
         : "This module is disabled in this server. Ask a server administrator to enable it with `/helyx` or in the Helyx dashboard.");
@@ -882,22 +890,29 @@ async function replyEphemeralText(interaction, content) {
     }
     await interaction.reply({ content, flags: MessageFlags.Ephemeral });
 }
-export async function authorizeCommand(interaction, moduleId, commandId, rateLimit, services, selfAuthorizingGuildCommand, resourceScopedCommand = false, requiredModuleName, installationIndependentCommand = false, authorization) {
+export async function authorizeCommand(interaction, moduleId, commandId, rateLimit, services, selfAuthorizingGuildCommand, resourceScopedCommand = false, requiredModuleName, installationIndependentCommand = false, authorization, module) {
     const bypassPlatformAuthorization = authorization === "public" || authorization === "self-authorized";
     if (!installationIndependentCommand && !selfAuthorizingGuildCommand) {
         const installations = interaction.guildId
             ? services.get(HELYX_SERVICE_NAMES.installations)
             : undefined;
-        const [globallyAvailable, moduleEnabled] = await Promise.all([
+        const [globallyAvailable, moduleEnabled, premiumAccessible] = await Promise.all([
             moduleIsGloballyAvailable(services, moduleId),
             installations && !selfAuthorizingGuildCommand
                 ? installations.isModuleEnabled(interaction.guildId, moduleId)
                 : Promise.resolve(true),
+            interaction.guildId && module
+                ? canAccessModule(services, interaction.guildId, module)
+                : Promise.resolve(true),
         ]);
         if (!globallyAvailable) {
             await replyEphemeralText(interaction, GLOBAL_MODULE_UNAVAILABLE_MESSAGE);
             return false;
         }
+        if (!premiumAccessible) {
+            await replyEphemeralText(interaction, PREMIUM_MODULE_UNAVAILABLE_MESSAGE);
+            return false;
+        }
         if (!moduleEnabled) {
             await replyEphemeralText(interaction, requiredModuleName
                 ? `This command needs ${requiredModuleName}. Ask a server administrator to enable it in the Helyx dashboard.`
@@ -939,19 +954,22 @@ export async function authorizeCommand(interaction, moduleId, commandId, rateLim
     }
     return true;
 }
-async function authorizeAutocomplete(interaction, moduleId, commandId, services, selfAuthorizingGuildCommand, resourceScopedCommand, installationIndependentCommand = false, authorization) {
+async function authorizeAutocomplete(interaction, moduleId, commandId, services, selfAuthorizingGuildCommand, resourceScopedCommand, installationIndependentCommand = false, authorization, module) {
     const bypassPlatformAuthorization = authorization === "public" || authorization === "self-authorized";
     if (!installationIndependentCommand && !selfAuthorizingGuildCommand) {
         const installations = interaction.guildId
             ? services.get(HELYX_SERVICE_NAMES.installations)
             : undefined;
-        const [globallyAvailable, moduleEnabled] = await Promise.all([
+        const [globallyAvailable, moduleEnabled, premiumAccessible] = await Promise.all([
             moduleIsGloballyAvailable(services, moduleId),
             installations && !selfAuthorizingGuildCommand
                 ? installations.isModuleEnabled(interaction.guildId, moduleId)
                 : Promise.resolve(true),
+            interaction.guildId && module
+                ? canAccessModule(services, interaction.guildId, module)
+                : Promise.resolve(true),
         ]);
-        if (!globallyAvailable || !moduleEnabled)
+        if (!globallyAvailable || !moduleEnabled || !premiumAccessible)
             return false;
     }
     if (bypassPlatformAuthorization ||
@@ -1365,17 +1383,6 @@ async function sendFailure(interaction, error) {
         .reply({ content: message, flags: MessageFlags.Ephemeral })
         .catch(() => undefined);
 }
-function safeError(error) {
-    const value = error instanceof Error ? error : new Error(String(error));
-    return {
-        name: value.name,
-        message: value.message,
-        ...("code" in value &&
-            (typeof value.code === "string" || typeof value.code === "number")
-            ? { code: value.code }
-            : {}),
-    };
-}
 function interactionLogContext(interaction) {
     return {
         interactionId: interaction.id,

package/dist/module-logging.js

@@ -1,4 +1,5 @@
 import { InstallationRepository, ModuleConfigurationRepository, ModuleLoggingPolicyRepository, } from "@helyx/database";
+import { safeError } from "@helyx/core";
 import { toReplyOptions } from "./interactions.js";
 import { createHash } from "node:crypto";
 const LOGGING_MODULE_ID = "helyx.logging";
@@ -108,8 +109,4 @@ function normalizeText(value, maximum, label) {
     }
     return normalized;
 }
-function safeError(error) {
-    const value = error instanceof Error ? error : new Error(String(error));
-    return { name: value.name, message: value.message };
-}
 //# sourceMappingURL=module-logging.js.map

package/dist/module-status-control.js

@@ -13,7 +13,7 @@ export async function mutateDashboardModuleStatus(input) {
         input.services.has(HELYX_SERVICE_NAMES.numericWriteBehind)
         ? input.services.get(HELYX_SERVICE_NAMES.numericWriteBehind)
         : null;
-    if (writeBehind)
+    if (change.enabled)
         await input.requireModuleAvailable();
     let mutationResult;
     const setEnabled = async () => {

package/dist/premium-access.d.ts

@@ -0,0 +1,7 @@
+import { type ModuleDefinition, type ServiceAccess } from "@helyx/sdk";
+export declare const PREMIUM_MODULE_UNAVAILABLE_MESSAGE = "This Premium module is not assigned to this server. A Premium subscriber can assign a slot in Billing or with `/activate`.";
+export declare function moduleRequiresPremium(module: ModuleDefinition): boolean;
+export declare function requirePremiumProviderEnvironment(modules: readonly ModuleDefinition[], environment: "sandbox" | "live" | undefined): "sandbox" | "live" | undefined;
+export declare function canAccessModule(services: ServiceAccess, guildId: string, module: ModuleDefinition): Promise<boolean>;
+export declare function assertReviewedPremiumCatalogue(modules: readonly ModuleDefinition[]): void;
+//# sourceMappingURL=premium-access.d.ts.map

package/dist/premium-access.js

@@ -0,0 +1,38 @@
+import { getModuleTier, HELYX_PREMIUM_ENTITLEMENT_CAPABILITY, isReviewedPremiumModuleId, REVIEWED_PREMIUM_MODULE_IDS, } from "@helyx/module-manifest";
+import { HELYX_SERVICE_NAMES, } from "@helyx/sdk";
+export const PREMIUM_MODULE_UNAVAILABLE_MESSAGE = "This Premium module is not assigned to this server. A Premium subscriber can assign a slot in Billing or with `/activate`.";
+export function moduleRequiresPremium(module) {
+    return getModuleTier(module.manifest) === "premium";
+}
+export function requirePremiumProviderEnvironment(modules, environment) {
+    if (!modules.some(moduleRequiresPremium))
+        return undefined;
+    if (!environment)
+        throw new Error("STRIPE_ENVIRONMENT is required when a reviewed Premium module is loaded");
+    return environment;
+}
+export async function canAccessModule(services, guildId, module) {
+    if (!moduleRequiresPremium(module))
+        return true;
+    if (!isReviewedPremiumModuleId(module.manifest.id))
+        return false;
+    if (typeof services.has === "function" &&
+        !services.has(HELYX_SERVICE_NAMES.entitlements))
+        return false;
+    const entitlements = services.get(HELYX_SERVICE_NAMES.entitlements);
+    return entitlements.has(guildId, HELYX_PREMIUM_ENTITLEMENT_CAPABILITY);
+}
+export function assertReviewedPremiumCatalogue(modules) {
+    const byId = new Map(modules.map((module) => [module.manifest.id, module]));
+    for (const module of modules) {
+        if (moduleRequiresPremium(module) &&
+            !isReviewedPremiumModuleId(module.manifest.id))
+            throw new Error(`Premium module has not passed catalogue review: ${module.manifest.id}`);
+    }
+    for (const moduleId of REVIEWED_PREMIUM_MODULE_IDS) {
+        const module = byId.get(moduleId);
+        if (module && !moduleRequiresPremium(module))
+            throw new Error(`Reviewed Premium module is missing its Premium manifest tier: ${moduleId}`);
+    }
+}
+//# sourceMappingURL=premium-access.js.map

package/dist/premium-activation-module.d.ts

@@ -0,0 +1,20 @@
+import type { BillingEnvironment, PremiumAllocationRepository } from "@helyx/database";
+import { type ModuleDefinition } from "@helyx/sdk";
+type AllocationService = Pick<PremiumAllocationRepository, "getAccountAllocation" | "inspectTarget" | "assignLowestAvailable" | "moveSlot" | "releaseSlot" | "auditDenied">;
+export interface PremiumGuildAuthority {
+    canManageGuild(input: {
+        guildId: string;
+        userId: string;
+    }): Promise<boolean>;
+}
+export interface PremiumActivationModuleOptions {
+    allocations: AllocationService;
+    authority: PremiumGuildAuthority;
+    provider: string;
+    providerEnvironment: BillingEnvironment;
+    reviewedPremiumModuleIds: readonly string[];
+    now?: () => Date;
+}
+export declare function createPremiumActivationModule(options: PremiumActivationModuleOptions): ModuleDefinition;
+export {};
+//# sourceMappingURL=premium-activation-module.d.ts.map