import type { ModuleManifest, PrivacyDataDeclaration } from "@helyx/module-manifest";
import type { ActionReceipt, ChallengeCreateRequest, ChallengeCreateResponse, DashboardAttemptPage, DashboardAttemptQuery, DashboardSafeAttemptDetail, SignedAssessmentEnvelope, VerificationDiscordSnapshot, VerificationInstallationClaims } from "@helyx/verification-contracts";
export * from "./nexus-ledger.js";
export * from "./nexus-commands.js";
export * from "./shared-commands.js";
export * from "./nexus-core.js";
export * from "./nexus-bulk.js";
export * from "./nexus-rewards.js";
export * from "./nexus-economy.js";
export * from "./community-goal-progress.js";
export * from "./member-role-grants.js";
export * from "./creator-onboarding.js";
export * from "./zoned-date-time.js";
export * from "./feature-access.js";
export * from "./moderation.js";
export * from "./violation-threads.js";
export * from "./violation-thread-layout.js";
export * from "./auto-moderation.js";
import type { NexusCommandContribution } from "./nexus-commands.js";
import type { SharedCommandContribution } from "./shared-commands.js";
import type { CreatorOnboardingContribution } from "./creator-onboarding.js";
import type { AutoModerationCaseLinkProviderContributionV1, AutoModerationScannerProviderContributionV1, DiscordAutoModerationActionExecutionContribution, DiscordAutoModerationRuleCreateContribution, DiscordAutoModerationRuleDeleteContribution, DiscordAutoModerationRuleUpdateContribution } from "./auto-moderation.js";
import type { AutoModerationEnforcementPolicyProviderContributionV1, ModerationActionProviderContributionV2 } from "./moderation.js";
export interface Logger {
    debug(fields: Record<string, unknown>, message: string): void;
    info(fields: Record<string, unknown>, message: string): void;
    warn(fields: Record<string, unknown>, message: string): void;
    error(fields: Record<string, unknown>, message: string): void;
    child(bindings: Record<string, unknown>): Logger;
}
export interface ServiceAccess {
    get<T>(name: string): T;
    has(name: string): boolean;
}
export interface RuntimeContext {
    logger: Logger;
    services: ServiceAccess;
    signal: AbortSignal;
}
export interface HealthResult {
    status: "healthy" | "degraded" | "unhealthy";
    message?: string;
}
export interface PermissionPolicy {
    everyone: boolean;
    accessLevel?: HelyxAccessLevel;
    requiredPermissions: readonly string[];
    allowedRoleIds: readonly string[];
    deniedRoleIds: readonly string[];
    allowedUserIds: readonly string[];
    deniedUserIds: readonly string[];
}
export type HelyxAccessLevel = "administrator" | "moderator";
export interface GuildAccessPolicy {
    administratorRoleIds: readonly string[];
    moderatorRoleIds: readonly string[];
    dashboardModeratorsEnabled: boolean;
    dashboardAllowedRoleIds: readonly string[];
    dashboardDeniedRoleIds: readonly string[];
}
export declare const DEFAULT_GUILD_ACCESS_POLICY: GuildAccessPolicy;
export interface VersionedGuildAccessPolicy extends GuildAccessPolicy {
    guildId: string;
    version: bigint;
    updatedBy: string | null;
    updatedAt: Date;
}
export interface PermissionActor {
    userId: string;
    roleIds: readonly string[];
    permissions: readonly string[];
    isServerOwner: boolean;
    isAdministrator: boolean;
    highestRolePosition?: number;
}
export interface ModulePermissionConfiguration {
    module: PermissionPolicy;
    commands: Readonly<Record<string, PermissionPolicy>>;
}
export declare const HELYX_SERVICE_NAMES: {
    readonly applicationUrls: "helyx.application-urls";
    readonly audit: "helyx.audit";
    readonly cacheInvalidation: "helyx.cache-invalidation";
    readonly configuration: "helyx.configuration";
    readonly featureAccess: "helyx.feature-access";
    readonly discordAutoModeration: "helyx.discord-auto-moderation";
    readonly discordMessages: "helyx.discord-messages";
    readonly discordOwnedMessages: "helyx.discord-owned-messages";
    readonly discordResources: "helyx.discord-resources";
    readonly discordGuildHealth: "helyx.discord-guild-health";
    readonly discordAnalytics: "helyx.discord-analytics";
    readonly discordInvites: "helyx.discord-invites";
    readonly creatorInvites: "helyx.creator-invites";
    readonly creatorGuildJoin: "helyx.creator-guild-join";
    readonly inviteAttributions: "helyx.invite-attributions";
    readonly entitlements: "helyx.entitlements";
    readonly memberContributions: "helyx.member-contributions";
    readonly achievementContributions: "helyx.achievement-contributions";
    readonly gamingEvents: "helyx.gaming-events";
    readonly gamingStatistics: "helyx.gaming-statistics";
    readonly installations: "helyx.installations";
    readonly memberEnforcement: "helyx.member-enforcement";
    readonly messageEnforcement: "helyx.message-enforcement";
    readonly violationThreads: "helyx.violation-threads";
    readonly atomicModerationCases: "helyx.atomic-moderation-cases";
    readonly moderationCasePrivacy: "helyx.moderation-case-privacy";
    readonly moderationActions: "helyx.moderation-actions";
    readonly automodScannerProvider: "helyx.automod-scanner-provider";
    readonly automodScannerObservations: "helyx.automod-scanner-observations";
    readonly verificationMembers: "helyx.verification-members";
    readonly memberRoles: "helyx.member-roles";
    readonly memberRoleGrants: "helyx.member-role-grants";
    readonly messageBuilder: "helyx.message-builder";
    readonly recurrence: "helyx.recurrence";
    readonly zonedDateTime: "helyx.zoned-date-time";
    readonly moduleCatalogue: "helyx.module-catalogue";
    readonly moduleAvailability: "helyx.module-availability";
    readonly moduleLogging: "helyx.module-logging";
    readonly numericWriteBehind: "helyx.numeric-write-behind";
    readonly nexusLedger: "helyx.nexus-ledger";
    readonly nexusCore: "helyx.nexus-core-service";
    readonly nexusBulk: "helyx.nexus-bulk";
    readonly nexusPrivacy: "helyx.nexus-privacy";
    readonly nexusRewards: "helyx.nexus-rewards-service";
    readonly nexusEconomy: "helyx.nexus-economy-service";
    readonly oauth: "helyx.oauth";
    readonly permissions: "helyx.permissions";
    readonly privacy: "helyx.privacy";
    readonly rateLimits: "helyx.rate-limits";
    readonly records: "helyx.records";
    readonly communityGoalProgress: "helyx.community-goal-progress";
    readonly recordRetention: "helyx.record-retention";
    readonly resourceAuthorization: "helyx.resource-authorization";
    readonly scheduledTasks: "helyx.scheduled-tasks";
    readonly schedulableActions: "helyx.schedulable-actions";
    readonly secureRandom: "helyx.secure-random";
    readonly sessions: "helyx.sessions";
    readonly subscriptions: "helyx.subscriptions";
    readonly triviaQuestions: "helyx.trivia-questions";
    readonly verification: "helyx.verification-service";
};
export interface ApplicationUrlService {
    dashboardBaseUrl: string;
    /** Current Cloud Connect installation; absent for hosted or unpaired runtimes. */
    readonly dashboardInstallationId?: string | undefined;
}
export declare const TRIVIA_CATEGORIES: readonly ["music", "sport_and_leisure", "film_and_tv", "arts_and_literature", "history", "society_and_culture", "science", "geography", "food_and_drink", "general_knowledge", "board_games", "mathematics", "mythology", "video_games", "technology", "anime_and_manga", "animals", "vehicles"];
export type TriviaCategory = (typeof TRIVIA_CATEGORIES)[number];
export type TriviaDifficulty = "easy" | "medium" | "hard";
export type TriviaQuestionType = "text_choice" | "text_input" | "true_false";
export interface TriviaQuestion {
    category: TriviaCategory;
    id: string;
    tags: readonly string[];
    difficulty: TriviaDifficulty;
    regions: readonly string[];
    isNiche: boolean;
    question: {
        readonly text: string;
    };
    correctAnswer: string;
    incorrectAnswers: readonly string[];
    type: TriviaQuestionType;
}
export type TriviaProviderFailureCode = "authentication" | "subscription" | "rate_limited" | "timeout" | "unavailable" | "invalid_response";
export declare class TriviaProviderError extends Error {
    readonly code: TriviaProviderFailureCode;
    constructor(code: TriviaProviderFailureCode);
}
export interface TriviaQuestionProvider {
    getQuestions(input: {
        category?: TriviaCategory;
        difficulty?: TriviaDifficulty;
        isNiche?: boolean;
        type: "text_choice" | "true_false";
        limit: number;
    }): Promise<readonly TriviaQuestion[]>;
    health(): Promise<{
        status: "healthy" | "degraded" | "unavailable";
        safeCode?: TriviaProviderFailureCode;
    }>;
}
export interface MemberContributionEvent {
    /** Durable delivery identity supplied by the platform to subscribers. */
    deliveryId?: string;
    guildId: string;
    memberId: string;
    sourceModuleId: string;
    eventId: string;
    amount: number;
    occurredAt: Date;
    idempotencyKey: string;
}
export interface MemberContributionService {
    emit(event: MemberContributionEvent): Promise<void>;
    subscribe(handler: (event: MemberContributionEvent) => void | Promise<void>): () => void;
}
export interface ModuleCatalogueService {
    get(moduleId: string): ModuleManifest | null;
}
/** @deprecated Use MemberContributionEvent. */
export type AchievementContributionEvent = MemberContributionEvent;
/** @deprecated Use MemberContributionService. */
export type AchievementContributionService = MemberContributionService;
/** @deprecated Use MemberContributionEvent. */
export type GamingAchievementEvent = MemberContributionEvent;
/** @deprecated Use MemberContributionService. */
export type GamingAchievementEventService = MemberContributionService;
export interface GamingStatisticIncrement {
    statKey: string;
    periodKey?: string;
    amount: number;
}
export interface GamingStatisticValue {
    guildId: string;
    memberId: string;
    sourceModuleId: string;
    statKey: string;
    periodKey: string;
    total: number;
    updatedAt: Date;
}
export interface GamingStatisticsService {
    record(input: {
        guildId: string;
        memberId: string;
        sourceModuleId: string;
        idempotencyKey: string;
        occurredAt: Date;
        increments: readonly GamingStatisticIncrement[];
    }): Promise<{
        replayed: boolean;
        values: readonly GamingStatisticValue[];
    }>;
    listMember(input: {
        guildId: string;
        memberId: string;
        sourceModuleId?: string;
        statKey?: string;
        periodKey?: string;
    }): Promise<readonly GamingStatisticValue[]>;
}
export interface VerificationResultContext {
    envelope: SignedAssessmentEnvelope;
    correlationId: string;
}
export declare class VerificationChallengeActiveError extends Error {
    readonly expiresAt: string;
    constructor(expiresAt: string);
}
export interface VerificationService {
    getInstallationContext(input: {
        guildId: string;
    }): Promise<{
        installation: VerificationInstallationClaims;
    }>;
    createChallenge(input: ChallengeCreateRequest): Promise<ChallengeCreateResponse>;
    cancelChallenges(input: {
        installationId: string;
        guildId: string;
        userId?: string;
    }): Promise<{
        cancelled: number;
    }>;
    listAttempts(input: DashboardAttemptQuery & {
        installationId: string;
        guildId: string;
    }): Promise<DashboardAttemptPage>;
    getAttempt(input: {
        installationId: string;
        guildId: string;
        attemptId: string;
    }): Promise<DashboardSafeAttemptDetail | null>;
    decideAttempt(input: {
        installationId: string;
        guildId: string;
        attemptId: string;
        expectedVersion: number;
        actorUserId: string;
        decision: "approve" | "deny" | "retry" | "reset" | "dismiss_relationship";
        reason: string;
    }): Promise<DashboardSafeAttemptDetail>;
    registerResultHandler(handler: (context: VerificationResultContext) => Promise<ActionReceipt>): () => void;
    acceptResult(envelope: SignedAssessmentEnvelope): Promise<ActionReceipt>;
    health(): Promise<{
        status: "healthy" | "degraded" | "unavailable";
        provider: "available" | "degraded" | "unavailable";
        allowanceRemaining?: number;
    }>;
}
export interface VerificationMemberService {
    captureSnapshot(input: {
        guildId: string;
        userId: string;
        verifiedRoleId: string;
        sourceClassification: VerificationDiscordSnapshot["sourceClassification"];
    }): Promise<VerificationDiscordSnapshot>;
    isCurrentlyBanned(input: {
        guildId: string;
        userId: string;
    }): Promise<boolean>;
}
export interface SecureRandomReceipt {
    algorithmVersion: string;
    operationReference: string;
    entropyDigest: string;
}
export interface SecureWeightedSelectionCheckpoint {
    algorithmVersion: string;
    operationReference: string;
    operationContextDigest: string;
    winnerCount: number;
    lastCandidateId: string | null;
    consideredCandidateCount: number;
    consideredTotalWeight: number;
    auditDigest: string;
    integrityDigest: string;
    reservoir: readonly {
        candidateId: string;
        weight: number;
    }[];
}
export interface SecureWeightedSelection {
    consider(candidate: {
        candidateId: string;
        weight: number;
    }): void;
    checkpoint(): SecureWeightedSelectionCheckpoint;
    finish(): SecureRandomReceipt & {
        selectedCandidateIds: readonly string[];
        consideredCandidateCount: number;
        consideredTotalWeight: number;
    };
}
export interface SecureRandomService {
    /** Creates a short-lived opaque capability identifier for a named workflow. */
    opaqueToken?(input: {
        bytes: number;
        purpose: string;
    }): string;
    boundedInteger(input: {
        maximumExclusive: number;
        operationContext: string;
    }): SecureRandomReceipt & {
        value: number;
    };
    createWeightedSelection(input: {
        winnerCount: number;
        operationContext: string;
        checkpoint?: SecureWeightedSelectionCheckpoint;
    }): SecureWeightedSelection;
}
export interface ResourceAuthorizationService {
    canUse(input: {
        guildId: string;
        moduleId: string;
        permissionId: string;
        actor: PermissionActor;
    }): Promise<boolean>;
}
export interface DiscordOwnedMessageService {
    /** Optional readiness signal; unavailable Discord work must not consume a cleanup attempt. */
    isReady?(): boolean;
    editOwnedMessage(input: {
        guildId: string;
        channelId: string;
        messageId: string;
        response: MessageResponse;
    }): Promise<{
        edited: boolean;
    }>;
    deleteOwnedMessage(input: {
        guildId: string;
        channelId: string;
        messageId: string;
    }): Promise<{
        deleted: boolean;
    }>;
    addOwnedMessageReaction(input: {
        guildId: string;
        channelId: string;
        messageId: string;
        emojiIdentifier: string;
    }): Promise<{
        added: boolean;
    }>;
    clearOwnedMessageReaction(input: {
        guildId: string;
        channelId: string;
        messageId: string;
        emojiIdentifier: string;
    }): Promise<{
        cleared: boolean;
    }>;
}
export interface DiscordMessageService {
    send(input: {
        guildId: string;
        channelId: string;
        response: MessageResponse;
        idempotencyKey?: string;
    }): Promise<{
        messageId: string;
    }>;
    sendDirect(input: {
        userId: string;
        response: MessageResponse;
    }): Promise<{
        outcome: "sent";
        messageId: string;
    } | {
        outcome: "closed" | "failed";
    }>;
    fetchSource(input: {
        guildId: string;
        channelId: string;
        messageId: string;
    }): Promise<DiscordSourceMessageSnapshot | null>;
}
export interface MemberRoleService {
    createApprovedRole(input: {
        guildId: string;
        name: string;
        moduleId: string;
        reason: string;
    }): Promise<{
        roleId: string;
        name: string;
    }>;
    getCurrentRoleIds(input: {
        guildId: string;
        memberUserId: string;
    }): Promise<readonly string[]>;
    addApprovedRole(input: {
        guildId: string;
        memberUserId: string;
        roleId: string;
        moduleId: string;
        reason: string;
    }): Promise<{
        changed: boolean;
    }>;
    removeApprovedRole(input: {
        guildId: string;
        memberUserId: string;
        roleId: string;
        moduleId: string;
        reason: string;
    }): Promise<{
        changed: boolean;
    }>;
    reconcileApprovedRoles(input: {
        guildId: string;
        memberUserId: string;
        allowedRoleIds: readonly string[];
        desiredRoleIds: readonly string[];
        moduleId: string;
        reason: string;
    }): Promise<{
        added: readonly string[];
        removed: readonly string[];
    }>;
}
export type MemberEnforcementOutcome = "kicked" | "banned" | "no_longer_required" | "member_missing" | "missing_permission" | "hierarchy_blocked" | "failed";
export type DirectMessageOutcome = "sent" | "closed" | "failed" | "not_requested";
export interface MemberEnforcementService {
    kick(input: {
        guildId: string;
        memberUserId: string;
        moduleId: string;
        reason: string;
        directMessage?: MessageResponse;
        revalidate(): Promise<boolean>;
    }): Promise<{
        outcome: MemberEnforcementOutcome;
        directMessage: DirectMessageOutcome;
    }>;
    ban(input: {
        guildId: string;
        memberUserId: string;
        moduleId: string;
        reason: string;
        directMessage?: MessageResponse;
        revalidate(): Promise<boolean>;
    }): Promise<{
        outcome: MemberEnforcementOutcome;
        directMessage: DirectMessageOutcome;
    }>;
}
export interface DiscordRoleInspection {
    guildId: string;
    roleId: string;
    exists: boolean;
    guildMatches: boolean;
    name?: string;
    managed: boolean;
    everyone: boolean;
    assignable: boolean;
    actorAssignable: boolean;
    hierarchy: "assignable" | "missing" | "guild-mismatch" | "everyone" | "managed" | "missing-manage-roles" | "above-helyx" | "above-actor";
    permissionNames: readonly string[];
    dangerousPermissionNames: readonly string[];
    helyxHighestRoleId?: string;
}
export interface DiscordEmojiInspection {
    guildId: string;
    emojiIdentifier: string;
    exists: boolean;
    guildMatches: boolean;
    usable: boolean;
    kind: "unicode" | "custom";
    canonicalEmojiKey?: string;
    emojiId?: string;
    name?: string;
}
export interface DiscordChannelInspection {
    guildId: string;
    channelId: string;
    exists: boolean;
    guildMatches: boolean;
    name?: string;
    type: "guild_text" | "guild_announcement" | "other" | "missing";
    effectivePermissionNames: readonly string[];
    viewable: boolean;
    sendMessages: boolean;
    addReactions: boolean;
    readMessageHistory: boolean;
    manageMessages: boolean;
    ageRestricted: boolean;
}
export interface DiscordMessageInspection {
    guildId: string;
    channelId: string;
    messageId: string;
    exists: boolean;
    guildMatches: boolean;
    channelMatches: boolean;
    authorUserId?: string;
}
export interface DiscordRuntimeCapabilities {
    guildMembers: boolean;
    guildMessages: boolean;
    guildMessageReactions: boolean;
    messageContent: boolean;
}
export interface DiscordGuildCapabilityInspection {
    guildId: string;
    effectivePermissionNames: readonly string[];
    manageRoles: boolean;
    kickMembers: boolean;
}
export interface DiscordChannelAudienceInspection {
    guildId: string;
    channelId: string;
    exists: boolean;
    guildMatches: boolean;
    everyoneCanView: boolean;
    roles: readonly {
        roleId: string;
        exists: boolean;
        canView: boolean;
    }[];
}
export interface DiscordGuildChannelAudienceInspection {
    guildId: string;
    channels: readonly {
        channelId: string;
        type: "guild_text" | "guild_announcement";
        everyoneCanView: boolean;
        visibleRoleIds: readonly string[];
    }[];
    missingRoleIds: readonly string[];
    truncated: boolean;
}
import type { ChannelAuditModuleId, ChannelAuditInput, ChannelAuditReport } from "./channel-audit.js";
export * from "./channel-audit.js";
export interface DiscordResourceInspectionService {
    inspectChannelAudit?(input: {
        guildId: string;
        moduleId: ChannelAuditModuleId;
        assumptions: ChannelAuditInput;
    }): Promise<ChannelAuditReport>;
    inspectGuildCapabilities(input: {
        guildId: string;
    }): Promise<DiscordGuildCapabilityInspection>;
    inspectRole(input: {
        guildId: string;
        roleId: string;
        actorUserId?: string;
    }): Promise<DiscordRoleInspection>;
    inspectEmoji(input: {
        guildId: string;
        emojiIdentifier: string;
    }): Promise<DiscordEmojiInspection>;
    inspectChannel(input: {
        guildId: string;
        channelId: string;
    }): Promise<DiscordChannelInspection>;
    inspectMessage(input: {
        guildId: string;
        channelId: string;
        messageId: string;
    }): Promise<DiscordMessageInspection>;
    inspectChannelAudience(input: {
        guildId: string;
        channelId: string;
        roleIds: readonly string[];
    }): Promise<DiscordChannelAudienceInspection>;
    inspectGuildChannelAudience(input: {
        guildId: string;
        roleIds: readonly string[];
    }): Promise<DiscordGuildChannelAudienceInspection>;
    seedMessageReaction(input: {
        guildId: string;
        channelId: string;
        messageId: string;
        emojiIdentifier: string;
    }): Promise<{
        added: boolean;
    }>;
    inspectRuntimeCapabilities(): Promise<DiscordRuntimeCapabilities>;
    resolveMembers(input: {
        guildId: string;
        userIds: readonly string[];
    }): Promise<readonly {
        userId: string;
        displayName: string | null;
        avatarUrl?: string;
    }[]>;
    searchMembers(input: {
        guildId: string;
        query: string;
        limit: number;
    }): Promise<readonly {
        userId: string;
        displayName: string;
        avatarUrl?: string;
        isBot: boolean;
    }[]>;
    listMembers(input: {
        guildId: string;
        after?: string;
        limit: number;
    }): Promise<{
        items: readonly {
            userId: string;
            displayName: string;
            avatarUrl?: string;
            isBot: boolean;
        }[];
        nextCursor?: string;
    }>;
    resolveMemberSnapshots(input: {
        guildId: string;
        userIds: readonly string[];
    }): Promise<readonly {
        userId: string;
        exists: boolean;
        isBot: boolean;
        roleIds: readonly string[];
        joinedAt: Date | null;
    }[]>;
}
export declare const OAUTH_PROVIDERS: readonly ["youtube", "twitch"];
export type OAuthProvider = (typeof OAUTH_PROVIDERS)[number];
/**
 * Hosted credential purposes are deliberately closed. Adding a purpose is a
 * security-boundary change, not a free-form module setting.
 */
export declare const OAUTH_CONNECTION_PURPOSES: readonly ["creator"];
export type OAuthConnectionPurpose = (typeof OAUTH_CONNECTION_PURPOSES)[number];
export declare const OAUTH_MAX_ACCOUNT_SLOTS: 3;
export type OAuthAccountSlot = 1 | 2 | 3;
export interface OAuthConnectionIdentity {
    provider: OAuthProvider;
    purpose: OAuthConnectionPurpose;
    accountSlot: OAuthAccountSlot;
}
export interface OAuthConnectionSummary extends OAuthConnectionIdentity {
    selectionRef: string;
    displayName: string;
    connectedAt: string;
}
export interface OAuthAuthorizationContext {
    version: 1;
    consumer: {
        moduleId: string;
        guildId: string;
        resourceType: string;
        resourceId: string;
    };
    connection: {
        purpose: OAuthConnectionPurpose;
        accountSlot: OAuthAccountSlot;
    };
    request: {
        kind: "eligibility";
        requirement: "subscribed" | "following" | "both";
    };
}
export interface OAuthEligibilityResult {
    provider: OAuthProvider;
    status: "eligible" | "ineligible" | "unknown";
    connected: boolean;
    following?: boolean;
    subscribed?: boolean;
    checkedAt: string;
    safeCode?: string;
}
export interface OAuthConsumerCleanupContext {
    consumerBindingId: string;
    provider: OAuthProvider;
    guildId: string;
    resourceType: string;
    resourceId: string;
    subjectUserId: string;
    correlationId: string;
    services: ServiceAccess;
}
export interface OAuthConsumerCleanupResult {
    invalidatedBindings: number;
    invalidatedVerifications: number;
    deactivatedRoleSources: number;
    removedRoles: number;
    warnings: number;
}
export interface OAuthConsumerCleanupContribution {
    provider: OAuthProvider;
    resourceType: string;
    version: number;
    ownsDiscordRoles: boolean;
    ownsScheduledWork: boolean;
    cleanup(context: OAuthConsumerCleanupContext): Promise<OAuthConsumerCleanupResult>;
}
/**
 * Safe OAuth boundary exposed to modules. Implementations must never return
 * access tokens, refresh tokens, client secrets, or decrypted credentials.
 */
export interface OAuthService {
    resolveCreatorIdentity?(input: {
        provider: "twitch";
        login: string;
    }): Promise<{
        userId: string;
        login: string;
    }>;
    connectionStatus(input: {
        discordUserId: string;
        purpose?: OAuthConnectionPurpose;
    }): Promise<readonly OAuthConnectionIdentity[]>;
    listConnections(input: {
        discordUserId: string;
    }): Promise<readonly OAuthConnectionSummary[]>;
    createAuthorization(input: {
        discordUserId: string;
        provider: OAuthProvider;
        purpose: OAuthConnectionPurpose;
        accountSlot: OAuthAccountSlot;
        context?: OAuthAuthorizationContext;
    }): Promise<{
        authorizationUrl: string;
        expiresAt: string;
    }>;
    verifyEligibility(input: {
        discordUserId: string;
        provider: OAuthProvider;
        purpose: OAuthConnectionPurpose;
        accountSlot: OAuthAccountSlot;
        targetChannelId: string;
        requirement: "subscribed" | "following" | "both";
        context?: OAuthAuthorizationContext;
    }): Promise<OAuthEligibilityResult>;
    revoke(input: {
        discordUserId: string;
        selectionRef: string;
        confirmation: "remove_access";
        comment?: string;
        correlationId: string;
    }): Promise<{
        provider: OAuthProvider;
        outcome: "completed" | "already_revoked" | "processing" | "cleanup_pending";
        providerRevocation: "completed" | "failed" | "not_supported";
    }>;
}
export type DiscordInviteUnavailableCode = "missing_permission" | "missing_intent" | "discord_unavailable" | "continuity_lost" | "not_supported";
export interface DiscordInviteUnavailable {
    available: false;
    code: DiscordInviteUnavailableCode;
}
export interface DiscordInviteSnapshotItem {
    /** Guild-scoped opaque fingerprint. The raw invite code never crosses this boundary. */
    sourceKey: string;
    channelId: string | null;
    inviterUserId: string | null;
    createdAt: Date | null;
    expiresAt: Date | null;
    maxUses: number;
    uses: number;
    temporary: boolean;
}
export interface DiscordInviteSnapshot {
    available: true;
    observedAt: Date;
    continuityGeneration: string;
    invites: readonly DiscordInviteSnapshotItem[];
    vanity: {
        sourceKey: string;
        uses: number;
    } | null;
}
/**
 * Guild-owner-routed invite inspection. Implementations fingerprint invite
 * codes before returning and must never expose a raw code or Discord object.
 */
export interface DiscordInviteInspectionService {
    captureSnapshot(input: {
        guildId: string;
    }): Promise<DiscordInviteSnapshot | DiscordInviteUnavailable>;
    fingerprintCode(input: {
        guildId: string;
        code: string;
    }): Promise<{
        sourceKey: string;
    }>;
    continuityGeneration(input: {
        guildId: string;
    }): string;
    invalidateContinuity(input: {
        guildId: string;
        reason: "event_queue_gap" | "gateway_session_gap" | "ownership_gap";
    }): void;
}
export type DiscordAnalyticsUnavailableCode = "missing_permission" | "missing_intent" | "discord_unavailable" | "not_supported";
export interface DiscordAnalyticsUnavailable {
    available: false;
    code: DiscordAnalyticsUnavailableCode;
}
export type DiscordAnalyticsChannelType = "category" | "text" | "announcement" | "forum" | "media";
export interface DiscordAnalyticsChannelFact {
    channelId: string;
    type: DiscordAnalyticsChannelType;
    parentId: string | null;
    botCanView: boolean;
    botCanReadHistory: boolean;
    selectedRoleCanView: boolean | null;
    selectedRoleCanWrite: boolean | null;
}
export interface DiscordAnalyticsMessageFact {
    messageId: string;
    createdAt: Date;
    authorUserId: string | null;
    authorIsBot: boolean;
    webhook: boolean;
    system: boolean;
    currentRoleIds: readonly string[] | null;
}
export interface DiscordAnalyticsMemberFact {
    userId: string;
    joinedAt: Date | null;
    accountCreatedAt: Date;
    isBot: boolean;
    roleIds: readonly string[];
}
export interface DiscordAnalyticsThreadFact {
    threadId: string;
    parentChannelId: string;
    type: "public" | "private" | "announcement";
    ownerUserId: string | null;
    createdAt: Date;
    lastActivityAt: Date | null;
    archived: boolean;
    locked: boolean;
    messageCount: number;
    totalMessageSent: number;
    appliedTagIds: readonly string[];
    botCanView: boolean;
    botCanReadHistory: boolean;
}
/** Metadata-only Discord reads for bounded, on-demand Analytics reports. */
export interface DiscordAnalyticsInspectionService {
    listChannels(input: {
        guildId: string;
        roleId?: string;
    }): Promise<{
        available: true;
        items: readonly DiscordAnalyticsChannelFact[];
    } | DiscordAnalyticsUnavailable>;
    listMessages(input: {
        guildId: string;
        channelId: string;
        before?: string;
        limit: number;
    }): Promise<{
        available: true;
        items: readonly DiscordAnalyticsMessageFact[];
        nextBefore?: string;
    } | DiscordAnalyticsUnavailable>;
    listMembers(input: {
        guildId: string;
        after?: string;
        limit: number;
    }): Promise<{
        available: true;
        items: readonly DiscordAnalyticsMemberFact[];
        nextAfter?: string;
    } | DiscordAnalyticsUnavailable>;
    listThreads(input: {
        guildId: string;
        parentChannelId?: string;
        cursor?: string;
        limit: number;
        includeArchived: boolean;
        includePrivate: boolean;
        signal?: AbortSignal;
    }): Promise<{
        available: true;
        items: readonly DiscordAnalyticsThreadFact[];
        nextCursor?: string;
        privateCoverage: "all" | "joined_only" | "none";
    } | DiscordAnalyticsUnavailable>;
}
export type InviteAttributionClassification = "confirmed" | "ambiguous" | "vanity_or_other" | "unknown";
/**
 * Core-owned, bounded bridge for optional Analytics enrichment. It exposes no
 * raw invite code or module record and is present only when Invite Tracking is
 * loaded.
 */
export interface InviteAttributionReadService {
    matchMemberJoins(input: {
        guildId: string;
        members: readonly {
            userId: string;
            joinedAt: Date;
        }[];
    }): Promise<readonly {
        userId: string;
        joinedAt: Date;
        classification: InviteAttributionClassification;
        sourceReference: string | null;
    }[]>;
}
export type DiscordGuildHealthUnavailableCode = "missing_permission" | "missing_intent" | "discord_unavailable" | "not_supported";
export interface DiscordGuildHealthUnavailable {
    available: false;
    code: DiscordGuildHealthUnavailableCode;
}
export interface DiscordGuildHealthOverview {
    available: true;
    guildId: string;
    name: string;
    ownerId: string;
    createdAt: Date;
    memberCount: number;
    verificationLevel: string;
    explicitContentFilter: string;
    defaultMessageNotifications: string;
    mfaLevel: string;
    premiumTier: number;
    features: readonly string[];
    botPermissions: readonly string[];
    channelCount: number;
    roleCount: number;
    emojiCount: number;
    stickerCount: number;
    rulesChannelId: string | null;
    publicUpdatesChannelId: string | null;
    safetyAlertsChannelId: string | null;
    invitesDisabledUntil: Date | null;
    dmsDisabledUntil: Date | null;
    botHighestRolePosition: number;
}
export interface DiscordGuildHealthChannel {
    channelId: string;
    name: string;
    type: string;
    parentId: string | null;
    ageRestricted: boolean;
    everyonePermissions: readonly string[];
    botPermissions: readonly string[];
    permissionsLocked: boolean | null;
}
export interface DiscordGuildHealthRole {
    roleId: string;
    name: string;
    position: number;
    managed: boolean;
    memberCount: number;
    permissions: readonly string[];
}
export interface DiscordGuildHealthMember {
    userId: string;
    bot: boolean;
    system: boolean;
    createdAt: Date;
    joinedAt: Date | null;
    timedOutUntil: Date | null;
    publicFlags: readonly string[];
    roleIds: readonly string[];
}
export interface DiscordGuildHealthMemberPage {
    available: true;
    items: readonly DiscordGuildHealthMember[];
    nextAfter?: string;
}
export interface DiscordGuildHealthInvite {
    code: string;
    channelId: string | null;
    channelName: string | null;
    channelExists: boolean;
    inviterUserId: string | null;
    createdAt: Date | null;
    expiresAt: Date | null;
    maxUses: number;
    uses: number;
    temporary: boolean;
}
export interface DiscordGuildHealthIntegration {
    integrationId: string;
    name: string;
    type: string;
    enabled: boolean;
    syncing: boolean | null;
    roleId: string | null;
    roleExists: boolean;
}
export interface DiscordGuildHealthWebhook {
    webhookId: string;
    name: string | null;
    channelId: string | null;
    ownerUserId: string | null;
    applicationId: string | null;
    channelName: string | null;
}
export interface DiscordGuildHealthAuditSummary {
    available: true;
    inspected: number;
    highImpactActionsLastHour: number;
}
export interface DiscordGuildHealthModuleState {
    moduleId: string;
    name: string;
    version: string;
    enabled: boolean;
    configured: boolean;
    configurationValid: boolean;
    resourceValidationValid: boolean | null;
    activationValid: boolean | null;
    catalogueMatches: boolean;
    requiredCapabilities: readonly ("guild-members" | "message-content")[];
    missingCapabilities: readonly ("guild-members" | "message-content")[];
    missingPermissions: readonly string[];
    healthStatus: "healthy" | "degraded" | "unhealthy" | "unavailable";
    healthMessage: string | null;
    diagnosticsAvailable: boolean;
}
export interface DiscordGuildHealthAutoModerationRule {
    ruleId: string;
    name: string;
    enabled: boolean;
    triggerType: string;
    eventType: string;
    actionCount: number;
}
export interface DiscordGuildHealthInspectionService {
    inspectOverview(input: {
        guildId: string;
    }): Promise<DiscordGuildHealthOverview | DiscordGuildHealthUnavailable>;
    listChannels(input: {
        guildId: string;
    }): Promise<{
        available: true;
        items: readonly DiscordGuildHealthChannel[];
    } | DiscordGuildHealthUnavailable>;
    listRoles(input: {
        guildId: string;
    }): Promise<{
        available: true;
        items: readonly DiscordGuildHealthRole[];
    } | DiscordGuildHealthUnavailable>;
    listMembers(input: {
        guildId: string;
        after?: string;
        limit: number;
    }): Promise<DiscordGuildHealthMemberPage | DiscordGuildHealthUnavailable>;
    listInvites(input: {
        guildId: string;
    }): Promise<{
        available: true;
        items: readonly DiscordGuildHealthInvite[];
    } | DiscordGuildHealthUnavailable>;
    listIntegrations(input: {
        guildId: string;
    }): Promise<{
        available: true;
        items: readonly DiscordGuildHealthIntegration[];
    } | DiscordGuildHealthUnavailable>;
    listWebhooks(input: {
        guildId: string;
    }): Promise<{
        available: true;
        items: readonly DiscordGuildHealthWebhook[];
    } | DiscordGuildHealthUnavailable>;
    listAutoModerationRules(input: {
        guildId: string;
    }): Promise<{
        available: true;
        items: readonly DiscordGuildHealthAutoModerationRule[];
    } | DiscordGuildHealthUnavailable>;
    inspectAuditSummary(input: {
        guildId: string;
    }): Promise<DiscordGuildHealthAuditSummary | DiscordGuildHealthUnavailable>;
    inspectHelyxModules(input: {
        guildId: string;
        batchSize?: number;
    }): Promise<{
        available: true;
        items: readonly DiscordGuildHealthModuleState[];
    } | DiscordGuildHealthUnavailable>;
}
export interface ModuleLogDetail {
    label: string;
    value: string;
}
export interface ModuleLoggingService {
    emit(input: {
        guildId: string;
        moduleId: string;
        eventId: string;
        summary: string;
        details?: readonly ModuleLogDetail[];
        idempotencyKey?: string;
    }): Promise<{
        delivered: boolean;
        retryable?: boolean;
    }>;
}
export interface VersionedModuleConfiguration {
    guildId: string;
    moduleId: string;
    value: Record<string, unknown>;
    schemaVersion: number;
    version: bigint;
}
export interface ConfigurationMutationContext {
    actorUserId: string;
    correlationId: string;
    source: "discord" | "dashboard" | "control" | "system";
}
export interface ModuleConfigurationService {
    get(guildId: string, moduleId: string): Promise<VersionedModuleConfiguration | null>;
    getMany?(guildId: string, moduleIds: readonly string[]): Promise<readonly VersionedModuleConfiguration[]>;
    update(input: {
        guildId: string;
        moduleId: string;
        value: unknown;
        expectedVersion: bigint | null;
        context: ConfigurationMutationContext;
    }): Promise<VersionedModuleConfiguration>;
}
export interface PermissionPolicyService {
    getGuildAccessPolicy?(guildId: string): Promise<GuildAccessPolicy>;
    getPolicy(guildId: string, moduleId: string, commandId?: string): Promise<{
        policy: PermissionPolicy;
        version: bigint | null;
        inherited: boolean;
    }>;
    getPolicies?(guildId: string, targets: readonly {
        moduleId: string;
        commandId?: string;
    }[]): Promise<readonly {
        moduleId: string;
        commandId?: string;
        policy: PermissionPolicy;
        version: bigint | null;
        inherited: boolean;
    }[]>;
    getEffectivePolicy(guildId: string, moduleId: string, commandId: string): Promise<PermissionPolicy>;
    setPolicy(input: {
        guildId: string;
        moduleId: string;
        commandId?: string;
        policy: PermissionPolicy;
        expectedVersion: bigint | null;
        context: ConfigurationMutationContext;
    }): Promise<{
        policy: PermissionPolicy;
        version: bigint;
    }>;
    clearPolicy(input: {
        guildId: string;
        moduleId: string;
        commandId?: string;
        expectedVersion: bigint;
        context: ConfigurationMutationContext;
    }): Promise<boolean>;
}
export interface InteractionSessionService {
    create(input: {
        guildId: string;
        userId: string;
        purpose: string;
        state: Record<string, unknown>;
        expiresAt: Date;
        replace?: boolean;
    }): Promise<{
        sessionId: string;
        state: Record<string, unknown>;
        version: bigint;
    }>;
    get(sessionId: string): Promise<{
        sessionId: string;
        guildId: string;
        userId: string;
        purpose: string;
        state: Record<string, unknown>;
        version: bigint;
        expiresAt: Date;
    } | null>;
    getFor(guildId: string, userId: string, purpose: string): Promise<{
        sessionId: string;
        guildId: string;
        userId: string;
        purpose: string;
        state: Record<string, unknown>;
        version: bigint;
        expiresAt: Date;
    } | null>;
    update(input: {
        sessionId: string;
        state: Record<string, unknown>;
        expectedVersion: bigint;
        expiresAt?: Date;
    }): Promise<{
        state: Record<string, unknown>;
        version: bigint;
    }>;
    advance(input: {
        sessionId: string;
        guildId: string;
        userId: string;
        purpose: string;
        expectedVersion: bigint;
        expectedStep: number;
        nextStep: number;
        state: Record<string, unknown> & {
            step: number;
        };
        expiresAt?: Date;
    }): Promise<{
        state: Record<string, unknown>;
        version: bigint;
    }>;
    expire(input: {
        sessionId: string;
        guildId: string;
        userId: string;
        purpose: string;
        expiredAt: Date;
    }): Promise<{
        expired: false;
    } | {
        expired: true;
        state: Record<string, unknown>;
    }>;
    delete(sessionId: string): Promise<boolean>;
}
export interface CacheInvalidationService {
    publish(input: {
        namespace: string;
        key: string;
    }): Promise<bigint>;
    revision(input: {
        namespace: string;
        key: string;
    }): Promise<bigint>;
}
export interface RateLimitService {
    consume(input: {
        scope: "user" | "guild" | "global";
        subjectId: string;
        action: string;
        limit: number;
        windowSeconds: number;
    }): Promise<{
        allowed: boolean;
        remaining: number;
        resetsAt: Date;
    }>;
    /**
     * Releases a previously consumed slot when the protected operation did not
     * complete. Implementations must clamp the window count at zero.
     */
    release(input: {
        scope: "user" | "guild" | "global";
        subjectId: string;
        action: string;
        windowSeconds: number;
    }): Promise<void>;
}
export interface EntitlementService {
    has(guildId: string, capability: string): Promise<boolean>;
}
export interface SubscriptionService {
    getForGuild(guildId: string): Promise<{
        status: "trialing" | "active" | "past_due" | "paused" | "cancelled" | "expired";
        planId: string;
        currentPeriodEnd: Date | null;
        gracePeriodEnd: Date | null;
    } | null>;
}
export interface AuditService {
    append(input: {
        guildId: string;
        actorUserId?: string;
        action: string;
        source: "discord" | "dashboard" | "control" | "system";
        correlationId?: string;
        idempotencyKey?: string;
        moduleId?: string;
        commandId?: string;
        targetType?: string;
        targetId?: string;
        metadata?: Record<string, unknown>;
    }): Promise<{
        eventId: bigint;
        createdAt: Date;
    }>;
}
export type ScheduledTaskPayload = Readonly<Record<string, string>>;
export type ScheduledTaskExecutionResult = {
    outcome: "completed";
} | {
    outcome: "deferred";
    delayMs: number;
    safeCode: string;
} | {
    outcome: "retry";
    delayMs: number;
    safeCode: string;
} | {
    outcome: "requires_review";
    safeCode: string;
};
export declare function validateScheduledTaskExecutionResult(input: unknown): ScheduledTaskExecutionResult;
export type ModuleScheduledTaskExecution = {
    delivery: "one-shot";
    taskId: string;
    moduleId: string;
    taskKind: string;
    taskVersion: number;
    guildId: string | null;
    payload: ScheduledTaskPayload;
} | {
    delivery: "coalesced";
    taskId: string;
    moduleId: string;
    taskKind: string;
    taskVersion: number;
    guildId: string | null;
    payload: ScheduledTaskPayload;
    claimedGeneration: number;
};
interface ModuleScheduledTaskContributionBase {
    kind: string;
    version: number;
    attemptLimit?: number;
    validatePayload(input: unknown): ScheduledTaskPayload;
    execute(context: RuntimeContext, task: ModuleScheduledTaskExecution): Promise<ScheduledTaskExecutionResult>;
}
export type ModuleScheduledTaskContribution = (ModuleScheduledTaskContributionBase & {
    delivery: "one-shot";
}) | (ModuleScheduledTaskContributionBase & {
    delivery: "coalesced";
    minimumIntervalMs: number;
});
export interface ScheduledTaskService {
    schedule(input: {
        moduleId: string;
        taskKind: string;
        guildId?: string;
        idempotencyKey: string;
        payload: ScheduledTaskPayload;
        scheduledFor: Date;
    }): Promise<{
        taskId: string;
        scheduledFor: Date;
    }>;
    cancel(input: {
        moduleId: string;
        taskId: string;
    }): Promise<{
        cancelled: boolean;
    }>;
    signal(input: {
        moduleId: string;
        taskKind: string;
        guildId?: string;
        coalesceKey: string;
        payload: ScheduledTaskPayload;
        mode?: "normal" | "barrier";
    }): Promise<{
        taskId: string;
        requestedGeneration: number;
    }>;
}
export type ModuleRecordWriteValue = string | boolean | number | Date;
export type ModuleRecordValue = ModuleRecordWriteValue | null;
export declare const MAX_SCALED_INTEGER_UNITS = 9000000000000000n;
export declare function isCanonicalScaledInteger(value: unknown): value is string;
export interface ModuleRecordOrder {
    field: string;
    direction: "asc" | "desc";
}
export interface ModuleRecordNumericMutation {
    identity: Readonly<Record<string, ModuleRecordWriteValue>>;
    insert: Readonly<Record<string, ModuleRecordWriteValue>>;
    increments: Readonly<Record<string, number>>;
    maxima?: Readonly<Record<string, Date>>;
}
export interface ModuleRecordNumericMutationResult {
    created: boolean;
    before: Readonly<Record<string, ModuleRecordValue>>;
    after: Readonly<Record<string, ModuleRecordValue>>;
}
export type NumericWriteBehindEnqueueOutcome = "accepted" | "cooldown" | "suppressed" | "paused" | "capacity" | "unavailable";
export interface NumericWriteBehindEnqueueInput {
    moduleId: string;
    collection: string;
    guildId: string;
    subjectId: string;
    occurredAt: Date;
    cooldownSeconds: number;
    identity: Readonly<Record<string, ModuleRecordWriteValue>>;
    insert: Readonly<Record<string, ModuleRecordWriteValue>>;
    increments: Readonly<Record<string, number>>;
    maxima?: Readonly<Record<string, Date>>;
}
export interface NumericWriteBehindScope {
    moduleId: string;
    collection: string;
}
export interface NumericWriteBehindMemberScope extends NumericWriteBehindScope {
    guildId: string;
    subjectId: string;
}
export interface NumericWriteBehindPendingSnapshot {
    increments: Readonly<Record<string, number>>;
    maxima: Readonly<Record<string, Date>>;
    oldestAcceptedAt: Date | null;
}
export interface NumericWriteBehindCommittedBatch extends NumericWriteBehindScope {
    operationId: string;
    replayed: boolean;
    itemIndexes?: readonly number[];
    mutations: readonly ModuleRecordNumericMutation[];
    results: readonly ModuleRecordNumericMutationResult[];
}
export interface NumericWriteBehindHealth {
    accepting: boolean;
    pendingEntries: number;
    retryBatches: number;
    quarantinedBatches: number;
    inFlightEntries: number;
    oldestPendingAgeMs: number | null;
    lastFlushDurationMs: number | null;
    retryCount: number;
    rejectedCount: number;
    suppressedGuilds: number;
    suppressedMembers: number;
    suppressedSubjects: number;
}
export interface NumericWriteBehindService {
    enqueue(input: NumericWriteBehindEnqueueInput): Promise<{
        outcome: NumericWriteBehindEnqueueOutcome;
    }>;
    pendingMemberSnapshot(input: NumericWriteBehindMemberScope): Promise<NumericWriteBehindPendingSnapshot>;
    flushMember(input: NumericWriteBehindMemberScope): Promise<void>;
    flushGuild(input: NumericWriteBehindScope & {
        guildId: string;
    }): Promise<void>;
    flushSubject(input: NumericWriteBehindScope & {
        subjectId: string;
    }): Promise<void>;
    flushModule(input: NumericWriteBehindScope): Promise<void>;
    runMemberBarrier<Result>(input: NumericWriteBehindMemberScope, operation: (signal: AbortSignal) => Promise<Result>): Promise<Result>;
    runGuildBarrier<Result>(input: NumericWriteBehindScope & {
        guildId: string;
    }, operation: (signal: AbortSignal) => Promise<Result>): Promise<Result>;
    runSubjectBarrier<Result>(input: NumericWriteBehindScope & {
        subjectId: string;
    }, operation: (signal: AbortSignal) => Promise<Result>): Promise<Result>;
    suppressGuild(input: NumericWriteBehindScope & {
        guildId: string;
    }): Promise<{
        suppressionId: string;
        discarded: number;
    }>;
    releaseGuild(input: NumericWriteBehindScope & {
        guildId: string;
        suppressionId: string;
    }): Promise<{
        released: boolean;
    }>;
    suppressSubject(input: NumericWriteBehindScope & {
        subjectId: string;
        cutoff: Date;
    }): Promise<{
        suppressionId: string;
        discarded: number;
    }>;
    releaseSubject(input: NumericWriteBehindScope & {
        subjectId: string;
        suppressionId: string;
    }): Promise<{
        released: boolean;
    }>;
    clearMemberCooldown(input: NumericWriteBehindMemberScope): Promise<void>;
    clearSubjectCooldown(input: NumericWriteBehindScope & {
        subjectId: string;
    }): Promise<void>;
    subscribeCommitted(input: NumericWriteBehindScope, handler: (batch: NumericWriteBehindCommittedBatch, signal: AbortSignal) => void | Promise<void>): () => void;
}
export interface NumericWriteBehindControl {
    health(): NumericWriteBehindHealth;
    stop(timeoutMs?: number): Promise<{
        drained: boolean;
    }>;
}
export interface ModuleRecordRankedResult {
    rank: number;
    values: Readonly<Record<string, ModuleRecordValue>>;
}
export interface ModuleRecordAudit {
    guildId: string;
    actorUserId?: string;
    action: string;
    source: "discord" | "dashboard" | "control" | "system";
    correlationId?: string;
    idempotencyKey: string;
    targetType?: string;
    targetId?: string;
    metadata?: Readonly<Record<string, unknown>>;
}
export interface ModuleRecordRetention {
    collection: string;
    where: Readonly<Record<string, string>>;
    scheduledFor: Date;
    idempotencyKey: string;
    batchLimit?: number;
    audit?: {
        action: string;
        targetType: string;
        targetId: string;
    };
}
export interface ModuleRecordAchievementContribution {
    guildId: string;
    memberId: string;
    eventId: string;
    amount: number;
    occurredAt: Date;
    idempotencyKey: string;
    /** Keep the first event time when an identical participation is replayed later. */
    allowTimestampReplay?: boolean;
}
export interface RecordRetentionService {
    execute(retentionTaskId: string): Promise<{
        completed: boolean;
        deleted: number;
        deferredUntil?: Date;
    }>;
}
export interface ModuleRecordService {
    /** Bounded startup recovery, scoped by core to the current worker's servers.
     * Cursor prepends a server ID to the declared immutable record ordering. */
    findManyForRecovery?(input: {
        moduleId: string;
        collection: string;
        select: readonly string[];
        orderBy: readonly ModuleRecordOrder[];
        cursor?: readonly ModuleRecordWriteValue[];
        limit: number;
    }): Promise<{
        records: readonly Readonly<Record<string, ModuleRecordValue>>[];
        nextCursor: readonly ModuleRecordWriteValue[] | null;
    }>;
    runGuildWriteFence<Result>(input: {
        moduleId: string;
        guildId: string;
    }, operation: () => Promise<Result>): Promise<Result>;
    runGuildsWriteFence<Result>(input: {
        moduleId: string;
        guildIds: readonly string[];
    }, operation: () => Promise<Result>): Promise<Result>;
    runSubjectWriteFence<Result>(input: {
        moduleId: string;
        subjectId: string;
    }, operation: () => Promise<Result>): Promise<Result>;
    append(input: {
        moduleId: string;
        collection: string;
        values: Readonly<Record<string, ModuleRecordWriteValue>>;
        achievementContribution?: ModuleRecordAchievementContribution;
    }): Promise<void>;
    appendUnique(input: {
        moduleId: string;
        collection: string;
        values: Readonly<Record<string, ModuleRecordWriteValue>>;
        uniqueBy: readonly string[];
        requireModuleEnabledForGuildId?: string;
        quotaGuards?: readonly {
            collection: string;
            where: Readonly<Record<string, ModuleRecordValue>>;
            in?: {
                field: string;
                values: readonly ModuleRecordWriteValue[];
            };
            maximum: number;
        }[];
        orderedRetention?: {
            where: Readonly<Record<string, ModuleRecordValue>>;
            eligibleIn: {
                field: string;
                values: readonly ModuleRecordWriteValue[];
            };
            orderBy: readonly ModuleRecordOrder[];
            select: readonly string[];
            maximum: number;
        };
        audit?: ModuleRecordAudit;
        retention?: readonly ModuleRecordRetention[];
        signal?: {
            taskKind: string;
            guildId?: string;
            coalesceKey: string;
            payload: ScheduledTaskPayload;
            mode?: "normal" | "barrier";
        };
        schedule?: {
            taskKind: string;
            guildId?: string;
            idempotencyKey: string;
            payload: ScheduledTaskPayload;
            scheduledFor: Date;
        };
    }): Promise<{
        created: boolean;
        reason?: "quota_exceeded" | "module_disabled";
        purged?: Readonly<Record<string, ModuleRecordValue>>;
    }>;
    upsert(input: {
        moduleId: string;
        collection: string;
        values: Readonly<Record<string, ModuleRecordWriteValue>>;
        uniqueBy: readonly string[];
        update: readonly string[];
        clear?: readonly string[];
    }): Promise<{
        created: boolean;
    }>;
    mutateNumericBatch(input: {
        moduleId: string;
        collection: string;
        operationId: string;
        uniqueBy: readonly string[];
        mutations: readonly ModuleRecordNumericMutation[];
        select: readonly string[];
        audit?: ModuleRecordAudit;
        retention?: readonly ModuleRecordRetention[];
    }): Promise<{
        replayed: boolean;
        results: readonly ModuleRecordNumericMutationResult[];
    }>;
    rankedPage(input: {
        moduleId: string;
        collection: string;
        guildId: string;
        scoreField: string;
        select: readonly string[];
        cursor?: {
            score: number;
            userId: string;
        };
        limit: number;
    }): Promise<{
        records: readonly ModuleRecordRankedResult[];
        nextCursor: {
            score: number;
            userId: string;
        } | null;
    }>;
    rankOf(input: {
        moduleId: string;
        collection: string;
        guildId: string;
        userId: string;
        scoreField: string;
        select: readonly string[];
    }): Promise<ModuleRecordRankedResult | null>;
    count(input: {
        moduleId: string;
        collection: string;
        where: Readonly<Record<string, ModuleRecordValue>>;
    }): Promise<number>;
    findOne(input: {
        moduleId: string;
        collection: string;
        select: readonly string[];
        where: Readonly<Record<string, ModuleRecordValue>>;
    }): Promise<Readonly<Record<string, ModuleRecordValue>> | null>;
    findMany(input: {
        moduleId: string;
        collection: string;
        select: readonly string[];
        where: Readonly<Record<string, ModuleRecordValue>>;
        orderBy: readonly ModuleRecordOrder[];
        cursor?: readonly ModuleRecordWriteValue[];
        search?: string;
        prefix?: {
            field: string;
            value: string;
        };
        dateRange?: {
            field: string;
            from: Date;
            to: Date;
        };
        limit: number;
    }): Promise<{
        records: readonly Readonly<Record<string, ModuleRecordValue>>[];
        nextCursor: readonly ModuleRecordWriteValue[] | null;
    }>;
    findManyByValues(input: {
        moduleId: string;
        collection: string;
        select: readonly string[];
        where: Readonly<Record<string, ModuleRecordValue>>;
        whereAny: {
            field: string;
            values: readonly ModuleRecordWriteValue[];
        };
        orderBy: readonly ModuleRecordOrder[];
    }): Promise<readonly Readonly<Record<string, ModuleRecordValue>>[]>;
    updateOne(input: {
        moduleId: string;
        collection: string;
        where: Readonly<Record<string, ModuleRecordWriteValue>>;
        expected: {
            field: string;
            value: ModuleRecordValue;
        };
        dateNullOrAfterNow?: {
            field: string;
        };
        dateAfterNow?: {
            field: string;
        };
        dateAtOrBeforeNow?: {
            field: string;
        };
        requireModuleEnabledForGuildId?: string;
        values: Readonly<Record<string, ModuleRecordValue>>;
        appendUnique?: {
            collection: string;
            values: Readonly<Record<string, ModuleRecordWriteValue>>;
            uniqueBy: readonly string[];
        };
        audit?: ModuleRecordAudit;
        retention?: readonly ModuleRecordRetention[];
        signal?: {
            taskKind: string;
            guildId?: string;
            coalesceKey: string;
            payload: ScheduledTaskPayload;
            mode?: "normal" | "barrier";
        };
        schedule?: {
            taskKind: string;
            guildId?: string;
            idempotencyKey: string;
            payload: ScheduledTaskPayload;
            scheduledFor: Date;
        };
        achievementContribution?: ModuleRecordAchievementContribution;
    }): Promise<{
        updated: boolean;
    }>;
    /**
     * Deletes one revision-checked record and writes its required Audit event in
     * the same transaction. `where` must be one complete declared unique key.
     */
    deleteOne(input: {
        moduleId: string;
        collection: string;
        where: Readonly<Record<string, ModuleRecordWriteValue>>;
        expected: {
            field: string;
            value: ModuleRecordValue;
        };
        audit: ModuleRecordAudit;
    }): Promise<{
        deleted: boolean;
    }>;
    deleteMany(input: {
        moduleId: string;
        collection: string;
        where: Readonly<Record<string, ModuleRecordValue>>;
        limit: number;
    }): Promise<{
        deleted: number;
    }>;
    groupCount(input: {
        moduleId: string;
        collection: string;
        where: Readonly<Record<string, ModuleRecordValue>>;
        groupBy: string;
        /** Exclusive keyset cursor for bounded traversal of grouped values. */
        after?: ModuleRecordValue;
        limit: number;
    }): Promise<readonly {
        value: ModuleRecordValue;
        count: number;
    }[]>;
    aggregateCounts(input: {
        moduleId: string;
        collection: string;
        where: Readonly<Record<string, ModuleRecordValue>>;
        groupBy: string;
        distinctBy: string;
        limit: number;
    }): Promise<{
        groups: readonly {
            value: ModuleRecordValue;
            count: number;
        }[];
        totalRows: number;
        distinctCount: number;
    }>;
    countDistinct(input: {
        moduleId: string;
        collection: string;
        where: Readonly<Record<string, ModuleRecordValue>>;
        field: string;
    }): Promise<number>;
    replaceOwnedSet(input: {
        moduleId: string;
        collection: string;
        owner: Readonly<Record<string, ModuleRecordWriteValue>>;
        values: readonly Readonly<Record<string, ModuleRecordWriteValue>>[];
        uniqueBy: readonly string[];
        preserveFields?: readonly string[];
        quotaGuards?: readonly {
            collection: string;
            where: Readonly<Record<string, ModuleRecordValue>>;
            in?: {
                field: string;
                values: readonly ModuleRecordWriteValue[];
            };
            maximum: number;
        }[];
        guard?: {
            collection: string;
            where: Readonly<Record<string, ModuleRecordWriteValue>>;
            expected?: {
                field: string;
                value: ModuleRecordValue;
            };
            dateNullOrAfterNow?: {
                field: string;
            };
            dateAfterNow?: {
                field: string;
            };
            dateAtOrBeforeNow?: {
                field: string;
            };
            values?: Readonly<Record<string, ModuleRecordWriteValue>>;
        };
        requiredRows?: readonly {
            collection: string;
            where: Readonly<Record<string, ModuleRecordWriteValue>>;
            expected?: {
                field: string;
                value: ModuleRecordValue;
            };
        }[];
        requireModuleEnabledForGuildId?: string;
        insertIfEmpty?: boolean;
        signal?: {
            taskKind: string;
            guildId?: string;
            coalesceKey: string;
            payload: ScheduledTaskPayload;
            mode?: "normal" | "barrier";
        };
        schedule?: {
            taskKind: string;
            guildId?: string;
            idempotencyKey: string;
            payload: ScheduledTaskPayload;
            scheduledFor: Date;
        };
        schedules?: readonly {
            taskKind: string;
            guildId?: string;
            idempotencyKey: string;
            payload: ScheduledTaskPayload;
            scheduledFor: Date;
            parentTaskIdField?: string;
        }[];
        audit?: ModuleRecordAudit;
        parent?: {
            collection: string;
            values: Readonly<Record<string, ModuleRecordWriteValue>>;
            uniqueBy: readonly string[];
        };
        achievementContributions?: readonly (ModuleRecordAchievementContribution & {
            when: "applied" | "owner-empty";
        })[];
    }): Promise<{
        applied: boolean;
        reason: "guard_not_matched" | "module_disabled" | "owned_set_not_empty" | "parent_conflict" | "quota_exceeded" | "required_row_missing" | null;
        deleted: number;
        inserted: number;
        scheduled?: readonly {
            idempotencyKey: string;
            taskId: string;
        }[];
    }>;
}
export interface ModuleRecordCollection {
    table: string;
    fields: Readonly<Record<string, {
        type: "string" | "boolean" | "number" | "date" | "json" | "scaled-integer-string";
        optional?: boolean;
    }>>;
    ownedSetLimit?: number;
    uniqueKeys?: readonly (readonly string[])[];
    readableFields?: readonly string[];
    writableFields?: readonly string[];
    orderKeys?: readonly (readonly string[])[];
    groupableFields?: readonly string[];
    searchableFields?: readonly string[];
    incrementableFields?: readonly string[];
    maximumFields?: readonly string[];
    rankableFields?: readonly string[];
}
export interface InstallationService {
    isModuleEnabled(guildId: string, moduleId: string): Promise<boolean>;
    getModuleState(guildId: string, moduleId: string): Promise<{
        enabled: boolean;
        enabledAt: Date;
        disabledAt: Date | null;
    } | null>;
    setModuleEnabled(input: {
        guildId: string;
        moduleId: string;
        enabled: boolean;
        context: ConfigurationMutationContext;
    }): Promise<{
        enabled: boolean;
        transitionedModuleIds: string[];
    }>;
    completeFirstTimeSetup?(input: {
        guildId: string;
        moduleIds: string[];
        expectedRevision: bigint;
        idempotencyKey: string;
        context: ConfigurationMutationContext;
    }): Promise<{
        enabled: true;
        transitionedModuleIds: string[];
    }>;
}
export interface ModuleAvailabilityState {
    moduleId: string;
    globallyDisabled: boolean;
    revision: bigint;
    generation: bigint;
    updatedAt: Date | null;
}
export interface ModuleAvailabilityService {
    get(moduleId: string): Promise<ModuleAvailabilityState>;
    isAvailable(moduleId: string): Promise<boolean>;
    refresh(): Promise<void>;
    snapshotRevision(): bigint;
}
export declare class ModuleStateValidationError extends Error {
    constructor(message: string);
}
export interface ModuleConfigurationContribution {
    schemaVersion: number;
    validate(input: unknown): Record<string, unknown>;
    validateUpdate?(input: {
        guildId: string;
        value: Record<string, unknown>;
        services: ServiceAccess;
    }): Promise<void>;
    settingsPreview?(context: ModuleSettingsPreviewContext, input: {
        value: Record<string, unknown>;
        input: Readonly<Record<string, ManagedResourceValue>>;
    }): Promise<Readonly<Record<string, ManagedResourceValue>>>;
}
export interface ModuleSettingsPreviewContext {
    guildId: string;
    actor: PermissionActor;
    correlationId: string;
    services: ServiceAccess;
}
export interface EmbedMessage {
    title?: string;
    description?: string;
    color?: number;
    footer?: string;
    footerIconUrl?: string;
    url?: string;
    author?: {
        name: string;
        url?: string;
        iconUrl?: string;
    };
    timestamp?: string;
    imageUrl?: string;
    thumbnailUrl?: string;
    fields?: readonly {
        name: string;
        value: string;
        inline: boolean;
    }[];
}
export interface InteractiveButtonComponent {
    type: "button";
    customId: string;
    label: string;
    style: "primary" | "secondary" | "success" | "danger";
    emojiIdentifier?: string;
    disabled?: boolean;
    url?: never;
}
export interface LinkButtonComponent {
    type: "button";
    label: string;
    style: "link";
    url: string;
    emojiIdentifier?: string;
    disabled?: boolean;
    customId?: never;
}
export type ButtonComponent = InteractiveButtonComponent | LinkButtonComponent;
export interface StringSelectComponent {
    type?: "string";
    customId: string;
    placeholder: string;
    minValues?: number;
    maxValues?: number;
    disabled?: boolean;
    options: readonly {
        label: string;
        value: string;
        description?: string;
        emojiIdentifier?: string;
    }[];
}
export interface DiscordChannelSelectComponent {
    type: "discord-channel";
    customId: string;
    placeholder: string;
    minValues?: number;
    maxValues?: number;
    channelTypes: readonly ("guild_text" | "guild_announcement" | "guild_category" | "guild_forum" | "guild_media")[];
    options?: never;
}
export interface DiscordRoleSelectComponent {
    type: "discord-role";
    customId: string;
    placeholder: string;
    minValues?: number;
    maxValues?: number;
    options?: never;
}
export type SelectComponent = StringSelectComponent | DiscordChannelSelectComponent | DiscordRoleSelectComponent;
export interface ComponentsV2Message {
    accentColor?: number;
    text: readonly {
        content: string;
        markdown?: boolean;
    }[];
}
export interface MessageResponse {
    /** Plain message content. Components V2 responses must leave this unset. */
    content?: string;
    ephemeral?: boolean;
    suppressEmbeds?: boolean;
    embed?: EmbedMessage;
    embeds?: readonly EmbedMessage[];
    suppressNotifications?: boolean;
    buttons?: readonly ButtonComponent[];
    selects?: readonly SelectComponent[];
    componentsV2?: ComponentsV2Message;
    allowedUserMentionIds?: readonly string[];
    allowedRoleMentionIds?: readonly string[];
}
export type MessageBuilderPresentation = {
    type: "text";
    title: string;
    body: string;
    accentColor?: number;
} | {
    type: "embed";
    title: string;
    body: string;
    color?: number;
    footer?: string;
};
export interface MessageBuilderButtonDraft {
    customId: string;
    label: string;
    style: Exclude<ButtonComponent["style"], "link">;
    emojiIdentifier?: string;
    disabled?: boolean;
}
export interface MessageBuilderStringSelectDraft {
    customId: string;
    placeholder: string;
    minValues?: number;
    maxValues?: number;
    disabled?: boolean;
    options: readonly {
        label: string;
        value: string;
        description?: string;
        emojiIdentifier?: string;
    }[];
}
export interface MessageBuilderDraft {
    presentation: MessageBuilderPresentation;
    buttons?: readonly MessageBuilderButtonDraft[];
    selects?: readonly MessageBuilderStringSelectDraft[];
    reactionIdentifiers?: readonly string[];
    allowedUserMentionIds?: readonly string[];
}
export interface RichMessageBuilderDraft {
    content?: string;
    embeds: readonly EmbedMessage[];
    suppressNotifications?: boolean;
}
export interface RichMessageBuilderResult extends MessageBuilderResult {
    canonical: RichMessageBuilderDraft;
}
export type RecurrenceDefinition = {
    kind: "interval";
    intervalMinutes: number;
} | {
    kind: "daily";
    timezone: string;
    localTime: string;
} | {
    kind: "weekly";
    timezone: string;
    localTime: string;
    weekday: number;
};
export interface RecurrenceService {
    next(input: {
        definition: RecurrenceDefinition;
        after: Date;
    }): Date;
}
export interface MessageBuilderResult {
    response: MessageResponse;
    reactionSeeds: readonly string[];
}
export interface MessageBuilderService {
    build(draft: MessageBuilderDraft): MessageBuilderResult;
    buildRich(draft: RichMessageBuilderDraft): RichMessageBuilderResult;
}
interface ModalFieldBase {
    customId: string;
    label: string;
    description?: string;
}
export interface ModalTextField extends ModalFieldBase {
    type?: "text";
    style: "short" | "paragraph";
    required?: boolean;
    minLength?: number;
    maxLength?: number;
    placeholder?: string;
    value?: string;
}
export interface ModalStringSelectField extends ModalFieldBase {
    type: "string-select";
    placeholder?: string;
    required?: boolean;
    minValues?: number;
    maxValues?: number;
    options: readonly {
        label: string;
        value: string;
        description?: string;
        default?: boolean;
    }[];
}
interface ModalAutoSelectField extends ModalFieldBase {
    placeholder?: string;
    required?: boolean;
    minValues?: number;
    maxValues?: number;
}
export interface ModalDiscordUserSelectField extends ModalAutoSelectField {
    type: "discord-user";
    defaultValues?: readonly string[];
}
export interface ModalDiscordRoleSelectField extends ModalAutoSelectField {
    type: "discord-role";
    defaultValues?: readonly string[];
}
export interface ModalDiscordMentionableSelectField extends ModalAutoSelectField {
    type: "discord-mentionable";
    defaultValues?: readonly {
        type: "user" | "role";
        id: string;
    }[];
}
export interface ModalDiscordChannelSelectField extends ModalAutoSelectField {
    type: "discord-channel";
    channelTypes: readonly ("guild_text" | "guild_announcement" | "guild_category" | "guild_forum" | "guild_media")[];
    defaultValues?: readonly string[];
}
export type ModalField = ModalTextField | ModalStringSelectField | ModalDiscordUserSelectField | ModalDiscordRoleSelectField | ModalDiscordMentionableSelectField | ModalDiscordChannelSelectField;
export interface ModalTextDisplay {
    type: "text-display";
    content: string;
    markdown?: boolean;
}
export type ModalItem = ModalTextDisplay | ModalField;
export interface ModalDefinition {
    customId: string;
    title: string;
    /** Ordered Discord modal components. When set, legacy collections must be empty. */
    items?: readonly ModalItem[];
    /** @deprecated Prefer `items` when text and fields must be interleaved. */
    text?: readonly Omit<ModalTextDisplay, "type">[];
    fields: readonly ModalField[];
}
export interface DashboardActionResult {
    title: string;
    description: string;
}
export interface DashboardActionInspection extends DashboardActionResult {
    /** Opaque bounded revision that must be echoed into a checked mutation. */
    inspectionRevision: string;
}
export interface DashboardActionExecutionInput {
    inspectionRevision?: string;
}
export declare class DashboardActionValidationError extends Error {
    constructor(message: string);
}
export interface DashboardActionContext {
    guildId: string;
    actorUserId: string;
    correlationId: string;
    services: ServiceAccess;
    /** Rechecks module availability and this action's exact declared permission. */
    revalidate(): Promise<boolean>;
    sendToChannel(channelId: string, response: MessageResponse): Promise<{
        messageId: string;
    }>;
    deleteChannelMessage(channelId: string, messageId: string): Promise<void>;
}
export interface ModuleDashboardAction {
    id: string;
    inspect?(context: DashboardActionContext): Promise<DashboardActionInspection>;
    execute(context: DashboardActionContext, input?: DashboardActionExecutionInput): Promise<DashboardActionResult>;
}
export type ManagedResourceValue = string | number | boolean | null | readonly ManagedResourceValue[] | {
    readonly [key: string]: ManagedResourceValue;
};
export type ManagedResourceCreationIntent = "draft" | "publish";
export interface ManagedResourceSummary {
    id: string;
    revision: number;
    status: string;
    title: string;
    description?: string;
    attributes?: Readonly<Record<string, ManagedResourceValue>>;
    updatedAt: string;
}
export interface ManagedResourcePage {
    items: readonly ManagedResourceSummary[];
    nextCursor?: string;
    total?: number;
}
export interface ManagedResourceRelationRow {
    id: string;
    value: Readonly<Record<string, ManagedResourceValue>>;
}
export interface ManagedResourceRelationPage {
    items: readonly ManagedResourceRelationRow[];
    nextCursor?: string;
}
export interface ManagedResourceDetail extends ManagedResourceSummary {
    value: Readonly<Record<string, ManagedResourceValue>>;
    /** Optional current-state presentation filter; execution must revalidate authoritatively. */
    availableActionIds?: readonly string[];
}
export interface ManagedResourceContext {
    guildId: string;
    actor: PermissionActor;
    /**
     * Trusted dashboard-session authentication time supplied by the API/control
     * boundary. Discord interactions and older control clients omit it.
     */
    actorAuthenticatedAt?: string;
    correlationId: string;
    services: ServiceAccess;
    sendToChannel(channelId: string, response: MessageResponse): Promise<{
        messageId: string;
    }>;
    deleteChannelMessage(channelId: string, messageId: string): Promise<void>;
    editChannelMessage(channelId: string, messageId: string, response: MessageResponse): Promise<void>;
    addChannelMessageReaction(channelId: string, messageId: string, emojiIdentifier: string): Promise<void>;
}
export interface ModuleManagedResource {
    id: string;
    /**
     * Allows configuration records required by validateActivation to be
     * prepared while the module is disabled. Runtime actions remain gated.
     */
    availableWhileDisabled?: boolean;
    list(context: ManagedResourceContext, input: {
        cursor?: string;
        limit: number;
        search?: string;
        filters?: Readonly<Record<string, string>>;
    }): Promise<ManagedResourcePage>;
    read(context: ManagedResourceContext, resourceId: string): Promise<ManagedResourceDetail | null>;
    preview(context: ManagedResourceContext, value: Readonly<Record<string, ManagedResourceValue>>): Promise<MessageResponse>;
    import?(context: ManagedResourceContext, input: {
        format: "utf8_text";
        content: string;
    }): Promise<{
        value: Readonly<Record<string, ManagedResourceValue>>;
        preview: Readonly<Record<string, ManagedResourceValue>>;
    }>;
    create(context: ManagedResourceContext, value: Readonly<Record<string, ManagedResourceValue>>, intent?: ManagedResourceCreationIntent): Promise<ManagedResourceDetail>;
    update(context: ManagedResourceContext, input: {
        resourceId: string;
        expectedRevision: number;
        value: Readonly<Record<string, ManagedResourceValue>>;
    }): Promise<ManagedResourceDetail>;
    delete(context: ManagedResourceContext, input: {
        resourceId: string;
        expectedRevision: number;
    }): Promise<{
        deleted: boolean;
    }>;
    executeAction(context: ManagedResourceContext, input: {
        resourceId: string;
        actionId: string;
        expectedRevision: number;
        value: Readonly<Record<string, ManagedResourceValue>>;
    }): Promise<ManagedResourceDetail | null>;
    listRelation?(context: ManagedResourceContext, resourceId: string, relationId: string, input: {
        cursor?: string;
        limit: number;
        search?: string;
        filters?: Readonly<Record<string, string>>;
    }): Promise<ManagedResourceRelationPage>;
}
export interface InteractionContext {
    interactionId: string;
    /** Discord's creation timestamp for the interaction response budget. */
    interactionCreatedAt?: Date;
    customId?: string;
    userId: string;
    userDisplayName: string;
    userRoleIds: readonly string[];
    userHighestRolePosition?: number;
    userPermissions?: readonly string[];
    isServerOwner?: boolean;
    isAdministrator: boolean;
    serverId?: string;
    channelId?: string;
    messageId?: string;
    services: ServiceAccess;
    deferReply?(ephemeral?: boolean): Promise<void>;
    deleteReplyAfter?(milliseconds: number): void;
    reply(response: MessageResponse): Promise<void>;
    updateResponse?(response: MessageResponse): Promise<void>;
    editSourceMessage?(response: MessageResponse): Promise<void>;
    sendToChannel(channelId: string, response: MessageResponse): Promise<{
        messageId: string;
    }>;
    deleteChannelMessage(channelId: string, messageId: string): Promise<void>;
    editChannelMessage(channelId: string, messageId: string, response: MessageResponse): Promise<void>;
    addChannelMessageReaction(channelId: string, messageId: string, emojiIdentifier: string): Promise<void>;
}
export interface ModalCapableInteractionContext extends InteractionContext {
    showModal(modal: ModalDefinition): Promise<void>;
}
export interface ModalInteractionContext extends InteractionContext {
    getField(customId: string): string;
    getStringSelectValues(customId: string): readonly string[];
    getSelectedUserIds(customId: string): readonly string[];
    getSelectedRoleIds(customId: string): readonly string[];
    getSelectedMentionables(customId: string): {
        userIds: readonly string[];
        roleIds: readonly string[];
    };
    getSelectedRolePositions?(customId: string): Readonly<Record<string, number>>;
    getSelectedChannelIds(customId: string): readonly string[];
}
export type UserFacingInteractionErrorCode = "nexus_exchange_slow" | "nexus_exchange_item_unavailable" | "nexus_exchange_item_changed" | "nexus_exchange_balance_changed" | "nexus_exchange_form_expired" | "nexus_exchange_form_replayed" | "nexus_exchange_preview_expired" | "nexus_exchange_invalid_request" | "nexus_exchange_response_required";
/**
 * Carries only a closed safe code across the module/runtime boundary. The bot
 * owns the customer-facing copy and never exposes the underlying exception.
 */
export declare class UserFacingInteractionError extends Error {
    readonly code: UserFacingInteractionErrorCode;
    constructor(code: UserFacingInteractionErrorCode);
}
export interface SelectInteractionContext extends ModalCapableInteractionContext {
    selectedValues: readonly string[];
}
export interface CommandInteractionContext extends ModalCapableInteractionContext {
    getStringOption(name: string): string | null;
    getBooleanOption(name: string): boolean | null;
    getIntegerOption?(name: string): number | null;
    getUserOption(name: string): {
        id: string;
        displayName: string;
        isBot: boolean;
    } | null;
    getChannelOption(name: string): {
        id: string;
        name: string;
        type: "guild_text" | "guild_announcement" | "guild_category" | "other";
    } | null;
    getRoleOption(name: string): {
        id: string;
        name: string;
    } | null;
}
export interface CommandAutocompleteChoice {
    name: string;
    value: string;
}
export interface CommandAutocompleteContext {
    interactionId: string;
    userId: string;
    userRoleIds: readonly string[];
    userPermissions?: readonly string[];
    isServerOwner?: boolean;
    isAdministrator: boolean;
    serverId?: string;
    focusedOptionName: string;
    focusedValue: string;
    services: ServiceAccess;
    respond(choices: readonly CommandAutocompleteChoice[]): Promise<void>;
}
export type CommandOptionDefinition = {
    type: "string";
    name: string;
    description: string;
    required?: boolean;
    minLength?: number;
    maxLength?: number;
    choices?: readonly {
        name: string;
        value: string;
    }[];
    autocomplete?: boolean;
} | {
    type: "boolean";
    name: string;
    description: string;
    required?: boolean;
} | {
    type: "integer";
    name: string;
    description: string;
    required?: boolean;
    minimum?: number;
    maximum?: number;
} | {
    type: "channel";
    name: string;
    description: string;
    required?: boolean;
    channelTypes?: readonly ("guild_text" | "guild_announcement" | "guild_category" | "guild_forum" | "guild_media")[];
} | {
    type: "role";
    name: string;
    description: string;
    required?: boolean;
} | {
    type: "user";
    name: string;
    description: string;
    required?: boolean;
};
export interface CommandPermissionOperation {
    id: string;
    name: string;
    description: string;
}
export interface SubcommandContribution {
    name: string;
    description: string;
    acknowledgement?: CommandAcknowledgement;
    permissionId?: string;
    authorization?: CommandAuthorization;
    permissionOperations?: readonly CommandPermissionOperation[];
    options?: readonly CommandOptionDefinition[];
    rateLimit?: {
        scope: "user" | "guild";
        limit: number;
        windowSeconds: number;
    };
    autocomplete?(context: CommandAutocompleteContext): Promise<void>;
    execute(context: CommandInteractionContext): Promise<void>;
}
export interface SubcommandGroupContribution {
    name: string;
    description: string;
    subcommands: readonly SubcommandContribution[];
}
export type CommandRegistrationPolicy = "platform-global" | "enabled-guild" | "deployment" | "internal-guild";
type CommandRegistration = {
    registrationPolicy: CommandRegistrationPolicy;
    registration?: never;
} | {
    /** @deprecated Migrate commands to registrationPolicy. */
    registration: "global" | "guild";
    registrationPolicy?: never;
};
interface CommandContributionDefinition {
    name: string;
    description: string;
    acknowledgement?: CommandAcknowledgement;
    permissionId?: string;
    authorization?: CommandAuthorization;
    permissionOperations?: readonly CommandPermissionOperation[];
    options?: readonly CommandOptionDefinition[];
    contexts: readonly ("guild" | "bot_dm" | "private_channel")[];
    integrationTypes: readonly ("guild_install" | "user_install")[];
    rateLimit?: {
        scope: "user" | "guild";
        limit: number;
        windowSeconds: number;
    };
    execute?(context: CommandInteractionContext): Promise<void>;
    subcommands?: readonly SubcommandContribution[];
    subcommandGroups?: readonly SubcommandGroupContribution[];
}
export type CommandContribution = CommandContributionDefinition & CommandRegistration;
export type CommandAcknowledgement = "deferred-ephemeral" | "immediate-modal" | "immediate-response";
export type CommandAuthorization = "resource-scoped" | "public" | "self-authorized";
type ExactOrPrefixedCustomId = {
    customId: string;
    customIdPrefix?: never;
} | {
    customId?: never;
    customIdPrefix: string;
};
export type ButtonContribution = ExactOrPrefixedCustomId & {
    acknowledgement?: "deferred-ephemeral" | "deferred-update";
    authorization?: "public";
    execute(context: ModalCapableInteractionContext): Promise<void>;
};
export type ModalContribution = ExactOrPrefixedCustomId & {
    acknowledgement?: "deferred-ephemeral" | "deferred-update";
    execute(context: ModalInteractionContext): Promise<void>;
};
export interface SelectContribution {
    customId: string;
    acknowledgement?: "deferred-ephemeral" | "deferred-update";
    execute(context: SelectInteractionContext): Promise<void>;
}
export interface InteractionContributions {
    commands?: readonly CommandContribution[];
    buttons?: readonly ButtonContribution[];
    modals?: readonly ModalContribution[];
    selects?: readonly SelectContribution[];
}
export interface MessageReactionAddContext {
    serverId: string;
    channelId: string;
    parentChannelId?: string;
    messageId: string;
    userId: string;
    userRoleIds: readonly string[];
    userPermissions?: readonly string[];
    isServerOwner?: boolean;
    isAdministrator?: boolean;
    emojiKey: string;
    emojiIdentifier: string;
    reactionCount: number;
    reactionType: "normal" | "burst";
    sourceAuthorId: string;
    sourceAuthorIsBot: boolean;
    sourceAuthorIsWebhook: boolean;
    sourceAuthorIsSystem: boolean;
    sourceCreatedAt: Date;
    services: ServiceAccess;
    fetchSourceMessage(): Promise<DiscordSourceMessageSnapshot | null>;
    removeAddedReaction(): Promise<void>;
    removeUserReaction(emojiIdentifier: string): Promise<void>;
}
export interface MessageReactionAddContribution {
    type: "discord.message-reaction-add";
    execute(context: MessageReactionAddContext): Promise<void>;
}
export interface MessageReactionRemoveContext {
    serverId: string;
    channelId: string;
    parentChannelId?: string;
    messageId: string;
    userId: string;
    emojiKey: string;
    emojiIdentifier: string;
    reactionCount: number;
    reactionType: "normal" | "burst";
    services: ServiceAccess;
}
export interface MessageReactionRemoveContribution {
    type: "discord.message-reaction-remove";
    execute(context: MessageReactionRemoveContext): Promise<void>;
}
export interface MessageReactionRemoveAllContext {
    serverId: string;
    channelId: string;
    messageId: string;
    services: ServiceAccess;
}
export interface MessageReactionRemoveAllContribution {
    type: "discord.message-reaction-remove-all";
    execute(context: MessageReactionRemoveAllContext): Promise<void>;
}
export interface MessageReactionRemoveEmojiContext {
    serverId: string;
    channelId: string;
    messageId: string;
    emojiKey: string;
    emojiIdentifier: string;
    services: ServiceAccess;
}
export interface MessageReactionRemoveEmojiContribution {
    type: "discord.message-reaction-remove-emoji";
    execute(context: MessageReactionRemoveEmojiContext): Promise<void>;
}
export interface DiscordSourceMessageAttachment {
    name: string;
    url: string;
    contentType: string | null;
    size: number;
    image: boolean;
    spoiler?: boolean;
}
export interface DiscordSourceMessageSnapshot {
    serverId: string;
    channelId: string;
    channelName?: string;
    parentChannelId?: string;
    messageId: string;
    jumpUrl: string;
    authorId: string;
    authorDisplayName: string;
    authorAvatarUrl?: string;
    authorIsBot: boolean;
    authorIsWebhook: boolean;
    authorIsSystem: boolean;
    createdAt: Date;
    editedAt: Date | null;
    ageRestricted: boolean;
    contentAvailable: boolean;
    content: string;
    attachments: readonly DiscordSourceMessageAttachment[];
    reactions: readonly {
        emojiKey: string;
        emojiIdentifier: string;
        count: number;
    }[];
}
export interface GuildMessageUpdateContext {
    serverId: string;
    channelId: string;
    messageId: string;
    services: ServiceAccess;
    fetchSourceMessage(): Promise<DiscordSourceMessageSnapshot | null>;
}
export interface GuildMessageUpdateContribution {
    type: "discord.guild-message-update";
    execute(context: GuildMessageUpdateContext): Promise<void>;
}
export interface MessageDeleteContext {
    serverId: string;
    channelId: string;
    messageId: string;
    services: ServiceAccess;
}
export interface MessageDeleteContribution {
    type: "discord.message-delete";
    execute(context: MessageDeleteContext): Promise<void>;
}
export interface GuildMessageDeleteBulkContext {
    serverId: string;
    channelId: string;
    messageIds: readonly string[];
    services: ServiceAccess;
}
export interface GuildMessageDeleteBulkContribution {
    type: "discord.guild-message-delete-bulk";
    execute(context: GuildMessageDeleteBulkContext): Promise<void>;
}
export interface PrivilegedMessageCreateContext {
    serverId: string;
    channelId: string;
    messageId: string;
    userId: string;
    userIsBot: boolean;
    webhookId: string | null;
    content: string;
    /** Added compatibly for consumers that need role and thread exemptions. */
    source?: PrivilegedMessageSourceContext;
    services: ServiceAccess;
    deleteSource(): Promise<void>;
}
export interface PrivilegedMessageEligibilityContext {
    serverId: string;
    channelId: string;
    userId: string;
    userIsBot: boolean;
    userIsSystem: boolean;
    webhookId: string | null;
    content: string;
    /** Added compatibly for consumers that need role and thread exemptions. */
    source?: PrivilegedMessageSourceContext;
    services: ServiceAccess;
}
export interface PrivilegedMessageCreateContribution {
    type: "discord.privileged-message-create";
    /** Optional for backward compatibility; binds v0.5 feature-owned listeners. */
    featureId?: string;
    isEligible(context: PrivilegedMessageEligibilityContext): Promise<boolean>;
    execute(context: PrivilegedMessageCreateContext): Promise<void>;
}
export type PrivilegedMessageSourceContext = {
    resolved: true;
    userId: string;
    userIsBot: boolean;
    userIsSystem: boolean;
    webhookId: string | null;
    member: {
        present: true;
        roleIds: readonly string[];
    } | {
        present: false;
    };
    channelId: string;
    parentChannelId: string | null;
    channelIsThread: boolean;
} | {
    resolved: false;
};
export type PrivilegedMessageUpdateContent = {
    present: true;
    value: string;
} | {
    present: false;
};
/**
 * Partial Gateway update observation. It deliberately exposes no source fetch;
 * absent content is not an empty message and unresolved identity cannot be acted on.
 */
export interface PrivilegedMessageUpdateContext {
    serverId: string;
    channelId: string;
    messageId: string;
    observationVersion: string;
    observedAt: Date;
    content: PrivilegedMessageUpdateContent;
    source: PrivilegedMessageSourceContext;
    services: ServiceAccess;
}
export interface PrivilegedMessageUpdateContribution {
    type: "discord.privileged-message-update";
    /** Required by reviewed v0.5 feature-owned message-update contributions. */
    featureId?: string;
    execute(context: PrivilegedMessageUpdateContext): Promise<void>;
}
export type GuildMessageKind = "text" | "emoji" | "link" | "image" | "gif" | "file" | "sticker" | "voice-message";
export type GuildMessageClassification = {
    available: false;
    kinds: readonly [];
} | {
    available: true;
    kinds: readonly GuildMessageKind[];
};
export interface GuildMessageCreateContext {
    serverId: string;
    channelId: string;
    parentChannelId?: string;
    messageId: string;
    isReply: boolean;
    authorId: string;
    authorDisplayName: string;
    authorRoleIds: readonly string[];
    authorIsBot: boolean;
    authorIsWebhook: boolean;
    authorIsSystem: boolean;
    /** Bounded, deduplicated structural Discord user mentions; never parsed from content. */
    mentionedUserIds: readonly string[];
    classification: GuildMessageClassification;
    createdAt: Date;
    services: ServiceAccess;
    addAuthorRole(roleId: string): Promise<void>;
    removeAuthorRole(roleId: string): Promise<void>;
    sendToChannel(channelId: string, response: MessageResponse): Promise<{
        messageId: string;
    }>;
}
export interface GuildMessageCreateContribution {
    type: "discord.guild-message-create";
    execute(context: GuildMessageCreateContext): Promise<void>;
}
export interface GuildVoiceSessionContext {
    serverId: string;
    channelId: string;
    memberId: string;
    startedAt: Date;
    endedAt: Date;
    durationSeconds: number;
    services: ServiceAccess;
}
export interface GuildVoiceSessionContribution {
    type: "discord.guild-voice-session";
    execute(context: GuildVoiceSessionContext): Promise<void>;
}
export interface GuildMemberAddContext {
    serverId: string;
    serverName: string;
    memberId: string;
    memberDisplayName: string;
    memberIsBot: boolean;
    accountCreatedAt: Date;
    joinedAt: Date;
    /** Stable for a repeated delivery of the same membership occurrence. */
    occurrenceId: string;
    /** Changes whenever the bot can no longer prove uninterrupted join-event observation. */
    continuityGeneration: string;
    services: ServiceAccess;
    assignRole(roleId: string): Promise<void>;
    sendToChannel(channelId: string, response: MessageResponse): Promise<{
        messageId: string;
    }>;
}
export interface GuildMemberAddContribution {
    type: "discord.guild-member-add";
    execute(context: GuildMemberAddContext): Promise<void>;
}
export interface GuildMemberRemoveContext {
    serverId: string;
    serverName?: string;
    memberId: string;
    memberDisplayName?: string;
    memberIsBot: boolean;
    accountCreatedAt: Date;
    joinedAt: Date | null;
    services: ServiceAccess;
}
export interface GuildMemberRemoveContribution {
    type: "discord.guild-member-remove";
    execute(context: GuildMemberRemoveContext): Promise<void>;
}
export interface GuildRoleDeleteContext {
    serverId: string;
    roleId: string;
    services: ServiceAccess;
}
export interface GuildRoleDeleteContribution {
    type: "discord.guild-role-delete";
    execute(context: GuildRoleDeleteContext): Promise<void>;
}
export interface GuildRoleUpdateContext {
    serverId: string;
    roleId: string;
    services: ServiceAccess;
}
export interface GuildRoleUpdateContribution {
    type: "discord.guild-role-update";
    execute(context: GuildRoleUpdateContext): Promise<void>;
}
export interface ChannelDeleteContext {
    serverId: string;
    channelId: string;
    services: ServiceAccess;
}
export interface ChannelDeleteContribution {
    type: "discord.channel-delete";
    execute(context: ChannelDeleteContext): Promise<void>;
}
export interface ChannelUpdateContext {
    serverId: string;
    channelId: string;
    services: ServiceAccess;
}
export interface ChannelUpdateContribution {
    type: "discord.channel-update";
    execute(context: ChannelUpdateContext): Promise<void>;
}
export interface GuildEmojiDeleteContext {
    serverId: string;
    emojiId: string;
    services: ServiceAccess;
}
export interface GuildEmojiDeleteContribution {
    type: "discord.guild-emoji-delete";
    execute(context: GuildEmojiDeleteContext): Promise<void>;
}
export interface GuildEmojiUpdateContext {
    serverId: string;
    emojiId: string;
    services: ServiceAccess;
}
export interface GuildEmojiUpdateContribution {
    type: "discord.guild-emoji-update";
    execute(context: GuildEmojiUpdateContext): Promise<void>;
}
export interface EventContributions {
    privilegedMessageCreate?: readonly PrivilegedMessageCreateContribution[];
    privilegedMessageUpdate?: readonly PrivilegedMessageUpdateContribution[];
    discordAutoModerationRuleCreate?: readonly DiscordAutoModerationRuleCreateContribution[];
    discordAutoModerationRuleUpdate?: readonly DiscordAutoModerationRuleUpdateContribution[];
    discordAutoModerationRuleDelete?: readonly DiscordAutoModerationRuleDeleteContribution[];
    discordAutoModerationActionExecution?: readonly DiscordAutoModerationActionExecutionContribution[];
    guildMessageCreate?: readonly GuildMessageCreateContribution[];
    guildVoiceSession?: readonly GuildVoiceSessionContribution[];
    messageReactionAdd?: readonly MessageReactionAddContribution[];
    messageReactionRemove?: readonly MessageReactionRemoveContribution[];
    messageReactionRemoveAll?: readonly MessageReactionRemoveAllContribution[];
    messageReactionRemoveEmoji?: readonly MessageReactionRemoveEmojiContribution[];
    guildMessageUpdate?: readonly GuildMessageUpdateContribution[];
    messageDelete?: readonly MessageDeleteContribution[];
    guildMessageDeleteBulk?: readonly GuildMessageDeleteBulkContribution[];
    guildMemberAdd?: readonly GuildMemberAddContribution[];
    guildMemberRemove?: readonly GuildMemberRemoveContribution[];
    guildRoleDelete?: readonly GuildRoleDeleteContribution[];
    guildRoleUpdate?: readonly GuildRoleUpdateContribution[];
    channelDelete?: readonly ChannelDeleteContribution[];
    channelUpdate?: readonly ChannelUpdateContribution[];
    guildEmojiDelete?: readonly GuildEmojiDeleteContribution[];
    guildEmojiUpdate?: readonly GuildEmojiUpdateContribution[];
}
export interface ModuleLogEventContribution {
    id: string;
    name: string;
    description: string;
    defaultEnabled: boolean;
}
export interface ModuleLoggingContribution {
    events: readonly ModuleLogEventContribution[];
}
export type PrivacyOutcome = "captured" | "deleted" | "detached" | "anonymised" | "retained" | "not_found" | "not_applicable" | "manual_review";
export type PrivacyExportValue = string | number | boolean | null | readonly PrivacyExportValue[] | {
    readonly [key: string]: PrivacyExportValue;
};
export interface PrivacyCaptureInput {
    requestId: string;
    discordUserId: string;
    cutoffAt: Date;
    cursor?: string;
}
export interface PrivacyCaptureItem {
    collection: string;
    recordId: string;
    data: Readonly<Record<string, PrivacyExportValue>>;
}
export interface PrivacyCapturePage {
    outcome: Extract<PrivacyOutcome, "captured" | "not_found" | "not_applicable" | "manual_review">;
    items: readonly PrivacyCaptureItem[];
    nextCursor?: string;
}
export interface PrivacyEraseInput {
    requestId: string;
    discordUserId: string;
    executeThrough: Date;
    cursor?: string;
}
export interface PrivacyEraseResult {
    collection: string;
    outcome: Exclude<PrivacyOutcome, "captured" | "not_applicable">;
    affectedRecords: number;
    reasonCode?: string;
}
export interface PrivacyErasePage {
    outcome: Exclude<PrivacyOutcome, "captured">;
    results: readonly PrivacyEraseResult[];
    nextCursor?: string;
}
export interface PrivacyCorrectionInput {
    requestId: string;
    itemId: string;
}
export interface PrivacyCorrectionAssessment {
    outcome: Extract<PrivacyOutcome, "retained" | "not_found" | "not_applicable" | "manual_review">;
    reasonCode?: string;
}
export interface PrivacyProviderExecutor {
    captureAccess(input: {
        providerId: string;
        providerVersion: number;
        request: PrivacyCaptureInput;
    }): Promise<PrivacyCapturePage>;
    erase(input: {
        providerId: string;
        providerVersion: number;
        request: PrivacyEraseInput;
    }): Promise<PrivacyErasePage>;
    assessCorrection(input: {
        providerId: string;
        providerVersion: number;
        request: PrivacyCorrectionInput;
    }): Promise<PrivacyCorrectionAssessment>;
}
export interface PrivacyProvider {
    readonly id: string;
    readonly version: number;
    describe(): PrivacyDataDeclaration;
    captureAccess(input: PrivacyCaptureInput): Promise<PrivacyCapturePage>;
    erase(input: PrivacyEraseInput): Promise<PrivacyErasePage>;
    assessCorrection(input: PrivacyCorrectionInput): Promise<PrivacyCorrectionAssessment>;
}
export interface ModulePrivacyContribution {
    readonly providerVersion: number;
    create(executor: PrivacyProviderExecutor, services?: ServiceAccess): PrivacyProvider;
}
export declare function getModulePrivacyDeclaration(manifest: ModuleManifest): PrivacyDataDeclaration;
export declare function createPrivacyProvider(input: {
    id: string;
    declaration: PrivacyDataDeclaration;
    executor: PrivacyProviderExecutor;
}): PrivacyProvider;
export interface ModuleActivationContext {
    guildId: string;
    services: ServiceAccess;
}
export interface SchedulableActionRequest {
    guildId: string;
    actionDocument: string;
    targetChannelId?: string;
    targetMemberUserId?: string;
    targetRoleId?: string;
    recurrenceKind: "one_time" | "interval" | "daily" | "weekly";
}
export interface SchedulableActionOutcome {
    safeCode: string;
    messageId?: string;
}
export declare class SchedulableActionUnavailableError extends Error {
    constructor(message?: string);
}
export declare function validateSchedulableActionOutcome(input: unknown): SchedulableActionOutcome;
export interface SchedulableActionDescriptor {
    id: string;
    version: number;
    name: string;
    description: string;
    recurring: boolean;
    requiredDiscordPermissions: readonly string[];
}
export interface ModuleSchedulableActionContribution extends SchedulableActionDescriptor {
    validate(request: SchedulableActionRequest, services: ServiceAccess): Promise<void>;
    preview(request: SchedulableActionRequest, services: ServiceAccess): Promise<MessageResponse>;
    execute(request: SchedulableActionRequest, services: ServiceAccess, idempotencyKey: string): Promise<SchedulableActionOutcome>;
}
export interface SchedulableActionService {
    list(): readonly SchedulableActionDescriptor[];
    get(actionId: string, version: number): SchedulableActionDescriptor | null;
    validate(input: {
        actionId: string;
        version: number;
        request: SchedulableActionRequest;
    }): Promise<void>;
    preview(input: {
        actionId: string;
        version: number;
        request: SchedulableActionRequest;
    }): Promise<MessageResponse>;
    execute(input: {
        actionId: string;
        version: number;
        request: SchedulableActionRequest;
        idempotencyKey: string;
    }): Promise<SchedulableActionOutcome>;
}
export interface ModuleConfigurationChangedContext extends ConfigurationMutationContext {
    guildId: string;
    previous: VersionedModuleConfiguration | null;
    current: VersionedModuleConfiguration;
    services: ServiceAccess;
}
/**
 * Runs before core commits a requested customer-module disablement. Modules
 * may reject the transition only for bounded, user-resolvable safety state;
 * the thrown ModuleStateValidationError must name the dashboard resolution.
 */
export interface ModuleDeactivationValidationContext extends ModuleActivationContext {
    actorUserId: string;
    correlationId: string;
    source: "discord" | "dashboard" | "control" | "system";
}
export interface PublicAchievementProjectionItem {
    definitionId: string;
    presentation: "visible" | "hidden";
    name?: string;
    description?: string;
    emoji?: string;
    sourceModuleId?: string;
    sourceModuleName?: string;
    score: number;
    target?: number;
    progress?: number;
    earned?: boolean;
    earnedAt?: string;
    awardCount?: number;
    repeatable?: boolean;
    nexusRewardAmount?: number;
    nexusRewardDisplay?: string;
}
export interface PublicAchievementProjectionPage {
    kind: "achievements";
    score?: number;
    earnedCount?: number;
    nexusBalanceLabel?: string;
    nexusBalanceDisplay?: string;
    nexusBalanceAmount?: string;
    nexusBalanceCurrencyName?: string;
    items: readonly PublicAchievementProjectionItem[];
    nextCursor?: string;
    asOf: string;
}
export interface ModulePublicProjectionContext {
    guildId: string;
    /** Present only after the API has verified current Discord membership. */
    subjectUserId?: string;
    services: ServiceAccess;
}
export interface ModulePublicProjection {
    read(context: ModulePublicProjectionContext, input: {
        cursor?: string;
        limit: number;
    }): Promise<PublicAchievementProjectionPage>;
}
export interface ModuleDefinition {
    creatorOnboarding?: CreatorOnboardingContribution;
    /** Read-only admission policy; pending/unknown never authorises a public creator role. */
    admissionGate?(input: {
        guildId: string;
        memberUserId: string;
        roleIds: readonly string[];
        services: ServiceAccess;
    }): Promise<"ready" | "pending" | "unavailable">;
    manifest: ModuleManifest;
    requiredDiscordCapabilities?: readonly ("guild-members" | "message-content")[];
    configuration?: ModuleConfigurationContribution;
    defaultPermissions?: ModulePermissionConfiguration;
    /** Executable permission targets with no command attachment. */
    permissionOperations?: readonly CommandPermissionOperation[];
    records?: Readonly<Record<string, ModuleRecordCollection>>;
    interactions?: InteractionContributions;
    sharedCommands?: readonly SharedCommandContribution[];
    nexusCommands?: readonly NexusCommandContribution[];
    events?: EventContributions;
    logging?: ModuleLoggingContribution;
    privacy?: ModulePrivacyContribution;
    scheduledTasks?: readonly ModuleScheduledTaskContribution[];
    schedulableActions?: readonly ModuleSchedulableActionContribution[];
    oauthConsumers?: readonly OAuthConsumerCleanupContribution[];
    dashboardActions?: readonly ModuleDashboardAction[];
    managedResources?: readonly ModuleManagedResource[];
    publicProjection?: ModulePublicProjection;
    moderationActionProvider?: ModerationActionProviderContributionV2;
    autoModerationEnforcementPolicyProvider?: AutoModerationEnforcementPolicyProviderContributionV1;
    autoModerationScannerProvider?: AutoModerationScannerProviderContributionV1;
    autoModerationCaseLinkProvider?: AutoModerationCaseLinkProviderContributionV1;
    exclusiveCapabilities?: readonly string[];
    validateActivation?(context: ModuleActivationContext): Promise<void>;
    onConfigurationChanged?(context: ModuleConfigurationChangedContext): Promise<void>;
    validateDeactivation?(context: ModuleDeactivationValidationContext): Promise<void>;
    onActivated?(context: ModuleActivationContext): Promise<void>;
    onDeactivated?(context: ModuleActivationContext): Promise<void>;
    start(context: RuntimeContext): Promise<void>;
    stop(context: RuntimeContext): Promise<void>;
    health?(): HealthResult | Promise<HealthResult>;
}
export declare function defineModule(module: ModuleDefinition): ModuleDefinition;
export declare function getModuleScheduledTaskContribution(module: ModuleDefinition, taskKind: string): ModuleScheduledTaskContribution | null;