import type { ActivityStore } from "./activity-log.js";
import { type DiscordClient, type ScheduledEventReadOptions, type ScheduledEventUserPageOptions } from "./discord-client.js";
import { type OperationStore } from "./operation-store.js";
import { type DiscordPermissionName } from "./permissions.js";
import type { ScopePolicy } from "./policy.js";
import { type ScheduledEventCoverFileReview } from "./scheduled-event-file.js";
import type { RequestOptions } from "./types.js";
export declare const SCHEDULED_EVENT_ENTITY_TYPES: readonly ["external", "stage", "voice"];
export declare const SCHEDULED_EVENT_STATUSES: readonly ["active", "canceled", "completed", "scheduled"];
export declare const SCHEDULED_EVENT_WEEKDAYS: readonly ["monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday"];
export declare const SCHEDULED_EVENT_OMITTED_FIELDS: readonly ["coverImageCdnUrl", "coverImageHash", "creatorProfile", "rawDiscordObject", "subscriberProfiles"];
export declare const SCHEDULED_EVENT_USER_OMITTED_FIELDS: readonly ["avatars", "displayNames", "memberData", "rawDiscordObjects", "usernames"];
export type ScheduledEventAction = "create" | "delete" | "transition" | "update";
export type ScheduledEventEntityType = typeof SCHEDULED_EVENT_ENTITY_TYPES[number];
export type ScheduledEventStatus = typeof SCHEDULED_EVENT_STATUSES[number];
export type ScheduledEventWeekday = typeof SCHEDULED_EVENT_WEEKDAYS[number];
export type ScheduledEventTransitionTarget = Exclude<ScheduledEventStatus, "scheduled">;
export type ScheduledEventHosting = {
    channelId: string;
    entityType: "stage" | "voice";
} | {
    entityType: "external";
    location: string;
};
export type ScheduledEventRecurrenceRequest = {
    frequency: "daily";
    weekdays?: readonly ScheduledEventWeekday[];
} | {
    frequency: "monthly";
    week: 1 | 2 | 3 | 4 | 5;
    weekday: ScheduledEventWeekday;
} | {
    frequency: "weekly";
    interval?: 1 | 2;
    weekday: ScheduledEventWeekday;
} | {
    frequency: "yearly";
    month: number;
    monthDay: number;
};
interface ScheduledEventRequestBase {
    action: ScheduledEventAction;
    auditReason: string;
    guildId: string;
    operationKey: string;
}
export interface CreateScheduledEventRequest extends ScheduledEventRequestBase {
    action: "create";
    coverImagePath?: string;
    description?: string;
    hosting: ScheduledEventHosting;
    name: string;
    recurrence?: ScheduledEventRecurrenceRequest;
    scheduledEndTime?: string;
    scheduledStartTime: string;
}
export interface UpdateScheduledEventRequest extends ScheduledEventRequestBase {
    action: "update";
    coverImagePath?: string | null;
    description?: string | null;
    eventId: string;
    hosting?: ScheduledEventHosting;
    name?: string;
    recurrence?: ScheduledEventRecurrenceRequest | null;
    scheduledEndTime?: string;
    scheduledStartTime?: string;
}
export interface TransitionScheduledEventRequest extends ScheduledEventRequestBase {
    action: "transition";
    eventId: string;
    targetStatus: ScheduledEventTransitionTarget;
}
export interface DeleteScheduledEventRequest extends ScheduledEventRequestBase {
    action: "delete";
    eventId: string;
}
export type ScheduledEventChangeRequest = CreateScheduledEventRequest | DeleteScheduledEventRequest | TransitionScheduledEventRequest | UpdateScheduledEventRequest;
interface NormalizedRequestBase {
    action: ScheduledEventAction;
    auditReason: string;
    guildId: string;
    operationKeyHash: string;
}
interface DailyRecurrencePattern {
    frequency: "daily";
    weekdays: ScheduledEventWeekday[] | null;
}
interface MonthlyRecurrencePattern {
    frequency: "monthly";
    week: 1 | 2 | 3 | 4 | 5;
    weekday: ScheduledEventWeekday;
}
interface WeeklyRecurrencePattern {
    frequency: "weekly";
    interval: 1 | 2;
    weekday: ScheduledEventWeekday;
}
interface YearlyRecurrencePattern {
    frequency: "yearly";
    month: number;
    monthDay: number;
}
export type NormalizedScheduledEventRecurrence = DailyRecurrencePattern | MonthlyRecurrencePattern | WeeklyRecurrencePattern | YearlyRecurrencePattern;
export type NormalizedScheduledEventChangeRequest = (Omit<CreateScheduledEventRequest, keyof ScheduledEventRequestBase | "hosting" | "recurrence"> & NormalizedRequestBase & {
    action: "create";
    hosting: ScheduledEventHosting;
    recurrence?: NormalizedScheduledEventRecurrence;
}) | (Omit<DeleteScheduledEventRequest, keyof ScheduledEventRequestBase> & NormalizedRequestBase & {
    action: "delete";
}) | (Omit<TransitionScheduledEventRequest, keyof ScheduledEventRequestBase> & NormalizedRequestBase & {
    action: "transition";
}) | (Omit<UpdateScheduledEventRequest, keyof ScheduledEventRequestBase | "hosting" | "recurrence"> & NormalizedRequestBase & {
    action: "update";
    hosting?: ScheduledEventHosting;
    recurrence?: NormalizedScheduledEventRecurrence | null;
});
export interface ProjectedScheduledEventRecurrence {
    count: number | null;
    endTime: string | null;
    frequency: "daily" | "monthly" | "weekly" | "yearly";
    interval: number;
    monthDays: number[] | null;
    months: number[] | null;
    numberedWeekdays: Array<{
        week: number;
        weekday: ScheduledEventWeekday;
    }> | null;
    startTime: string;
    weekdays: ScheduledEventWeekday[] | null;
    yearDays: number[] | null;
}
export interface ProjectedScheduledEvent {
    channelId: string | null;
    creatorUserId: string | null;
    description: string | null;
    entityId: string | null;
    entityType: ScheduledEventEntityType;
    eventId: string;
    guildId: string;
    hasCoverImage: boolean;
    location: string | null;
    name: string;
    privacyLevel: "guild-only";
    recurrence: ProjectedScheduledEventRecurrence | null;
    scheduledEndTime: string | null;
    scheduledStartTime: string;
    status: ScheduledEventStatus;
    subscriberCount: number | null;
}
export type PlannedScheduledEvent = Omit<ProjectedScheduledEvent, "eventId"> & {
    eventId: string | null;
};
export interface ScheduledEventAccessEvidence {
    administrator: boolean;
    channelId: string | null;
    confidence: "complete";
    effectivePermissions: string;
    entityType: ScheduledEventEntityType;
    guildOwner: boolean;
    missingPermissions: [];
    permissionScope: "channel" | "guild";
    requiredPermissions: DiscordPermissionName[];
}
export interface ScheduledEventChangePermissionEvidence {
    botOwned: boolean | null;
    current: ScheduledEventAccessEvidence;
    destination: ScheduledEventAccessEvidence | null;
    ownershipRequired: boolean;
}
export interface ScheduledEventPrivacyProjection {
    omittedFields: typeof SCHEDULED_EVENT_OMITTED_FIELDS;
    privateFieldsProjectedOut: true;
    subscriberIdentitiesExposed: false;
}
export interface ScheduledEventInventoryResult {
    events: Array<{
        access: ScheduledEventAccessEvidence;
        event: ProjectedScheduledEvent;
    }>;
    guild: {
        id: string;
        name: string;
    };
    page: {
        returned: number;
        safetyLimit: number;
        visibility: "connector-visible";
    };
    privacy: ScheduledEventPrivacyProjection;
    schemaVersion: number;
    status: "ok";
    subscriberCountsIncluded: boolean;
}
export interface ScheduledEventLookupResult {
    access: ScheduledEventAccessEvidence;
    event: ProjectedScheduledEvent;
    guild: {
        id: string;
        name: string;
    };
    privacy: ScheduledEventPrivacyProjection;
    schemaVersion: number;
    status: "ok";
    subscriberCountIncluded: boolean;
}
export interface ScheduledEventUserPageResult {
    access: ScheduledEventAccessEvidence;
    event: ProjectedScheduledEvent;
    guild: {
        id: string;
        name: string;
    };
    page: {
        nextAfter: string | null;
        requestedAfter: string | null;
        requestedLimit: number;
        returned: number;
    };
    privacy: {
        memberDataRequested: false;
        omittedFields: typeof SCHEDULED_EVENT_USER_OMITTED_FIELDS;
        persistence: "none";
        profileFieldsProjectedOut: true;
        rawPayloads: "omitted";
        userIdsExposed: true;
    };
    schemaVersion: number;
    status: "ok";
    users: Array<{
        bot: boolean;
        id: string;
    }>;
}
export interface ScheduledEventPlan {
    action: ScheduledEventAction;
    applicationId: string;
    auditReason: string;
    botId: string;
    createdAt: string;
    desired: PlannedScheduledEvent | null;
    digest: string;
    effect: "create" | "delete" | "none" | "transition" | "update";
    existing: ProjectedScheduledEvent | null;
    file: {
        contentDigest: string;
        review: ScheduledEventCoverFileReview;
    } | null;
    guild: {
        id: string;
        name: string;
    };
    operationKeyHash: string;
    permission: ScheduledEventChangePermissionEvidence;
    privacy: ScheduledEventPrivacyProjection;
    schemaVersion: number;
    status: "already-current" | "planned";
    visibleInventory: {
        digest: string | null;
        returned: number | null;
        safetyLimit: number;
        visibility: "connector-visible";
    };
    warnings: string[];
}
export interface ScheduledEventResult {
    action: ScheduledEventAction;
    activityId: string | null;
    eventId: string;
    guildId: string;
    observed: ProjectedScheduledEvent | null;
    operationKeyHash: string;
    planDigest: string;
    schemaVersion: number;
    status: "already-current" | "completed" | "completed-with-drift";
}
export interface ScheduledEventServiceClient extends Pick<DiscordClient, "createGuildScheduledEvent" | "deleteGuildScheduledEvent" | "getGuild" | "getGuildChannels" | "getGuildMember" | "getGuildRoles" | "getGuildScheduledEvent" | "listGuildScheduledEvents" | "listGuildScheduledEventUsers" | "modifyGuildScheduledEvent"> {
}
export interface ScheduledEventServiceOptions {
    activityStore: ActivityStore;
    client: ScheduledEventServiceClient;
    clock?: () => Date;
    fileRoots: readonly string[];
    operationStore: OperationStore;
    planKey?: Uint8Array;
    policy: ScopePolicy;
    randomId?: () => string;
}
export declare function normalizeScheduledEventChangeRequest(request: ScheduledEventChangeRequest): NormalizedScheduledEventChangeRequest;
export declare class ScheduledEventService {
    #private;
    constructor(options: ScheduledEventServiceOptions);
    list(botId: string, guildId: string, options?: ScheduledEventReadOptions): Promise<ScheduledEventInventoryResult>;
    get(botId: string, guildId: string, eventId: string, options?: ScheduledEventReadOptions): Promise<ScheduledEventLookupResult>;
    listUsers(botId: string, guildId: string, eventId: string, options?: ScheduledEventUserPageOptions): Promise<ScheduledEventUserPageResult>;
    plan(applicationId: string, botId: string, request: ScheduledEventChangeRequest, options?: RequestOptions): Promise<ScheduledEventPlan>;
    execute(applicationId: string, botId: string, request: ScheduledEventChangeRequest, expectedDigest: string, options?: RequestOptions): Promise<ScheduledEventResult>;
}
export {};
//# sourceMappingURL=scheduled-event-service.d.ts.map