import type { ActivityStore } from "./activity-log.js";
import { type DiscordClient } from "./discord-client.js";
import { type OperationStore } from "./operation-store.js";
import { type DiscordChannelPermissionName, type DiscordPermissionName } from "./permissions.js";
import type { ScopePolicy } from "./policy.js";
import { normalizeChannel } from "./normalize.js";
import type { RequestOptions } from "./types.js";
export declare const CHANNEL_PERMISSION_OVERWRITE_MODES: readonly ["delete", "update"];
export declare const CHANNEL_PERMISSION_OVERWRITE_STATES: readonly ["allow", "deny", "inherit"];
export declare const CHANNEL_PERMISSION_OVERWRITE_TARGET_TYPES: readonly ["member", "role"];
export type ChannelPermissionOverwriteMode = typeof CHANNEL_PERMISSION_OVERWRITE_MODES[number];
export type ChannelPermissionOverwriteState = typeof CHANNEL_PERMISSION_OVERWRITE_STATES[number];
export type ChannelPermissionOverwriteTargetType = typeof CHANNEL_PERMISSION_OVERWRITE_TARGET_TYPES[number];
export interface ChannelPermissionOverwriteChange {
    permission: DiscordChannelPermissionName;
    state: ChannelPermissionOverwriteState;
}
interface ChannelPermissionOverwriteRequestBase {
    auditReason: string;
    channelId: string;
    operationKey: string;
    targetId: string;
    targetType: ChannelPermissionOverwriteTargetType;
}
export type ChannelPermissionOverwriteRequest = (ChannelPermissionOverwriteRequestBase & {
    changes?: undefined;
    mode: "delete";
}) | (ChannelPermissionOverwriteRequestBase & {
    changes: readonly ChannelPermissionOverwriteChange[];
    mode: "update";
});
export interface NormalizedChannelPermissionOverwriteRequest extends ChannelPermissionOverwriteRequestBase {
    changes: ChannelPermissionOverwriteChange[];
    mode: ChannelPermissionOverwriteMode;
    operationKeyHash: string;
    targetTypeCode: 0 | 1;
}
export interface ChannelPermissionOverwriteView {
    allow: string;
    allowPermissions: DiscordPermissionName[];
    deny: string;
    denyPermissions: DiscordPermissionName[];
    targetId: string;
    targetType: ChannelPermissionOverwriteTargetType;
    unknownAllow: string;
    unknownDeny: string;
}
export interface ChannelPermissionOverwriteListResult {
    inherited: boolean;
    page: {
        hasMore: boolean;
        nextAfterTargetId: string | null;
        requestedLimit: number;
        returned: number;
        total: number;
    };
    requestedChannel: ReturnType<typeof normalizeChannel>;
    schemaVersion: number;
    sourceChannel: ReturnType<typeof normalizeChannel>;
    status: "ok";
    overwrites: ChannelPermissionOverwriteView[];
}
export type ChannelPermissionDecision = "allowed" | "denied" | "ineffective" | "unknown";
export interface ChannelPermissionImpact {
    after: ChannelPermissionDecision;
    before: ChannelPermissionDecision;
    permission: DiscordChannelPermissionName;
}
export interface ChannelPermissionOverwritePlan {
    action: "delete" | "none" | "put";
    applicationId: string;
    auditReason: string;
    botId: string;
    botPermission: {
        afterEffectivePermissions: string;
        beforeEffectivePermissions: string;
        confidence: "complete";
        manageRolesAfter: true;
        manageRolesBefore: true;
        viewChannelAfter: true;
        viewChannelBefore: true;
    };
    changes: ChannelPermissionOverwriteChange[];
    channel: ReturnType<typeof normalizeChannel>;
    createdAt: string;
    currentOverwrite: ChannelPermissionOverwriteView | null;
    desiredOverwrite: ChannelPermissionOverwriteView | null;
    digest: string;
    evaluatedPermissions: DiscordChannelPermissionName[];
    guild: {
        id: string;
        name: string;
    };
    operationKeyHash: string;
    parentSync: {
        after: boolean | null;
        before: boolean | null;
        parentChannelId: string | null;
    };
    requestedMode: ChannelPermissionOverwriteMode;
    schemaVersion: number;
    status: "already-current" | "planned";
    target: {
        id: string;
        name: string;
        type: ChannelPermissionOverwriteTargetType;
    };
    targetAccess: {
        basis: "member-effective" | "standalone-role-baseline";
        impacts: ChannelPermissionImpact[];
    };
    warnings: string[];
}
export interface ChannelPermissionOverwriteResult {
    activityId: string | null;
    channelId: string;
    guildId: string;
    observedOverwrite: ChannelPermissionOverwriteView | null;
    operationKeyHash: string;
    overwriteSetMatched: boolean;
    planDigest: string;
    schemaVersion: number;
    status: "already-current" | "completed" | "completed-with-drift";
    targetId: string;
    targetMatched: boolean;
    targetType: ChannelPermissionOverwriteTargetType;
}
export interface ChannelPermissionSyncRequest {
    acknowledgeConcurrentPermissionChangesStopped: true;
    acknowledgeFutureParentPropagation: true;
    acknowledgeOverwriteReplacement: true;
    auditReason: string;
    channelId: string;
    operationKey: string;
}
export interface NormalizedChannelPermissionSyncRequest extends ChannelPermissionSyncRequest {
    operationKeyHash: string;
}
export interface ChannelPermissionSyncChange {
    after: ChannelPermissionOverwriteView | null;
    before: ChannelPermissionOverwriteView | null;
    roleName: string | null;
    targetId: string;
    targetType: ChannelPermissionOverwriteTargetType;
}
export interface ChannelPermissionSyncAuthority {
    confidence: "complete";
    effectivePermissions: string;
    manageChannels: boolean;
    manageRoles: boolean;
    viewChannel: boolean;
}
export interface ChannelPermissionSyncPlan {
    acknowledgments: {
        concurrentPermissionChangesStopped: true;
        futureParentPropagation: true;
        overwriteReplacement: true;
    };
    action: "none" | "replace";
    applicationId: string;
    auditReason: string;
    authority: {
        currentChild: ChannelPermissionSyncAuthority;
        parent: ChannelPermissionSyncAuthority;
        prospectiveChild: ChannelPermissionSyncAuthority;
    };
    botId: string;
    changes: ChannelPermissionSyncChange[];
    channel: ReturnType<typeof normalizeChannel>;
    createdAt: string;
    digest: string;
    guild: {
        id: string;
        name: string;
    };
    operationKeyHash: string;
    overwriteCounts: {
        changed: number;
        currentChild: number;
        parent: number;
    };
    parent: ReturnType<typeof normalizeChannel>;
    privacy: {
        memberProfilesFetched: false;
        persistedOverwriteTargets: false;
        targetImpactAnalysis: "structural-only";
    };
    schemaVersion: number;
    status: "already-synchronized" | "planned";
    warnings: string[];
}
export interface ChannelPermissionSyncResult {
    activityId: string | null;
    channelId: string;
    evidenceMatched: boolean;
    guildId: string;
    operationKeyHash: string;
    parentBaselineMatched: boolean;
    parentChannelId: string;
    planDigest: string;
    responseMatched: boolean;
    schemaVersion: number;
    status: "already-synchronized" | "completed" | "completed-with-drift";
    synchronized: boolean;
}
export interface ChannelPermissionOverwriteListOptions extends RequestOptions {
    afterTargetId?: string;
    limit?: number;
}
export interface ChannelPermissionOverwriteServiceClient extends Pick<DiscordClient, "deleteChannelPermissionOverwrite" | "editChannelPermissionOverwrite" | "getChannel" | "getGuild" | "getGuildMember" | "getGuildRoles"> {
    replaceChannelPermissionOverwrites?: DiscordClient["replaceChannelPermissionOverwrites"];
}
export interface ChannelPermissionOverwriteServiceOptions {
    activityStore: ActivityStore;
    client: ChannelPermissionOverwriteServiceClient;
    clock?: () => Date;
    operationStore: OperationStore;
    planKey?: Uint8Array;
    policy: ScopePolicy;
    randomId?: () => string;
}
export declare function normalizeChannelPermissionOverwriteRequest(request: ChannelPermissionOverwriteRequest): NormalizedChannelPermissionOverwriteRequest;
export declare function normalizeChannelPermissionSyncRequest(request: ChannelPermissionSyncRequest): NormalizedChannelPermissionSyncRequest;
export declare class ChannelPermissionOverwriteService {
    #private;
    constructor(options: ChannelPermissionOverwriteServiceOptions);
    list(channelId: string, options?: ChannelPermissionOverwriteListOptions): Promise<ChannelPermissionOverwriteListResult>;
    plan(applicationId: string, botId: string, request: ChannelPermissionOverwriteRequest, options?: RequestOptions): Promise<ChannelPermissionOverwritePlan>;
    reconcilePlan(applicationId: string, botId: string, request: ChannelPermissionOverwriteRequest, options?: RequestOptions): Promise<ChannelPermissionOverwritePlan>;
    execute(applicationId: string, botId: string, request: ChannelPermissionOverwriteRequest, expectedDigest: string, options?: RequestOptions): Promise<ChannelPermissionOverwriteResult>;
    planSync(applicationId: string, botId: string, request: ChannelPermissionSyncRequest, options?: RequestOptions): Promise<ChannelPermissionSyncPlan>;
    executeSync(applicationId: string, botId: string, request: ChannelPermissionSyncRequest, expectedDigest: string, options?: RequestOptions): Promise<ChannelPermissionSyncResult>;
}
export {};
//# sourceMappingURL=channel-permission-overwrite-service.d.ts.map