import type { ActivityStore } from "./activity-log.js";
import { type DiscordClient } from "./discord-client.js";
import type { GatewayChannelLayoutSource } from "./gateway-channel-layout.js";
import { type GuildChannelEvidenceView } from "./guild-channel-evidence.js";
import { type OperationStore } from "./operation-store.js";
import { type DiscordPermissionName } from "./permissions.js";
import type { ScopePolicy } from "./policy.js";
import { type PrivateCapabilityFileSystem, type PrivateCapabilityTargetReview } from "./private-capability-file.js";
import type { RequestOptions } from "./types.js";
declare const INVITE_CAPABILITY_FILE_FORMAT = "discord-invite-capability.v3";
declare const VANITY_LOCAL_CONSTRAINTS: Readonly<{
    codeCharacters: 256;
    codeDisclosure: "explicit-tool-opt-in";
}>;
export declare const INVITE_OMITTED_FIELDS: readonly ["approximateCounts", "code", "guildObject", "guildScheduledEvent", "inviterProfile", "rawDiscordObject", "roleNames", "roleVisuals", "stageInstance", "targetApplicationMetadata", "targetUserAcceptance", "targetUserProfile", "url"];
export interface InviteListOptions extends RequestOptions {
    cursor?: string;
    limit?: number;
}
export interface GuildVanityUrlOptions extends RequestOptions {
    includeCode?: boolean;
}
export interface InviteDeletionRequest {
    auditReason: string;
    guildId: string;
    inviteRef: string;
    operationKey: string;
}
export interface NormalizedInviteDeletionRequest extends InviteDeletionRequest {
    operationKeyHash: string;
}
export interface InviteChannelProjection {
    id: string;
    name: string;
    type: number;
}
export interface InviteGrantedRoleProjection {
    highRiskPermissions: DiscordPermissionName[];
    permissionNames: DiscordPermissionName[];
    permissions: string;
    roleId: string;
    unknownPermissionBits: string;
}
export interface ProjectedInvite {
    channel: InviteChannelProjection;
    createdAt: string;
    expiresAt: string | null;
    flags: {
        guest: boolean;
        raw: number;
        unknownBits: string;
    };
    inviteRef: string;
    inviterUserId: string | null;
    maxAgeSeconds: number;
    maxUses: number;
    riskFlags: string[];
    roles: InviteGrantedRoleProjection[];
    target: {
        id: string;
        kind: "embedded-application" | "stream";
    } | null;
    temporaryMembership: boolean;
    uses: number;
}
export interface InviteAccessEvidence {
    appliedRoleIds: string[];
    botAdministrator: boolean;
    botIsGuildOwner: boolean;
    complete: true;
    effectivePermissionNames: DiscordPermissionName[];
    effectivePermissions: string;
    manageGuild: true;
    requiredPermission: "MANAGE_GUILD";
    unknownPermissionBits: string;
}
export interface InvitePrivacyProjection {
    capabilitiesProjectedOut: true;
    omittedFields: typeof INVITE_OMITTED_FIELDS;
    persistence: "none";
    rawPayloads: "omitted";
}
export interface InviteInventoryResult {
    access: InviteAccessEvidence;
    applicationId: string;
    botId: string;
    guild: {
        id: string;
        name: string;
    };
    invites: ProjectedInvite[];
    page: {
        cursor: string | null;
        hasMore: boolean;
        nextCursor: string | null;
        requestedLimit: number;
        returned: number;
        safetyLimit: number;
    };
    privacy: InvitePrivacyProjection;
    schemaVersion: number;
    status: "ok";
}
export interface InviteLookupResult extends Omit<InviteInventoryResult, "invites" | "page"> {
    invite: ProjectedInvite;
}
export interface GuildVanityUrlAuditResult {
    access: InviteAccessEvidence;
    applicationId: string;
    botId: string;
    guildId: string;
    localConstraints: typeof VANITY_LOCAL_CONSTRAINTS;
    privacy: {
        code: "explicit-transient-opt-in";
        inviteUrl: "omitted";
        persistence: "none";
        rawPayloads: "omitted";
        unknownFields: "counts-only";
    };
    schemaVersion: number;
    status: "ok";
    vanity: {
        code: string | null;
        codeDisclosure: "included" | "omitted";
        configured: boolean;
        eligible: boolean;
        unknownFieldCount: number | null;
        uses: number | null;
    };
    verification: {
        endpointCalled: boolean;
        guildCrossCheck: "match" | "not-applicable";
        writePerformed: false;
    };
}
export interface InviteDeletionPlan {
    access: InviteAccessEvidence;
    action: "delete";
    applicationId: string;
    auditReason: string;
    botId: string;
    createdAt: string;
    digest: string;
    guild: {
        id: string;
        name: string;
    };
    operationKeyHash: string;
    privacy: InvitePrivacyProjection;
    schemaVersion: number;
    status: "planned";
    target: ProjectedInvite;
    visibleInventory: {
        channelLimit: number;
        channels: number;
        inviteLimit: number;
        invites: number;
        roleLimit: number;
        roles: number;
    };
    warnings: string[];
}
export interface InviteDeletionResult {
    activityId: string;
    channelId: string;
    guildId: string;
    inviteRef: string;
    operationKeyHash: string;
    planDigest: string;
    schemaVersion: number;
    status: "completed" | "completed-with-drift";
    verifiedAbsent: boolean;
}
export interface InviteCreationRequest {
    acceptance: {
        kind: "bearer";
    } | {
        kind: "exact-users";
        userIds: string[];
    };
    acknowledgeBearerCapability: true;
    auditReason: string;
    channelId: string;
    guildId: string;
    maxAgeSeconds: number;
    maxUses: number;
    operationKey: string;
    outputFile: string;
    roleAssignment: {
        kind: "none";
    } | {
        acknowledgePersistentGrants: true;
        kind: "grant";
        roleIds: string[];
    };
    temporaryMembership: boolean;
}
export interface NormalizedInviteCreationRequest extends Omit<InviteCreationRequest, "acceptance"> {
    acceptance: {
        kind: "bearer";
    } | {
        kind: "exact-users";
        userIds: string[];
    };
    operationKeyHash: string;
}
export interface InviteCreationAccessEvidence {
    appliedRoleIds: string[];
    botAdministrator: boolean;
    botHighestRoleIds: string[];
    botHighestRolePosition: number;
    botIsGuildOwner: boolean;
    complete: true;
    createInstantInvite: true;
    effectivePermissionNames: DiscordPermissionName[];
    effectivePermissions: string;
    manageGuild: boolean;
    manageRoles: boolean;
    requiredPermissions: readonly DiscordPermissionName[];
    unknownPermissionBits: string;
    viewChannel: true;
}
export interface InviteCreationPlan {
    access: InviteCreationAccessEvidence;
    action: "create";
    applicationId: string;
    auditReason: string;
    botId: string;
    createdAt: string;
    delivery: {
        format: typeof INVITE_CAPABILITY_FILE_FORMAT;
        outputFile: string;
        review: PrivateCapabilityTargetReview;
    };
    digest: string;
    guild: {
        id: string;
        name: string;
    };
    intent: {
        acceptance: NormalizedInviteCreationRequest["acceptance"];
        maxAgeSeconds: number;
        maxUses: number;
        roleAssignment: NormalizedInviteCreationRequest["roleAssignment"];
        temporaryMembership: boolean;
        unique: true;
    };
    operationKeyHash: string;
    privacy: {
        capabilityDelivery: "private-file-only";
        mcpResult: "credential-free";
        persistence: "content-free-lifecycle-only";
        rawDiscordPayloads: "omitted";
    };
    roleAssignment: InviteRoleAssignmentReview;
    schemaVersion: number;
    status: "planned";
    target: InviteChannelProjection & {
        permissionOverwriteCount: number;
    };
    visibleInventory: {
        channelLimit: number;
        channels: number;
        roleLimit: number;
        roles: number;
    };
    warnings: string[];
}
export interface InviteCreationResult {
    acceptance: {
        kind: "bearer" | "exact-users";
        targetUserCount: number;
    };
    activityId: string;
    capabilityFileWritten: true;
    channelId: string;
    guildId: string;
    inviteRef: string;
    operationKeyHash: string;
    outputFile: string;
    planDigest: string;
    roleAssignment: {
        kind: "none";
        roleCount: 0;
    } | {
        kind: "grant";
        roleCount: number;
        roleIds: string[];
    };
    schemaVersion: number;
    status: "completed";
    verified: true;
}
export interface InviteServiceClient extends Pick<DiscordClient, "createChannelInvite" | "deleteInvite" | "getGuild" | "getGuildChannels" | "getGuildMember" | "getGuildRoles" | "getGuildVanityUrl" | "getInvite" | "getInviteTargetUserIds" | "getInviteTargetUsersJobStatus" | "listGuildInvites"> {
}
export interface InviteServiceOptions {
    activityStore: ActivityStore;
    capabilityRoots?: readonly string[];
    client: InviteServiceClient;
    clock?: () => Date;
    layoutSource?: GatewayChannelLayoutSource;
    operationStore: OperationStore;
    planKey?: Uint8Array;
    policy: Pick<ScopePolicy, "assertGuildInviteAuditable" | "assertGuildInviteCreatable" | "assertGuildInviteDeletable" | "assertInviteRoleAssignmentAllowed">;
    privateFileSystem?: PrivateCapabilityFileSystem;
    randomId?: () => string;
    sleep?: (milliseconds: number, signal?: AbortSignal) => Promise<void>;
}
type InviteRolePermissionDecision = "allowed" | "denied" | "ineffective";
interface InviteRolePermissionChange {
    after: InviteRolePermissionDecision;
    before: InviteRolePermissionDecision;
    permission: DiscordPermissionName;
}
interface InviteRoleChannelImpact {
    channelId: string;
    channelName: string;
    channelType: number;
    changes: InviteRolePermissionChange[];
}
interface InviteRoleGuildPermissionImpact {
    added: DiscordPermissionName[];
    after: DiscordPermissionName[];
    before: DiscordPermissionName[];
}
interface InviteAssignedRoleProjection {
    highRiskPermissions: DiscordPermissionName[];
    id: string;
    name: string;
    permissionNames: DiscordPermissionName[];
    permissions: string;
    position: number;
}
type InviteRoleAssignmentReview = {
    kind: "none";
} | {
    acknowledgePersistentGrants: true;
    assignedRoles: InviteAssignedRoleProjection[];
    channelEvidence: GuildChannelEvidenceView;
    highRiskPermissionGains: DiscordPermissionName[];
    impact: {
        changedChannels: number;
        channels: InviteRoleChannelImpact[];
        evaluatedChannels: number;
        guildPermissions: InviteRoleGuildPermissionImpact;
        projection: "minimum-new-member";
    };
    kind: "grant";
    persistence: "manual-removal-required";
    roleIds: string[];
};
export declare function assertInviteListInput(guildId: string, options: InviteListOptions): void;
export declare function assertInviteGetInput(guildId: string, inviteRef: string): void;
export declare function assertGuildVanityUrlInput(guildId: string, includeCode: boolean): void;
export declare function normalizeInviteDeletionRequest(request: InviteDeletionRequest): NormalizedInviteDeletionRequest;
export declare function normalizeInviteCreationRequest(request: InviteCreationRequest): NormalizedInviteCreationRequest;
export declare class InviteService {
    #private;
    constructor(options: InviteServiceOptions);
    planCreation(applicationId: string, botId: string, request: InviteCreationRequest, options?: RequestOptions): Promise<InviteCreationPlan>;
    executeCreation(applicationId: string, botId: string, request: InviteCreationRequest, expectedDigest: string, options?: RequestOptions): Promise<InviteCreationResult>;
    list(applicationId: string, botId: string, guildId: string, options?: InviteListOptions): Promise<InviteInventoryResult>;
    getVanityUrl(applicationId: string, botId: string, guildId: string, options?: GuildVanityUrlOptions): Promise<GuildVanityUrlAuditResult>;
    get(applicationId: string, botId: string, guildId: string, inviteRef: string, options?: RequestOptions): Promise<InviteLookupResult>;
    plan(applicationId: string, botId: string, request: InviteDeletionRequest, options?: RequestOptions): Promise<InviteDeletionPlan>;
    execute(applicationId: string, botId: string, request: InviteDeletionRequest, expectedDigest: string, options?: RequestOptions): Promise<InviteDeletionResult>;
}
export {};
//# sourceMappingURL=invite-service.d.ts.map