import { COORDINATION_NOTE_FORMAT, type CoordinationNoteEnvelope } from "./coordination-note.js";
import type { MessagePageOptions } from "./discord-client.js";
import type { ScopePolicy } from "./policy.js";
import type { DiscordChannel, DiscordMessage, RequestOptions } from "./types.js";
export interface CoordinationPageOptions extends RequestOptions {
    afterMessageId?: string;
    scanLimit?: number;
}
export interface CoordinationNoteListOptions extends CoordinationPageOptions {
    fromAddress?: string;
    includeBroadcasts?: boolean;
    tag?: string;
    unresolvedOnly?: boolean;
}
export interface CoordinationNoteServiceClient {
    getChannel(channelId: string, options?: RequestOptions): Promise<DiscordChannel>;
    listMessages(channelId: string, options?: MessagePageOptions): Promise<DiscordMessage[]>;
}
export interface CoordinationNoteServiceOptions {
    client: CoordinationNoteServiceClient;
    policy: Pick<ScopePolicy, "assertChannelReadable">;
}
export interface CoordinationStatusSignals {
    automatedReplyExpectedCount: number;
    blockedCount: number;
    declinedCount: number;
    doneOrApprovedCount: number;
    seenOrClaimedCount: number;
    terminalConventionObserved: boolean;
}
export interface CoordinationNoteView {
    body: string;
    channelId: string;
    editedTimestamp: string | null;
    fromAddress: string;
    guildId: string;
    id: string;
    jumpUrl: string;
    notificationRequested: boolean;
    plainMessage: {
        attachmentCount: 0;
        componentCount: 0;
        embedCount: 0;
        stickerCount: 0;
    };
    replyToMessageId: string | null;
    statusSignals: CoordinationStatusSignals;
    tags: readonly string[];
    timestamp: string;
    to: CoordinationNoteEnvelope["to"];
}
export interface CoordinationAddressObservation {
    address: string;
    firstObservedAtInPage: string;
    lastMessageIdInPage: string;
    lastObservedAtInPage: string;
    noteCountInPage: number;
}
interface CoordinationDiscardCounts {
    differentRecipient: number;
    filteredSender: number;
    filteredTag: number;
    malformedEnvelope: number;
    nonNote: number;
    resolvedByConvention: number;
    unsupportedAuthorOrWebhook: number;
    unsupportedMessageShape: number;
}
interface CoordinationPageEvidence {
    afterMessageId: string | null;
    nextAfterMessageId: string | null;
    requestedScanLimit: number;
    scanLimitReached: boolean;
    scannedMessageCount: number;
}
interface CoordinationPrivacyProjection {
    attachmentUrls: "omitted";
    connectorPersistence: "none";
    differentlyAddressedBodies: "discarded";
    profiles: "omitted";
    rawPayloads: "omitted";
    reactionUsers: "not-read";
}
interface CoordinationRoutingBoundary {
    addressAuthority: "none";
    addressAuthentication: "none";
    addressLiveness: "not-proven";
    addressRegistration: "none";
    contentAuthority: "none";
    statusSignalAuthority: "none";
}
export interface CoordinationNoteListResult {
    applicationId: string;
    botId: string;
    channel: {
        id: string;
        parentId: string | null;
        type: number;
    };
    discarded: CoordinationDiscardCounts;
    format: typeof COORDINATION_NOTE_FORMAT;
    guildId: string;
    notes: CoordinationNoteView[];
    page: CoordinationPageEvidence & {
        noteCount: number;
    };
    privacy: CoordinationPrivacyProjection;
    routing: CoordinationRoutingBoundary;
    schemaVersion: number;
    status: "ok";
}
export interface CoordinationAddressListResult {
    addresses: CoordinationAddressObservation[];
    applicationId: string;
    botId: string;
    channel: {
        id: string;
        parentId: string | null;
        type: number;
    };
    discarded: Omit<CoordinationDiscardCounts, "differentRecipient" | "filteredSender" | "filteredTag" | "resolvedByConvention">;
    format: typeof COORDINATION_NOTE_FORMAT;
    guildId: string;
    page: CoordinationPageEvidence & {
        addressCount: number;
        coordinationNoteCount: number;
    };
    privacy: CoordinationPrivacyProjection & {
        notificationTargets: "omitted";
        noteBodies: "omitted";
        recipients: "omitted";
        tags: "omitted";
    };
    routing: CoordinationRoutingBoundary;
    schemaVersion: number;
    status: "ok";
}
export declare function assertCoordinationNoteListRequest(channelId: unknown, recipientAddress: unknown, options?: CoordinationNoteListOptions): asserts channelId is string;
export declare function assertCoordinationAddressListRequest(channelId: unknown, options?: CoordinationPageOptions): asserts channelId is string;
export declare class CoordinationNoteService {
    #private;
    constructor(options: CoordinationNoteServiceOptions);
    listNotes(applicationId: string, botId: string, channelId: string, recipientAddress: string, options?: CoordinationNoteListOptions): Promise<CoordinationNoteListResult>;
    listAddresses(applicationId: string, botId: string, channelId: string, options?: CoordinationPageOptions): Promise<CoordinationAddressListResult>;
}
export {};
//# sourceMappingURL=coordination-note-service.d.ts.map