import type { ActivityStore } from "./activity-log.js";
import { type DiscordAutoModerationRuleSummary, type DiscordClient } from "./discord-client.js";
import { type OperationReceipt, type OperationStore } from "./operation-store.js";
import { type DiscordPermissionName } from "./permissions.js";
import type { ScopePolicy } from "./policy.js";
import type { RequestOptions } from "./types.js";
export declare const AUTOMOD_TRIGGER_TYPES: readonly ["keyword", "keyword-preset", "member-profile", "mention-spam", "spam"];
export declare const AUTOMOD_ACTION_TYPES: readonly ["block-member-interaction", "block-message", "send-alert-message", "timeout"];
export declare const AUTOMOD_KEYWORD_PRESETS: readonly ["profanity", "sexual-content", "slurs"];
export declare const AUTOMOD_OMITTED_FIELDS: readonly ["actionExecutionContent", "matchedContent", "matchedKeyword", "rawDiscordObject"];
export type AutoModerationChangeAction = "create" | "delete" | "set-enabled" | "update";
export type AutoModerationTriggerType = typeof AUTOMOD_TRIGGER_TYPES[number];
export type AutoModerationActionType = typeof AUTOMOD_ACTION_TYPES[number];
export type AutoModerationKeywordPreset = typeof AUTOMOD_KEYWORD_PRESETS[number];
export type AutoModerationEventType = "member-update" | "message-send";
export type AutoModerationTriggerRequest = {
    allowList?: readonly string[];
    keywordFilter?: readonly string[];
    regexPatterns?: readonly string[];
    type: "keyword" | "member-profile";
} | {
    allowList?: readonly string[];
    presets: readonly AutoModerationKeywordPreset[];
    type: "keyword-preset";
} | {
    mentionRaidProtectionEnabled?: boolean;
    mentionTotalLimit: number;
    type: "mention-spam";
} | {
    type: "spam";
};
export type AutoModerationActionRequest = {
    customMessage?: string;
    type: "block-message";
} | {
    channelId: string;
    type: "send-alert-message";
} | {
    durationSeconds: number;
    type: "timeout";
} | {
    type: "block-member-interaction";
};
interface AutoModerationRequestBase {
    action: AutoModerationChangeAction;
    auditReason: string;
    guildId: string;
    operationKey: string;
}
export interface CreateAutoModerationRuleRequest extends AutoModerationRequestBase {
    action: "create";
    actions: readonly AutoModerationActionRequest[];
    exemptChannelIds?: readonly string[];
    exemptRoleIds?: readonly string[];
    name: string;
    trigger: AutoModerationTriggerRequest;
}
export interface UpdateAutoModerationRuleRequest extends AutoModerationRequestBase {
    action: "update";
    actions?: readonly AutoModerationActionRequest[];
    exemptChannelIds?: readonly string[];
    exemptRoleIds?: readonly string[];
    name?: string;
    ruleId: string;
    trigger?: AutoModerationTriggerRequest;
}
export interface SetAutoModerationRuleEnabledRequest extends AutoModerationRequestBase {
    action: "set-enabled";
    enabled: boolean;
    ruleId: string;
}
export interface DeleteAutoModerationRuleRequest extends AutoModerationRequestBase {
    action: "delete";
    ruleId: string;
}
export type AutoModerationChangeRequest = CreateAutoModerationRuleRequest | DeleteAutoModerationRuleRequest | SetAutoModerationRuleEnabledRequest | UpdateAutoModerationRuleRequest;
export type NormalizedAutoModerationTrigger = {
    allowList: string[];
    keywordFilter: string[];
    regexPatterns: string[];
    type: "keyword";
} | {
    allowList: string[];
    keywordFilter: string[];
    regexPatterns: string[];
    type: "member-profile";
} | {
    allowList: string[];
    presets: AutoModerationKeywordPreset[];
    type: "keyword-preset";
} | {
    mentionRaidProtectionEnabled: boolean;
    mentionTotalLimit: number;
    type: "mention-spam";
} | {
    type: "spam";
};
export type NormalizedAutoModerationAction = {
    customMessage: string | null;
    type: "block-message";
} | {
    channelId: string;
    type: "send-alert-message";
} | {
    durationSeconds: number;
    type: "timeout";
} | {
    type: "block-member-interaction";
};
interface NormalizedRequestBase {
    action: AutoModerationChangeAction;
    auditReason: string;
    guildId: string;
    operationKeyHash: string;
}
export type NormalizedAutoModerationChangeRequest = (NormalizedRequestBase & {
    action: "create";
    actions: NormalizedAutoModerationAction[];
    exemptChannelIds: string[];
    exemptRoleIds: string[];
    name: string;
    trigger: NormalizedAutoModerationTrigger;
}) | (NormalizedRequestBase & {
    action: "delete";
    ruleId: string;
}) | (NormalizedRequestBase & {
    action: "set-enabled";
    enabled: boolean;
    ruleId: string;
}) | (NormalizedRequestBase & {
    action: "update";
    actions?: NormalizedAutoModerationAction[];
    exemptChannelIds?: string[];
    exemptRoleIds?: string[];
    name?: string;
    ruleId: string;
    trigger?: NormalizedAutoModerationTrigger;
});
export interface ProjectedAutoModerationRule {
    actions: NormalizedAutoModerationAction[];
    creatorUserId: string;
    enabled: boolean;
    eventType: AutoModerationEventType;
    exemptChannelIds: string[];
    exemptRoleIds: string[];
    guildId: string;
    name: string;
    ruleId: string;
    trigger: NormalizedAutoModerationTrigger;
}
export type PlannedAutoModerationRule = Omit<ProjectedAutoModerationRule, "ruleId"> & {
    ruleId: string | null;
};
export interface AutoModerationPermissionEvidence {
    administrator: boolean;
    confidence: "complete";
    effectivePermissions: string;
    guildOwner: boolean;
    missingPermissions: [];
    requiredPermissions: DiscordPermissionName[];
}
export interface AutoModerationRoleReference {
    exists: boolean;
    id: string;
    name: string | null;
}
export interface AutoModerationChannelReference {
    alertAllowed: boolean;
    connectorCanView: boolean | null;
    effectivePermissions: string | null;
    exists: boolean;
    id: string;
    name: string | null;
    permissionConfidence: "complete" | null;
    type: number | null;
}
export interface AutoModerationReferenceEvidence {
    alertChannels: AutoModerationChannelReference[];
    exemptChannels: AutoModerationChannelReference[];
    exemptRoles: AutoModerationRoleReference[];
    healthy: boolean;
}
export interface AutoModerationPrivacyProjection {
    actionExecutionEventsExposed: false;
    omittedFields: typeof AUTOMOD_OMITTED_FIELDS;
    policyContentPersisted: false;
}
export interface AutoModerationInventoryRule {
    actionTypes: AutoModerationActionType[];
    creatorUserId: string;
    enabled: boolean;
    eventType: AutoModerationEventType;
    exemptChannelCount: number;
    exemptRoleCount: number;
    guildId: string;
    name: string;
    policyEntryCounts: {
        allowList: number;
        keywordFilter: number;
        presets: number;
        regexPatterns: number;
    };
    references: {
        healthy: boolean;
    };
    ruleId: string;
    triggerType: AutoModerationTriggerType;
}
export interface AutoModerationInventoryResult {
    guild: {
        id: string;
        name: string;
    };
    page: {
        returned: number;
        safetyLimit: number;
        visibility: "connector-visible";
    };
    permission: AutoModerationPermissionEvidence;
    privacy: AutoModerationPrivacyProjection;
    rules: AutoModerationInventoryRule[];
    schemaVersion: number;
    status: "ok";
}
export interface AutoModerationLookupResult {
    guild: {
        id: string;
        name: string;
    };
    permission: AutoModerationPermissionEvidence;
    privacy: AutoModerationPrivacyProjection;
    references: AutoModerationReferenceEvidence;
    rule: ProjectedAutoModerationRule;
    schemaVersion: number;
    status: "ok";
}
export interface AutoModerationPlan {
    action: AutoModerationChangeAction;
    applicationId: string;
    auditReason: string;
    botId: string;
    capacity: {
        inventoryDigest: string;
        limitForTrigger: number;
        observedForTrigger: number;
        safetyLimit: number;
        visibleRules: number;
    } | null;
    createdAt: string;
    desired: PlannedAutoModerationRule | null;
    digest: string;
    effect: "create" | "delete" | "none" | "set-enabled" | "update";
    existing: ProjectedAutoModerationRule | null;
    guild: {
        id: string;
        name: string;
    };
    operationKeyHash: string;
    permission: AutoModerationPermissionEvidence;
    privacy: AutoModerationPrivacyProjection;
    references: {
        desired: AutoModerationReferenceEvidence | null;
        existing: AutoModerationReferenceEvidence | null;
    };
    schemaVersion: number;
    status: "already-current" | "planned";
    warnings: string[];
}
export interface AutoModerationResult {
    action: AutoModerationChangeAction;
    activityId: string | null;
    guildId: string;
    observed: ProjectedAutoModerationRule | null;
    operationKeyHash: string;
    planDigest: string;
    ruleId: string;
    schemaVersion: number;
    status: "already-current" | "completed" | "completed-with-drift";
}
export type AutoModerationVerificationReason = "operation-failed" | "operation-not-found" | "operation-pending" | "operation-uncertain" | "receipt-target-mismatch" | "request-mismatch" | "rule-missing" | "rule-state-mismatch" | "rule-still-present";
export interface AutoModerationVerificationResult {
    action: AutoModerationChangeAction;
    activityId: string | null;
    guildId: string;
    operationKeyHash: string;
    planDigest: string | null;
    readbackMatched: boolean;
    reason: AutoModerationVerificationReason | null;
    receiptStatus: OperationReceipt["status"] | null;
    requestMatched: boolean;
    ruleId: string | null;
    schemaVersion: number;
    status: "blocked" | "drifted" | "not-found" | "verified";
    timestamp: string | null;
}
export interface AutoModerationServiceClient extends Pick<DiscordClient, "createGuildAutoModerationRule" | "deleteGuildAutoModerationRule" | "getGuild" | "getGuildAutoModerationRule" | "getGuildChannels" | "getGuildMember" | "getGuildRoles" | "listGuildAutoModerationRules" | "modifyGuildAutoModerationRule"> {
}
export interface AutoModerationServiceOptions {
    activityStore: ActivityStore;
    client: AutoModerationServiceClient;
    clock?: () => Date;
    operationStore: OperationStore;
    planKey?: Uint8Array;
    policy: ScopePolicy;
    randomId?: () => string;
    verificationKey?: Uint8Array;
}
export declare function normalizeAutoModerationChangeRequest(request: AutoModerationChangeRequest): NormalizedAutoModerationChangeRequest;
export declare function autoModerationVerificationKey(token: string): Uint8Array;
export declare function autoModerationRequestDigest(key: Uint8Array, applicationId: string, botId: string, request: NormalizedAutoModerationChangeRequest): string;
export declare function projectAutoModerationRuleInventory(rules: readonly DiscordAutoModerationRuleSummary[], guildId: string): ProjectedAutoModerationRule[];
export declare class AutoModerationService {
    #private;
    constructor(options: AutoModerationServiceOptions);
    list(botId: string, guildId: string, options?: RequestOptions): Promise<AutoModerationInventoryResult>;
    get(botId: string, guildId: string, ruleId: string, options?: RequestOptions): Promise<AutoModerationLookupResult>;
    plan(applicationId: string, botId: string, request: AutoModerationChangeRequest, options?: RequestOptions): Promise<AutoModerationPlan>;
    verify(applicationId: string, botId: string, request: AutoModerationChangeRequest, options?: RequestOptions): Promise<AutoModerationVerificationResult>;
    execute(applicationId: string, botId: string, request: AutoModerationChangeRequest, expectedDigest: string, options?: RequestOptions): Promise<AutoModerationResult>;
}
export {};
//# sourceMappingURL=automod-service.d.ts.map