import { type RecordOwnerId } from '../record-owner-id.js';
import { type ChatPolicySnapshot } from './chat-policy.js';
import type { ArkmeSessionCredentials } from '../keychain-store.js';
import type { ArkmeChatAttentionSummary, ArkmeConversationNameSearchResult, ArkmeGroupAvatarPresentation, ArkmeSelfRecordItem, ArkmeSelfSummary, ArkmeSourceDirectory, ArkmeSourceDirectoryPinResult, ArkmeSourceItem, ArkmeSourceKind, ArkmeSourceList, ArkmeTimelineItem, ArkmeTopicCreateResult, ArkmeTopicDissolveResult, ArkmeTopicDissolveTask, ArkmeTopicHierarchyMoveResult, ArkmeTopicRenameResult } from '../types.js';
import { ProfileService, type ArkmePublicProfile } from './profile-service.js';
import { ArkmePrivacyVisibilityService } from './privacy-visibility.js';
import { type ConversationListPreferenceEntry } from './conversation-list-preference-service.js';
import { ServiceRuntime } from './service.js';
export interface ArkmeSourceRefPayload {
    version: 1;
    userId: number;
    kind: ArkmeSourceKind;
    ownerRef: string;
    displayName: string;
    botGroupTarget?: ArkmeGroupBotBindingTarget;
    sidebarSubjectUid?: string;
    conversationListActivityAtMillis?: number;
    conversationListLatestSequence?: number;
}
export interface ArkmeGroupBotBindingTarget {
    rmSubjectId?: number;
    subjectUid?: string;
}
export interface ArkmeGroupAvatarSnapshotProjection {
    memberCount: number;
    strategy: string;
    computedAtMillis: number;
    memberIds: number[];
}
interface ArkmeChatDirectoryMetadata {
    subjectUid?: string;
    activityAtMillis: number;
    latestSequence: number;
}
export interface ArkmePrivateChatViewerLabel {
    displayName: string;
    remark: string;
}
export interface ArkmeSourceRecordReader {
    summary(): Promise<ArkmeSelfSummary>;
    recordItem(raw: unknown): ArkmeSelfRecordItem | undefined;
    isDSHAgentInput?(raw: unknown): boolean;
    isPrivacyLocked?(raw: unknown): boolean;
}
export declare function arkmeGroupBotBindingTargetFromBundle(bundle: Record<string, unknown>): ArkmeGroupBotBindingTarget | undefined;
export declare function arkmeGroupBotBindingBody(source: Pick<ArkmeSourceRefPayload, 'ownerRef' | 'botGroupTarget'>): Record<string, unknown>;
export declare function arkmeChatConversationPreview(raw: Record<string, unknown>, viewerUserId?: number): string;
export declare function arkmeTimelineConversationPreview(item: ArkmeTimelineItem): string;
export declare class SourceService {
    private readonly runtime;
    private readonly profile;
    private readonly recordReader;
    private readonly privacy;
    private readonly chatSourceCache;
    private readonly sourceListCache;
    private readonly sourceListInFlight;
    private readonly selfDirectoryContexts;
    private readonly selfDirectoryContextReads;
    private readonly groupAvatarSnapshotCache;
    private readonly topicDissolveProgress;
    constructor(runtime: ServiceRuntime, profile: ProfileService, recordReader: ArkmeSourceRecordReader, privacy?: ArkmePrivacyVisibilityService);
    topicDissolveStatus(requestId: string): Promise<ArkmeTopicDissolveTask | undefined>;
    activeTopicDissolve(): Promise<ArkmeTopicDissolveTask | undefined>;
    private updateTopicDissolveProgress;
    cachedChatSource(userId: number, chatSessionUid: string): ArkmeSourceItem | undefined;
    cachedChatSourceByKey(cacheKey: string): ArkmeSourceItem | undefined;
    applyConfirmedChatPolicy(policy: ChatPolicySnapshot): void;
    private projectChatSourceAttention;
    private storeChatSourceByKey;
    /**
     * Server-owned tray summary. `summary` covers every visible conversation;
     * paginated `items` from this endpoint must never be summed as the Dock total.
     */
    chatUnreadBadgeSummary(signal?: AbortSignal): Promise<ArkmeChatAttentionSummary>;
    /** Resolve a remote-search owner into the same viewer-bound source used by the conversation UI. */
    searchTargetSource(sourceKind: number, sourceUid: string, displayNameInput: string, signal?: AbortSignal): Promise<ArkmeSourceItem | undefined>;
    /** Search one canonical directory page, including names with no matching messages. */
    searchConversationNames(options: {
        query: string;
        cursor?: string;
        signal?: AbortSignal;
    }): Promise<ArkmeConversationNameSearchResult>;
    /** Resolve a bounded set in one directory walk, reusing viewer-scoped source projections. */
    chatSourcesBySessionUids(uids: readonly string[], signal?: AbortSignal): Promise<Map<string, ArkmeSourceItem>>;
    setChatSource(userId: number, chatSessionUid: string, source: ArkmeSourceItem): void;
    setChatSourceByKey(cacheKey: string, source: ArkmeSourceItem): void;
    /**
     * Resolve the current viewer's private-chat labels for the supplied people.
     * The result is deliberately keyed only inside the Provider; callers project
     * the resolved label into their own viewer-bound response.
     */
    privateDisplayNamesByUserIds(userIds: readonly number[], options?: {
        signal?: AbortSignal;
    }): Promise<Map<number, string>>;
    /**
     * Resolve the current viewer's private-chat display label and its exact
     * remark source without compressing fallback snapshots into remark facts.
     */
    privateChatViewerLabelsByUserIds(userIds: readonly number[], options?: {
        signal?: AbortSignal;
    }): Promise<Map<number, ArkmePrivateChatViewerLabel>>;
    /**
     * Resolve only viewer-owned contact remarks for the supplied people.
     * This deliberately does not fall back to a private nickname or snapshot:
     * callers must keep those identities in their own domain-specific order.
     */
    privateRemarksByUserIds<T extends RecordOwnerId>(userIds: readonly T[], options?: {
        signal?: AbortSignal;
    }): Promise<Map<T, string>>;
    invalidateGroupAvatar(userId: number, chatSessionUid: string): void;
    dispose(): void;
    createTopic(titleInput: string, parentSourceRef?: string, options?: {
        contextSourceRef?: string;
        signal?: AbortSignal;
    }): Promise<ArkmeTopicCreateResult>;
    renameTopic(sourceRef: string, titleInput: string): Promise<ArkmeTopicRenameResult>;
    /** Reuse the record owner's topic policy, without replaying title/privacy defaults. */
    topicHomeVisibility(sourceRef: string, showInHome?: boolean, signal?: AbortSignal): Promise<{
        showInHome: boolean;
    }>;
    /**
     * Dissolving a topic promotes its direct children and moves the topic's own
     * records into its parent. Root-topic records return to the default category.
     */
    dissolveTopic(sourceRef: string, parentSourceRef: string | undefined, childSourceRefs: readonly string[], requestId?: string, expectedRecordCount?: number): Promise<ArkmeTopicDissolveResult>;
    private topicRecordUids;
    private moveTopicRecordsForDissolve;
    private rollbackDissolvedTopicRecords;
    private moveTopicHierarchyForDissolve;
    private rollbackDissolvedTopicChildren;
    /** Move a topic atomically, including its persisted order among siblings. */
    moveTopicHierarchy(sourceRef: string, currentParentSourceRef: string | undefined, nextParentSourceRef: string | undefined, insertBeforeSourceRef: string | undefined): Promise<ArkmeTopicHierarchyMoveResult>;
    /** Lightweight personal-topic choices; independent of conversation cards and their summaries. */
    listTopicCandidates(keyword: string, cursor?: string, signal?: AbortSignal): Promise<Pick<ArkmeSourceList, 'items' | 'hasMore' | 'nextCursor'>>;
    listSources(directory: ArkmeSourceDirectory, options?: {
        limit?: number;
        cursor?: string;
        signal?: AbortSignal;
        refresh?: boolean;
        firstPaint?: boolean;
        background?: boolean;
    }): Promise<ArkmeSourceList>;
    selfTarget(signal?: AbortSignal): Promise<ArkmeSourceItem>;
    /**
     * Resolve one personal topic and every visible descendant from the same
     * paginated directory contract used by the topic picker. Keeping this owner
     * here prevents a timeline read from trusting a partial browser-side tree or
     * exposing raw topic ids across the Host boundary.
     */
    topicSubtreeSources(sourceRef: string, signal?: AbortSignal): Promise<ArkmeSourceItem[]>;
    private selfTargetForAccount;
    setChatDirectoryPin(sourceRef: string, pinned: boolean, signal?: AbortSignal): Promise<ArkmeSourceDirectoryPinResult>;
    chatConversationListPreferenceEntry(sourceRef: string, signal?: AbortSignal): Promise<ConversationListPreferenceEntry>;
    chatConversationListPreferenceEntryBySessionUid(chatSessionUid: string, expectedOwnerUserId: number): Promise<ConversationListPreferenceEntry>;
    listGroupSources(options?: {
        limit?: number;
        cursor?: string;
        signal?: AbortSignal;
        refresh?: boolean;
        firstPaint?: boolean;
    }): Promise<ArkmeSourceList>;
    countGroupSources(signal?: AbortSignal): Promise<number>;
    private selfDirectoryContext;
    private listSourcesUncached;
    invalidateSourceListCache(userId: number, directory?: ArkmeSourceDirectory): void;
    private pruneSourceListCache;
    hydrateDirectoryPage(items: ArkmeSourceItem[], signal: AbortSignal): Promise<ArkmeSourceItem[]>;
    hydrateSourceAvatars(items: ArkmeSourceItem[], privateUserIdByIndex: ReadonlyMap<number, number>, groupSessionUidByIndex: ReadonlyMap<number, string>, session: ArkmeSessionCredentials, signal?: AbortSignal): Promise<void>;
    groupAvatarPresentation(snapshot: ArkmeGroupAvatarSnapshotProjection, profiles: ReadonlyMap<number, ArkmePublicProfile>, viewerUserId: number): Promise<ArkmeGroupAvatarPresentation>;
    chatDirectorySourceKey(userId: number, chatSessionUid: string): Promise<string>;
    chatTimelineItemKey(userId: number, chatSessionUid: string, relationUid: string): Promise<string>;
    chatPreparingActorKey(viewerUserId: number, chatSessionUid: string, actorUserId: number): Promise<string>;
    chatPreparingActorPresentation(viewerUserId: number, chatSessionUid: string, actorUserId: number): Promise<{
        actorKey: string;
        avatarRef: string;
    }>;
    topicHierarchyKey(userId: number, topicUid: string): Promise<string>;
    sealSourceRef(userId: number, kind: ArkmeSourceKind, ownerRef: string, displayName: string, options?: {
        botGroupTarget?: ArkmeGroupBotBindingTarget;
        chatDirectoryMetadata?: ArkmeChatDirectoryMetadata;
        omitDirectoryActivity?: boolean;
    }): Promise<string>;
    openSourceRef(sourceRef: string, expectedUserId: number): Promise<ArkmeSourceRefPayload>;
    sourceItem(source: ArkmeSourceRefPayload): Promise<ArkmeSourceItem>;
    chatSourceFromBundle(bundle: Record<string, unknown>, session: ArkmeSessionCredentials, cached: ArkmeSourceItem | undefined, timelineItems: ArkmeTimelineItem[], options?: {
        previewSnapshot?: boolean;
        previewUpdatedAtMillis?: number;
    }): Promise<ArkmeSourceItem>;
    private encodeCursor;
    private decodeCursor;
    private encodeTopicDirectoryCursor;
    private decodeTopicDirectoryCursor;
}
export {};
//# sourceMappingURL=source-service.d.ts.map