import { type ChannelAdministrationService, type ChannelCreationRequest } from "./channel-administration-service.js";
import { type ChannelCreationKind } from "./constants.js";
import { type OperationReceipt, type OperationStore } from "./operation-store.js";
import { type DiscordPermissionName } from "./permissions.js";
import type { ScopePolicy } from "./policy.js";
import { type RoleAdministrationService, type RoleCreationRequest } from "./role-administration-service.js";
import type { DiscordChannel, DiscordGuild, DiscordGuildMember, DiscordRole, RequestOptions } from "./types.js";
export type GuildScaffoldStepKind = "category" | "forum" | "role" | "text";
export type GuildScaffoldStepState = "already-current" | "completed" | "ready" | "waiting-for-parent";
export interface GuildScaffoldRoleInput {
    hoist?: boolean;
    key: string;
    mentionable?: boolean;
    name: string;
    permissions?: readonly DiscordPermissionName[];
    primaryColor?: number;
}
export interface GuildScaffoldChannelInput {
    defaultAutoArchiveDuration?: number;
    key: string;
    kind: ChannelCreationKind;
    name: string;
    nsfw?: boolean;
    parentKey?: string;
    rateLimitPerUser?: number;
    topic?: string;
}
export interface GuildScaffoldRequest {
    auditReason: string;
    channels: readonly GuildScaffoldChannelInput[];
    guildId: string;
    operationKey: string;
    roles: readonly GuildScaffoldRoleInput[];
    stepLimit?: number;
}
interface NormalizedGuildScaffoldRole {
    index: number;
    key: string;
    request: RoleCreationRequest;
}
interface NormalizedGuildScaffoldChannel {
    index: number;
    key: string;
    kind: ChannelCreationKind;
    parentKey: string | null;
    request: Omit<ChannelCreationRequest, "parentId">;
}
export interface NormalizedGuildScaffoldRequest {
    auditReason: string;
    channels: NormalizedGuildScaffoldChannel[];
    guildId: string;
    operationKey: string;
    operationKeyHash: string;
    roles: NormalizedGuildScaffoldRole[];
    stepLimit: number;
}
export interface GuildScaffoldPlanStep {
    existingResourceId: string | null;
    index: number;
    key: string;
    kind: GuildScaffoldStepKind;
    operationKeyHash: string;
    parent: {
        key: string;
        permission: {
            administrator: boolean;
            appliedRoleIds: string[];
            confidence: "complete";
            effectivePermissionNames: DiscordPermissionName[];
            effectivePermissions: string;
            manageChannels: boolean;
            permissionSourceChannelId: string;
            unknownPermissionBits: string;
            viewChannel: boolean;
            warnings: string[];
        } | null;
        resourceId: string | null;
    } | null;
    state: GuildScaffoldStepState;
    target: {
        defaultAutoArchiveDuration?: number | null;
        hoist?: boolean;
        mentionable?: boolean;
        name: string;
        nsfw?: boolean | null;
        permissionBits?: string;
        permissions?: DiscordPermissionName[];
        primaryColor?: number;
        rateLimitPerUser?: number | null;
        topic?: string | null;
    };
}
export interface GuildScaffoldPlan {
    applicationId: string;
    auditReason: string;
    botId: string;
    counts: {
        alreadyCurrent: number;
        completed: number;
        ready: number;
        total: number;
        waitingForParent: number;
    };
    createdAt: string;
    digest: string;
    executionFrontier: {
        stepIndexes: number[];
    };
    guild: {
        id: string;
        name: string;
        ownerId: string;
    };
    operation: {
        operationKeyHash: string;
        requestDigest: string;
        status: OperationReceipt["status"] | "unreserved";
        stepLimit: number;
    };
    permission: {
        botAdministrator: boolean;
        botEffectivePermissionNames: DiscordPermissionName[];
        botEffectivePermissions: string;
        botHighestRoleIds: string[];
        botHighestRolePosition: number;
        guildManageChannels: boolean;
        guildManageRoles: boolean;
        guildViewChannel: boolean;
    };
    schemaVersion: number;
    status: "already-current" | "completed" | "planned" | "resume-ready";
    steps: GuildScaffoldPlanStep[];
    visibleInventory: {
        channels: number;
        channelLimit: number;
        roles: number;
        roleLimit: number;
    };
    warnings: string[];
}
export interface GuildScaffoldExecutedStep {
    activityId: string | null;
    index: number;
    key: string;
    kind: GuildScaffoldStepKind;
    resourceId: string;
    status: "already-current" | "completed" | "completed-with-drift";
}
export interface GuildScaffoldResult {
    applicationId: string;
    botId: string;
    executedSteps: GuildScaffoldExecutedStep[];
    guildId: string;
    operationKeyHash: string;
    planDigest: string;
    remaining: {
        ready: number;
        waitingForParent: number;
    };
    requestDigest: string;
    schemaVersion: number;
    status: "already-current" | "completed" | "paused";
}
export interface GuildScaffoldVerificationStep {
    index: number;
    kind: GuildScaffoldStepKind;
    resourceId: string | null;
    state: GuildScaffoldStepState;
}
export interface GuildScaffoldVerification {
    applicationId: string;
    botId: string;
    checkedAt: string;
    counts: GuildScaffoldPlan["counts"];
    evidence: {
        callerRetainedRequestRequired: true;
        persistedDiscordContent: false;
        source: "live-discord-and-content-free-receipts";
    };
    guildId: string;
    operation: {
        operationKeyHash: string;
        receiptStatus: OperationReceipt["status"] | "unreserved";
        requestDigest: string;
    };
    planDigest: string;
    schemaVersion: number;
    status: "incomplete" | "unrecorded" | "verified";
    steps: GuildScaffoldVerificationStep[];
}
export interface GuildScaffoldServiceOptions {
    channelService: Pick<ChannelAdministrationService, "executeForGuildScaffold" | "planForGuildScaffold">;
    client: {
        getGuild(guildId: string, options?: RequestOptions): Promise<DiscordGuild>;
        getGuildChannels(guildId: string, options?: RequestOptions): Promise<DiscordChannel[]>;
        getGuildMember(guildId: string, userId: string, options?: RequestOptions): Promise<DiscordGuildMember>;
        getGuildRoles(guildId: string, options?: RequestOptions): Promise<DiscordRole[]>;
    };
    clock?: () => Date;
    operationStore: OperationStore;
    planKey?: Uint8Array;
    policy: ScopePolicy;
    randomId?: () => string;
    roleService: Pick<RoleAdministrationService, "executeForGuildScaffold" | "planForGuildScaffold">;
}
export declare function normalizeGuildScaffoldRequest(request: GuildScaffoldRequest): NormalizedGuildScaffoldRequest;
export declare class GuildScaffoldService {
    #private;
    constructor(options: GuildScaffoldServiceOptions);
    plan(applicationId: string, botId: string, request: GuildScaffoldRequest, options?: RequestOptions): Promise<GuildScaffoldPlan>;
    verify(applicationId: string, botId: string, request: GuildScaffoldRequest, options?: RequestOptions): Promise<GuildScaffoldVerification>;
    execute(applicationId: string, botId: string, request: GuildScaffoldRequest, expectedDigest: string, options?: RequestOptions): Promise<GuildScaffoldResult>;
}
export {};
//# sourceMappingURL=guild-scaffold-service.d.ts.map