import type { ServiceAccess } from "./index.js";
import type { ModerationRepeatActionPolicy } from "./moderation.js";
import type { ViolationEvidenceReference } from "./violation-threads.js";
export declare const AUTOMOD_ENHANCED_PROVIDER_ID = "helyx.automod-enhanced";
export declare const AUTOMOD_ENHANCED_CONFIG_PROTOCOL = "helyx.automod-enhanced-config/v1";
export declare const AUTOMOD_ENHANCED_RESULT_PROTOCOL = "helyx.automod-enhanced-result/v1";
export declare const AUTOMOD_ENHANCED_EVIDENCE_PROTOCOL = "helyx.automod-enhanced-evidence/v1";
export declare const AUTOMOD_ENHANCED_CONTRACT_VERSION = 1;
export declare const AUTOMOD_CASE_LINK_PROVIDER_ID = "helyx.automod-case-links";
export declare const AUTOMOD_CASE_LINK_CONTRACT_VERSION = 1;
export declare const AUTOMOD_SCANNER_LIMITS: Readonly<{
    configurationPageServers: 100;
    configurationPageBytes: 1048576;
    resultBytes: 8192;
    messageUtf8Bytes: 32768;
    messageCharacters: 2000;
    clockSkewSeconds: 30;
    actionDeadlineSeconds: 5;
    resultAcknowledgementSeconds: 30;
    evidenceBytes: 32768;
    evidenceDeadlineSeconds: 5;
}>;
export type DiscordAutoModerationKeywordPreset = "profanity" | "sexual_content" | "slurs";
export type DiscordAutoModerationTrigger = {
    type: "keyword";
    keywordFilter: readonly string[];
    regexPatterns: readonly string[];
    allowList: readonly string[];
} | {
    type: "spam";
} | {
    type: "keyword_preset";
    presets: readonly DiscordAutoModerationKeywordPreset[];
    allowList: readonly string[];
} | {
    type: "mention_spam";
    mentionTotalLimit: number;
    mentionRaidProtectionEnabled: boolean;
};
export type DiscordAutoModerationAction = {
    type: "block_message";
    customMessage?: string;
} | {
    type: "send_alert_message";
    channelId: string;
} | {
    type: "timeout";
    durationSeconds: number;
};
export interface DiscordAutoModerationRuleDefinition {
    name: string;
    enabled: boolean;
    eventType: "message_send";
    trigger: DiscordAutoModerationTrigger;
    actions: readonly DiscordAutoModerationAction[];
    exemptRoleIds: readonly string[];
    exemptChannelIds: readonly string[];
}
export interface DiscordAutoModerationRuleSnapshot extends DiscordAutoModerationRuleDefinition {
    guildId: string;
    ruleId: string;
    creatorUserId: string;
}
export type DiscordAutoModerationMutationOutcome = "succeeded" | "already_applied" | "already_absent" | "missing_permission" | "capacity_exceeded" | "invalid_rule" | "failed" | "ambiguous";
export type DiscordAutoModerationMutationResult = {
    outcome: "succeeded";
    rule: DiscordAutoModerationRuleSnapshot | null;
} | {
    outcome: "already_applied";
    rule: DiscordAutoModerationRuleSnapshot;
} | {
    outcome: "already_absent";
} | {
    outcome: Exclude<DiscordAutoModerationMutationOutcome, "succeeded" | "already_applied" | "already_absent">;
    safeCode?: string;
};
/** Guild-owner-routed native Discord Auto Moderation adapter. */
export interface DiscordAutoModerationService {
    list(input: {
        guildId: string;
    }): Promise<readonly DiscordAutoModerationRuleSnapshot[]>;
    read(input: {
        guildId: string;
        ruleId: string;
    }): Promise<DiscordAutoModerationRuleSnapshot | null>;
    create(input: {
        guildId: string;
        callerModuleId: string;
        operationKey: string;
        rule: DiscordAutoModerationRuleDefinition;
        revalidate(): Promise<boolean>;
    }): Promise<DiscordAutoModerationMutationResult>;
    update(input: {
        guildId: string;
        ruleId: string;
        callerModuleId: string;
        operationKey: string;
        rule: DiscordAutoModerationRuleDefinition;
        revalidate(): Promise<boolean>;
    }): Promise<DiscordAutoModerationMutationResult>;
    delete(input: {
        guildId: string;
        ruleId: string;
        callerModuleId: string;
        operationKey: string;
        revalidate(): Promise<boolean>;
    }): Promise<DiscordAutoModerationMutationResult>;
}
export interface DiscordAutoModerationRuleEventContext {
    serverId: string;
    rule: DiscordAutoModerationRuleSnapshot;
    services: ServiceAccess;
}
export interface DiscordAutoModerationRuleCreateContribution {
    type: "discord.auto-moderation-rule-create";
    execute(context: DiscordAutoModerationRuleEventContext): Promise<void>;
}
export interface DiscordAutoModerationRuleUpdateContribution {
    type: "discord.auto-moderation-rule-update";
    execute(context: DiscordAutoModerationRuleEventContext): Promise<void>;
}
export interface DiscordAutoModerationRuleDeleteContribution {
    type: "discord.auto-moderation-rule-delete";
    execute(context: DiscordAutoModerationRuleEventContext): Promise<void>;
}
export interface DiscordAutoModerationActionExecutionContext {
    serverId: string;
    ruleId: string;
    userId: string;
    channelId: string | null;
    messageId: string | null;
    alertSystemMessageId: string | null;
    action: DiscordAutoModerationAction;
    executionId: string;
    evidenceReference: ViolationEvidenceReference | null;
    occurredAt: Date;
    services: ServiceAccess;
}
export interface DiscordAutoModerationActionExecutionContribution {
    type: "discord.auto-moderation-action-execution";
    execute(context: DiscordAutoModerationActionExecutionContext): Promise<void>;
}
export type AutoModerationSeverity = "low" | "medium" | "high" | "critical";
export type AutoModerationDetectionMethod = "exact" | "phrase" | "wildcard" | "safe_regex" | "normalised" | "fuzzy" | "similar_message";
export type AutoModerationConfidenceClass = "exact" | "native_equivalent" | "high" | "medium" | "low";
export type AutoModerationScannerTermKind = "word" | "phrase" | "wildcard" | "safe_regex" | "similar_message";
export interface AutoModerationScannerTermV1 {
    termId: string;
    kind: AutoModerationScannerTermKind;
    value: string;
    allowList: readonly string[];
    normalisedMatching: boolean;
    fuzzyMatching: boolean;
    minimumConfidence?: number;
}
export interface AutoModerationScannerRuleV1 {
    ruleId: string;
    name: string;
    categoryId: string;
    severity: AutoModerationSeverity;
    terms: readonly AutoModerationScannerTermV1[];
    exemptRoleIds: readonly string[];
    exemptChannelIds: readonly string[];
    actionPolicy: ModerationRepeatActionPolicy;
    openViolationThread: boolean;
}
export interface AutoModerationScannerConfigurationV1 {
    guildId: string;
    configurationRevision: string;
    fingerprint: string;
    engineVersion: string;
    scoringVersion: string;
    categoryThresholds: Readonly<Record<AutoModerationSeverity, number>>;
    rules: readonly AutoModerationScannerRuleV1[];
    refreshAfter: string;
    expiresAt: string;
}
export interface AutoModerationScannerConfigurationPageV1 {
    protocol: typeof AUTOMOD_ENHANCED_CONFIG_PROTOCOL;
    providerId: typeof AUTOMOD_ENHANCED_PROVIDER_ID;
    contractVersion: typeof AUTOMOD_ENHANCED_CONTRACT_VERSION;
    snapshotFingerprint: string;
    items: readonly AutoModerationScannerConfigurationV1[];
    nextCursor?: string;
}
export interface AutoModerationEnhancedResultV1 {
    protocol: typeof AUTOMOD_ENHANCED_RESULT_PROTOCOL;
    providerId: typeof AUTOMOD_ENHANCED_PROVIDER_ID;
    contractVersion: typeof AUTOMOD_ENHANCED_CONTRACT_VERSION;
    detectorVersion: string;
    scoringVersion: string;
    operationId: string;
    nonce: string;
    issuedAt: string;
    deadlineAt: string;
    environment: string;
    guildId: string;
    channelId: string;
    parentChannelId: string | null;
    messageId: string;
    authorUserId: string;
    observation: {
        type: "create" | "edit";
        version: string;
        observedAt: string;
    };
    ruleId: string;
    categoryId: string;
    termId: string;
    configurationRevision: string;
    severity: AutoModerationSeverity;
    method: AutoModerationDetectionMethod;
    confidenceScore: number;
    confidenceClass: AutoModerationConfidenceClass;
    effectiveThreshold: number;
    correlationId: string;
}
/**
 * Separate, immediate-expiry transport accepted only by the core evidence
 * adapter. It is never a scanner result and is never exposed to module code.
 */
export interface AutoModerationEnhancedEvidenceEnvelopeV1 {
    protocol: typeof AUTOMOD_ENHANCED_EVIDENCE_PROTOCOL;
    providerId: typeof AUTOMOD_ENHANCED_PROVIDER_ID;
    contractVersion: typeof AUTOMOD_ENHANCED_CONTRACT_VERSION;
    operationId: string;
    nonce: string;
    issuedAt: string;
    deadlineAt: string;
    environment: string;
    guildId: string;
    channelId: string;
    messageId: string;
    authorUserId: string;
    configurationRevision: string;
    content: string;
}
export type AutoModerationEnhancedResultOutcome = {
    outcome: "accepted" | "duplicate";
    operationId: string;
} | {
    outcome: "rejected";
    code: "invalid_envelope" | "unknown_version" | "stale" | "replay" | "wrong_owner" | "module_unavailable" | "feature_unavailable" | "stale_revision" | "source_unresolved" | "source_exempt" | "below_threshold";
};
export type AutoModerationScannerAdapterSelection = {
    adapter: "hosted_ecko";
    available: true;
} | {
    adapter: "embedded";
    available: true;
} | {
    adapter: "unavailable";
    available: false;
    reason: "feature_unavailable" | "capability_unavailable" | "dependency_unhealthy";
};
/** Deployment-wide selection; modules never branch on Railway or process shape. */
export interface AutoModerationScannerAdapterService {
    select(input: {
        guildId: string;
        moduleId: string;
        featureId: string;
    }): Promise<AutoModerationScannerAdapterSelection>;
}
export interface AutoModerationScannerObservation {
    guildId: string;
    channelId: string;
    parentChannelId: string | null;
    messageId: string;
    authorUserId: string;
    memberRoleIds: readonly string[];
    content: string;
    source: "user" | "bot" | "webhook" | "system" | "unknown";
    type: "create" | "edit";
    version: string;
    observedAt: string;
}
export interface AutoModerationScannerObservationService {
    /** Refreshes the atomic provider snapshot after activation or configuration. */
    synchronize(): Promise<void>;
    /** Process-local, non-authoritative intake hint used before queueing content. */
    isConfigured(guildId: string): boolean;
    /** Queues one bounded observation without exposing deployment selection. */
    observe(input: AutoModerationScannerObservation): boolean;
}
/** Core-owned closed registry used by scanner transports and embedded adapters. */
export interface AutoModerationScannerProviderRegistryService extends AutoModerationScannerAdapterService {
    getConfigurationPage(input: {
        adapter: "hosted_ecko" | "embedded";
        providerId: typeof AUTOMOD_ENHANCED_PROVIDER_ID;
        contractVersion: typeof AUTOMOD_ENHANCED_CONTRACT_VERSION;
        cursor?: string;
        limit: number;
        knownFingerprint?: string;
    }): Promise<AutoModerationScannerConfigurationPageV1>;
    acceptResult(input: {
        adapter: "hosted_ecko" | "embedded";
        providerId: typeof AUTOMOD_ENHANCED_PROVIDER_ID;
        contractVersion: typeof AUTOMOD_ENHANCED_CONTRACT_VERSION;
        result: unknown;
        evidenceReference?: ViolationEvidenceReference;
    }): Promise<AutoModerationEnhancedResultOutcome>;
}
export interface AutoModerationScannerProviderContext {
    services: ServiceAccess;
}
export interface AutoModerationScannerResultContext extends AutoModerationScannerProviderContext {
    evidenceReference: ViolationEvidenceReference | null;
}
/** Closed provider owned by Auto Moderation and allowlisted by core. */
export interface AutoModerationScannerProviderContributionV1 {
    providerId: typeof AUTOMOD_ENHANCED_PROVIDER_ID;
    contractVersion: typeof AUTOMOD_ENHANCED_CONTRACT_VERSION;
    configurationProtocol: typeof AUTOMOD_ENHANCED_CONFIG_PROTOCOL;
    resultProtocol: typeof AUTOMOD_ENHANCED_RESULT_PROTOCOL;
    evidenceProtocol: typeof AUTOMOD_ENHANCED_EVIDENCE_PROTOCOL;
    getConfigurationPage(context: AutoModerationScannerProviderContext, input: {
        cursor?: string;
        limit: number;
        knownFingerprint?: string;
    }): Promise<AutoModerationScannerConfigurationPageV1>;
    validateResult(input: unknown): AutoModerationEnhancedResultV1;
    handleResult(context: AutoModerationScannerResultContext, result: AutoModerationEnhancedResultV1): Promise<AutoModerationEnhancedResultOutcome>;
}
/** Auto Moderation-owned case-link cleanup; no former subject identity crosses it. */
export interface AutoModerationCaseLinkProviderContributionV1 {
    providerId: typeof AUTOMOD_CASE_LINK_PROVIDER_ID;
    contractVersion: typeof AUTOMOD_CASE_LINK_CONTRACT_VERSION;
    disassociateCase(context: AutoModerationScannerProviderContext, input: {
        guildId: string;
        moderationCaseId: string;
        occurredAt: Date;
    }): Promise<{
        detachedRecords: number;
    }>;
}