import type { TeamRepresentationSelection } from '../team-group-contract.js';
import { type PersonRecordSourcesPage } from '../person-records.js';
import type { ArkmeTimelineMemberJoinEvent } from '../unified-chat-timeline.js';
import { type ArkmeMessageQuote } from '../message-quote.js';
import { type MessageUnderlineChange } from '../message-annotations.js';
import { type ResolvedMentions } from './mention-metadata-codec.js';
import type { RecordEditHistoryTarget } from './record-edit-history-service.js';
import { type RecordOwnerId } from '../record-owner-id.js';
import { type BotDisplayProfilesReader } from '../chat-sender-display.js';
import { CallHistoryService } from './call-history-service.js';
import { MemberEventService } from './member-event-service.js';
import type { ArkmeSessionCredentials } from '../keychain-store.js';
import type { ArkmeChatNotificationResult, ArkmeConversationMemberJoinEvent, ArkmeConversationMemberList, ArkmeConversationMemberPage, ArkmeConversationMemberPresentation, ArkmeConversationMemberCache, ArkmeConversationMemberRecordMode, ArkmeConversationMemberRecordPage, ArkmeBotMentionInput, ArkmeBotConversation, ArkmeBotConversationReadResult, ArkmeBotConversationSendResult, ArkmeBotNotificationPreference, ArkmeDirectTextSendResult, ArkmeFavoriteStickerList, ArkmeFavoriteStickerAddInput, ArkmeFavoriteStickerManageAction, ArkmeGroupJoinRestrictionMutationResult, ArkmeGroupJoinRestrictionPage, ArkmeGroupSelfNickname, ArkmeGroupMemberRemoveResult, ArkmeHumanMentionInput, ArkmeLongArticleDetail, ArkmeLongArticleDraft, ArkmeMessageCopyLinkExtendResult, ArkmeMessageCopyLinkResult, ArkmeMessageCopyLinkResolveResult, ArkmeMessageSnapshotDetail, ArkmeMessageReadReceiptDetail, ArkmeMessageReadReceiptQueryItem, ArkmeMessageReadReceiptSummaryList, ArkmeMessageReportResult, ArkmeMessageWithdrawalResult, ArkmeOfficialAuthorProfile, ArkmeOpenPrivateChatResult, ArkmeRichSendInput, ArkmeRecordCaptureContext, ArkmeRecordLocationCapture, ArkmeSourceItem, ArkmeSourceReadResult, ArkmeSourceSendResult, ArkmeSourceMessageExtendResult, ArkmeSourceMessageExtensionContext, ArkmeSharedRecordingPreview, ArkmeTimelineCursor, ArkmeTimelineAroundPage, ArkmeTimelineItem, ArkmeTimelineExtensionParent, ArkmeTimelinePage, ArkmeUploadedAsset } from '../types.js';
import { ArkoService } from './arko-service.js';
import { BotService } from './bot-service.js';
import { GroupAiPolishService } from './group-ai-polish-service.js';
import { MediaService, type ArkmeMediaDescriptor } from './media-service.js';
import { MessageActionService } from './message-action-service.js';
import { ProfileService } from './profile-service.js';
import { ArkmePrivacyVisibilityService } from './privacy-visibility.js';
import { RecordService } from './record-service.js';
import type { ArkmeRelatedQuickNoteSourceLocator } from './related-quick-note-service.js';
import { ServiceRuntime } from './service.js';
import { SourceService, type ArkmeSourceRefPayload } from './source-service.js';
interface ArkmeMessageRefPayload {
    version: 1;
    userId: number;
    chatSessionUid: string;
    relationUid: string;
}
/** Single owner for the provider-safe rich payload shared by UI, SDK, durable files and Tools. */
export declare function arkmeRichContentPayload(input: ArkmeRichSendInput, normalizedTextContent: string, mentionPayload?: Record<string, unknown>): Record<string, unknown> | undefined;
export interface ArkmeChatRealtimePort {
    beginLocalReadCursor(userId: number, sessionUid: string, sequence: number): (confirmedSequence?: number) => void;
    emitChatClientEvent(event: Parameters<import('./chat-realtime-service.js').ChatRealtimeService['emitChatClientEvent']>[0]): void;
    nextChatClientRevision(): number;
    scheduleChatSessionProjection(chatSessionUid: string, latestSequence: number): void;
    invalidateRecordProjection(options?: {
        contentOnly?: boolean;
    }): Promise<void>;
    refreshAttentionSummary(): Promise<void>;
}
/** Background availability is a media fact; waveform samples alone never manufacture it. */
export declare function arkmeSnapshotBackgroundSoundState(values: Record<string, unknown>): ArkmeMessageSnapshotDetail['backgroundSound'];
interface ArkmeJoinEventProjectionOptions {
    viewerUserId: number;
    memberRefForUserId(userId: number): Promise<string>;
    eventIdForStableKey(stableKey: string): Promise<string>;
}
/** Converts allowlisted member join metadata into a Browser-safe projection. */
export declare function projectArkmeConversationMemberJoinEvents(rawItems: readonly Record<string, unknown>[], options: ArkmeJoinEventProjectionOptions): Promise<ArkmeConversationMemberJoinEvent[]>;
export declare class ChatService {
    private readonly runtime;
    private readonly source;
    private readonly profile;
    private readonly media;
    private readonly record;
    private readonly bot;
    private readonly arko;
    private readonly aiPolish;
    private readonly realtime;
    private readonly privacy;
    private readonly messageActions?;
    private readonly callHistory;
    private readonly senderProfiles;
    readonly memberEvents: MemberEventService;
    private favoriteStickerMutationTail;
    constructor(runtime: ServiceRuntime, source: SourceService, profile: ProfileService, media: MediaService, record: RecordService, bot: BotService, arko: ArkoService, aiPolish: GroupAiPolishService, realtime: ArkmeChatRealtimePort, privacy?: ArkmePrivacyVisibilityService, messageActions?: MessageActionService | undefined, callHistory?: CallHistoryService, senderProfiles?: BotDisplayProfilesReader);
    private hydrateExtensionMedia;
    private hydrateUploadedExtension;
    readDirectBotConversation(botId: string, chatSessionUid: string, options?: {
        signal?: AbortSignal;
    }): Promise<ArkmeBotConversation>;
    sendDirectBotText(chatSessionUid: string, contentInput: string, options?: {
        signal?: AbortSignal;
    }): Promise<ArkmeBotConversationSendResult>;
    conversationNotification(sourceRef: string, enabled?: boolean, signal?: AbortSignal): Promise<ArkmeChatNotificationResult>;
    directBotNotificationPreference(chatSessionUid: string, options?: {
        signal?: AbortSignal;
    }): Promise<ArkmeBotNotificationPreference>;
    updateDirectBotNotificationPreference(chatSessionUid: string, muted: boolean, options?: {
        signal?: AbortSignal;
    }): Promise<ArkmeBotNotificationPreference>;
    markDirectBotRead(chatSessionUid: string, readSequence: number, options?: {
        signal?: AbortSignal;
    }): Promise<ArkmeBotConversationReadResult>;
    private directBotPolicy;
    private serializeFavoriteStickerMutation;
    cachedSourceMembers(sourceRef: string, signal?: AbortSignal): Promise<ArkmeConversationMemberCache | undefined>;
    /** Read-only human candidates for team management, not group invitations. */
    teamMemberCandidates(sourceRef: string, options?: {
        cursor?: string;
        signal?: AbortSignal;
    }): Promise<import('../team-member-add-contract.js').TeamMemberCandidateSourcePage>;
    pageSourceMembers(sourceRef: string, options?: {
        cursor?: string;
        limit?: number;
        signal?: AbortSignal;
    }): Promise<ArkmeConversationMemberPage>;
    sourceMembersPresentation(sourceRef: string, memberRefs: readonly string[], options?: {
        signal?: AbortSignal;
    }): Promise<ArkmeConversationMemberPresentation>;
    private memberRead;
    private sealMemberPageCursor;
    private openMemberPageCursor;
    listSourceMembers(sourceRef: string, options?: {
        activeOnly?: boolean;
        signal?: AbortSignal;
    }): Promise<ArkmeConversationMemberList>;
    /** Seal only an owner-authorized article source returned by Record's library. */
    articleSearchActionRef(raw: Record<string, unknown>, sourceRef: string, signal?: AbortSignal): Promise<string>;
    personRecordsPage(sourceRef: string, memberRef: string, options?: {
        cursor?: string;
        limit?: number;
        knownEventRefs?: readonly string[];
        validateOnly?: boolean;
        signal?: AbortSignal;
    }): Promise<import('../person-records.js').PersonRecordsPage>;
    personRecordsCapabilities(sourceRef: string, memberRef: string, signal?: AbortSignal): Promise<{
        version: 1;
        shared: boolean;
        strategy: "existing-conversations";
    }>;
    /** Discover bounded batches; reading this view never creates a chat or marks it read. */
    personRecordSources(sourceRef: string, memberRef: string, cursor?: string, signal?: AbortSignal): Promise<PersonRecordSourcesPage>;
    sourceMemberRecords(sourceRef: string, memberRef: string, mode: ArkmeConversationMemberRecordMode, options?: {
        limit?: number;
        beforeSequence?: number;
        basicPresentation?: boolean;
        signal?: AbortSignal;
    }): Promise<ArkmeConversationMemberRecordPage>;
    memberWorldTarget(sourceRef: string, memberRef: string, signal?: AbortSignal): Promise<{
        userId: number;
    }>;
    openPrivateChatFromMember(sourceRef: string, memberRef: string, options?: {
        signal?: AbortSignal;
    }): Promise<ArkmeOpenPrivateChatResult>;
    openPrivateChatFromUser(peerUserId: RecordOwnerId, options?: {
        presentationDisplayName?: string;
        expectedViewerUserId?: number;
        signal?: AbortSignal;
    }): Promise<ArkmeOpenPrivateChatResult>;
    openOfficialAuthorPrivateChat(options?: {
        signal?: AbortSignal;
    }): Promise<ArkmeOpenPrivateChatResult>;
    /**
     * Contact-author is an entry point, not a second conversation type. Scan the
     * ordinary directory first so repeated clicks always reuse the existing chat.
     */
    private findPrivateChatByPeerUserId;
    officialAuthorProfile(options?: {
        signal?: AbortSignal;
    }): Promise<ArkmeOfficialAuthorProfile>;
    private readTopicTimelineRawStream;
    private readTopicTimelineRawStreams;
    readSource(sourceRef: string, options?: {
        limit?: number;
        cursor?: ArkmeTimelineCursor;
        signal?: AbortSignal;
    }): Promise<ArkmeTimelinePage>;
    readSourceAround(sourceRef: string, itemUid: string, recordOwnerUserId: RecordOwnerId, options?: {
        beforeLimit?: number;
        afterLimit?: number;
        signal?: AbortSignal;
    }): Promise<ArkmeTimelineAroundPage>;
    reportMessage(messageRef: string, reportType: 1 | 2 | 3 | 4, options?: {
        reason?: string;
        requestUid?: string;
        signal?: AbortSignal;
    }): Promise<ArkmeMessageReportResult>;
    withdrawGroupMessage(messageWithdrawalRef: string, options?: {
        signal?: AbortSignal;
    }): Promise<ArkmeMessageWithdrawalResult>;
    groupSelfNickname(sourceRef: string, signal?: AbortSignal): Promise<ArkmeGroupSelfNickname>;
    setGroupSelfNickname(sourceRef: string, nickname: string, signal?: AbortSignal): Promise<ArkmeGroupSelfNickname>;
    removeGroupMember(sourceRef: string, memberRef: string, options?: {
        preventRejoin?: boolean;
        signal?: AbortSignal;
    }): Promise<ArkmeGroupMemberRemoveResult>;
    listGroupJoinRestrictions(sourceRef: string, options?: {
        cursor?: string;
        limit?: number;
        signal?: AbortSignal;
    }): Promise<ArkmeGroupJoinRestrictionPage>;
    setGroupJoinRestriction(sourceRef: string, memberRef: string, restricted: boolean, options?: {
        signal?: AbortSignal;
    }): Promise<ArkmeGroupJoinRestrictionMutationResult>;
    messageReadReceiptSummaries(sourceRef: string, rawItems: readonly ArkmeMessageReadReceiptQueryItem[], options?: {
        signal?: AbortSignal;
    }): Promise<ArkmeMessageReadReceiptSummaryList>;
    messageReadReceiptDetail(sourceRef: string, itemUid: string, sequence: number, options?: {
        signal?: AbortSignal;
        basicOnly?: boolean;
    }): Promise<ArkmeMessageReadReceiptDetail>;
    private requireReadReceiptChatSource;
    private requireReadReceiptItems;
    private readReceiptItemKey;
    copySourceMessageLink(sourceRef: string, actionRefs: readonly string[], options?: {
        signal?: AbortSignal;
    }): Promise<ArkmeMessageCopyLinkResult>;
    resolveMessageCopyLink(sid: string, options?: {
        signal?: AbortSignal;
    }): Promise<ArkmeMessageCopyLinkResolveResult>;
    private loadMessageCopyLinkPublicExtensions;
    private loadChatMessageExtensions;
    /** Personal and topic notes share the record-owned tree, including replies outside the original topic. */
    private ownedRecordParentFromTree;
    /** Lightweight visible-row enrichment; never reads an entire topic before showing it. */
    sourceMessageExtensionParent(sourceRef: string, actionRef: string, options?: {
        signal?: AbortSignal;
    }): Promise<{
        extensionParent?: ArkmeTimelineExtensionParent;
        recordUid: string;
    }>;
    private loadOwnedRecordExtensions;
    recordEditHistoryTarget(sourceRef: string, messageActionRef: string): Promise<RecordEditHistoryTarget>;
    reactionTarget(sourceRef: string, messageActionRef: string): Promise<import('./reaction-service.js').ReactionWireTarget>;
    reactionActorReferences(sourceRef: string, userIds: readonly number[]): Promise<Map<number, string>>;
    /** Keep viewer-owned remarks separate from group nicknames and public profiles. */
    reactionActorLabels(sourceRef: string, userIds: readonly number[], signal?: AbortSignal): Promise<Map<number, {
        remark: string;
        groupNickname: string;
    }>>;
    private underlineContext;
    private localMarkContext;
    sourceLocalMarkCapabilities(sourceRef: string): Promise<{
        supported: boolean;
        maxLength: number;
        storage: "local";
    }>;
    sourceLocalMarks(sourceRef: string, actionRefs: readonly string[]): Promise<{
        actionRef: string;
        snapshot: import("../message-annotations.js").MessageUnderlineSnapshot;
    }[]>;
    changeSourceLocalMark(sourceRef: string, actionRef: string, change: MessageUnderlineChange): Promise<import("../message-annotations.js").MessageUnderlineSnapshot>;
    captureSourceMessageAnchor(sourceRef: string, actionRef: string, start: number, end: number): Promise<ArkmeMessageQuote>;
    sourceUnderlineCapabilities(sourceRef: string, signal?: AbortSignal): Promise<import("../message-annotations.js").MessageUnderlineCapabilities>;
    sourceUnderlines(sourceRef: string, actionRefs: readonly string[], signal?: AbortSignal): Promise<{
        actionRef: string;
        snapshot: {
            revision: number;
            accessible: boolean;
            items: {
                id: string;
                actorId: number;
                actorName: string;
                mine: boolean;
                anchor: ArkmeMessageQuote;
                state: "available" | "stale";
            }[];
        };
    }[]>;
    changeSourceUnderline(sourceRef: string, actionRef: string, change: MessageUnderlineChange, signal?: AbortSignal): Promise<{
        revision: number;
        accessible: boolean;
        items: {
            id: string;
            actorId: number;
            actorName: string;
            mine: boolean;
            anchor: ArkmeMessageQuote;
            state: "available" | "stale";
        }[];
    }>;
    sourceMessageExtensionCapabilities(sourceRef: string, signal?: AbortSignal): Promise<import("../message-quote.js").ArkmeQuoteReplyCapabilities>;
    validateQuoteReply(sourceRef: string, messageActionRef: string, value: unknown, signal?: AbortSignal): Promise<ArkmeMessageQuote>;
    sourceMessageExtensionContext(sourceRef: string, messageActionRef: string, options?: {
        signal?: AbortSignal;
    }): Promise<ArkmeSourceMessageExtensionContext>;
    extendSourceMessage(sourceRef: string, messageActionRef: string, textContent: string, recordUid: string, assets?: readonly ArkmeUploadedAsset[], options?: {
        relationUid?: string;
        parentRecordUid?: string;
        quote?: ArkmeMessageQuote;
        signal?: AbortSignal;
    } & Pick<ArkmeRichSendInput, 'textFormat' | 'humanMentions' | 'botMentions' | 'representation' | 'sendAtMillis'>): Promise<ArkmeSourceMessageExtendResult>;
    extendMessageCopyLink(sid: string, itemIndex: number, textContent: string, recordUid: string, options?: {
        signal?: AbortSignal;
    }): Promise<ArkmeMessageCopyLinkExtendResult>;
    forwardSourceMessages(sourceRef: string, actionRefs: readonly string[], options?: {
        representation?: TeamRepresentationSelection;
        targetSourceRef?: string;
        recordUid?: string;
        relationUid?: string;
        commentText?: string;
        expectedUserId?: number;
        sendAtMillis?: number;
        signal?: AbortSignal;
    }): Promise<ArkmeSourceSendResult>;
    sendSourceText(sourceRef: string, textContent: string, options?: {
        recordUid?: string;
        relationUid?: string;
        recordDurationMillis?: number;
        captureContext?: ArkmeRecordCaptureContext;
        botRefs?: readonly string[];
        humanMentions?: readonly ArkmeHumanMentionInput[];
        botMentions?: readonly ArkmeBotMentionInput[];
        expectedUserId?: number;
        signal?: AbortSignal;
        representation?: TeamRepresentationSelection;
        sendAtMillis?: number;
        agentAuthored?: boolean;
    }): Promise<ArkmeSourceSendResult>;
    private mentionContentPayload;
    resolveMentions(source: ArkmeSourceRefPayload, rawText: string, normalizedText: string, humanInputs: readonly ArkmeHumanMentionInput[], botInputs: readonly ArkmeBotMentionInput[], session: ArkmeSessionCredentials, signal?: AbortSignal, textFormat?: 'plain' | 'markdown'): Promise<ResolvedMentions>;
    private humanMentionMetadata;
    private botMentionMetadata;
    groupBotMentionSend(sourceRef: string, source: ArkmeSourceRefPayload, text: string, botRefs: readonly string[], recordUid: string, relationUid: string, session: ArkmeSessionCredentials, signal?: AbortSignal, options?: {
        representation?: TeamRepresentationSelection;
        sendAtMillis?: number;
        agentAuthored?: boolean;
        recordDurationMillis?: number;
        captureContext?: ArkmeRecordCaptureContext;
    }): Promise<ArkmeSourceSendResult>;
    sendChatSourceTextRaw(sourceRef: string, chatSessionUid: string, text: string, recordUid: string, relationUid: string, session: ArkmeSessionCredentials, initialAiPolish?: Record<string, unknown>, contentPayload?: Record<string, unknown>, signal?: AbortSignal, options?: {
        representation?: TeamRepresentationSelection;
        sendAtMillis?: number;
        agentAuthored?: boolean;
        recordDurationMillis?: number;
        captureContext?: ArkmeRecordCaptureContext;
    }): Promise<ArkmeSourceSendResult>;
    private postChatTextRecord;
    sendSourceRich(sourceRef: string, input: ArkmeRichSendInput, options?: {
        recordUid?: string;
        relationUid?: string;
        expectedUserId?: number;
        signal?: AbortSignal;
        sendAtMillis?: number;
    }): Promise<ArkmeSourceSendResult>;
    private favoriteStickerDocument;
    private favoriteStickerView;
    favoriteStickers(signal?: AbortSignal): Promise<ArkmeFavoriteStickerList>;
    addFavoriteSticker(item: ArkmeFavoriteStickerAddInput, signal?: AbortSignal): Promise<ArkmeFavoriteStickerList>;
    manageFavoriteSticker(fileAssetUid: string, action: ArkmeFavoriteStickerManageAction, signal?: AbortSignal): Promise<ArkmeFavoriteStickerList>;
    sendFavoriteSticker(sourceRef: string, fileAssetUid: string, options?: {
        recordUid?: string;
        relationUid?: string;
        signal?: AbortSignal;
    } & import('./../team-group-contract.js').TeamRepresentationSendOptions): Promise<ArkmeSourceSendResult>;
    confirmSourceSend(input: import('../file-transfer-contract.js').ArkmeFileSendInput, signal?: AbortSignal): Promise<ArkmeSourceSendResult | undefined | null>;
    confirmLongArticlePublication(sourceRef: string, input: import('../types.js').ArkmeLongArticlePublishInput, userId: number, signal?: AbortSignal): Promise<ArkmeSourceSendResult>;
    longArticleDetail(sourceRef: string, itemUid: string, signal?: AbortSignal, actionRef?: string): Promise<ArkmeLongArticleDetail>;
    private withLongArticleActions;
    /** Resolve a complete, owned article, never trust a search excerpt as send content. */
    ownLongArticle(itemUid: string, expectedUserId: number, signal?: AbortSignal): Promise<{
        detail: ArkmeLongArticleDetail;
        messageActionRef: string;
    }>;
    updateLongArticle(sourceRef: string, itemUid: string, input: import('../types.js').ArkmeLongArticleUpdateInput & {
        assets?: import('../types.js').ArkmeUploadedAsset[];
    }): Promise<ArkmeLongArticleDetail>;
    getLongArticleDraft(sourceRef: string, itemUid?: string, draftScope?: string): Promise<ArkmeLongArticleDraft | undefined>;
    putLongArticleDraft(draft: ArkmeLongArticleDraft): Promise<void>;
    removeLongArticleDraft(sourceRef: string, itemUid?: string, expectedRecordUid?: string, draftScope?: string): Promise<void>;
    uploadLocalFile(filePath: string, metadata: {
        size: number;
        sha256: string;
        mimeType: string;
        fileName: string;
        fileKind: 1 | 2 | 3 | 4;
    }, options?: {
        expectedUserId?: number;
        signal?: AbortSignal;
    }): Promise<ArkmeUploadedAsset>;
    fetchMedia(mediaRef: string, range?: string, signal?: AbortSignal, method?: 'GET' | 'HEAD'): Promise<{
        response: Response;
        descriptor: ArkmeMediaDescriptor;
    }>;
    sendDirectText(recipientArkmeId: string, textContent: string, options?: {
        recordUid?: string;
        relationUid?: string;
        sendAtMillis?: number;
        signal?: AbortSignal;
    }): Promise<ArkmeDirectTextSendResult>;
    reportMessagePreparing(sourceRef: string, prepareAtMillis: number, options?: {
        signal?: AbortSignal;
    }): Promise<void>;
    cancelMessagePreparing(sourceRef: string, cancelAtMillis: number, options?: {
        signal?: AbortSignal;
    }): Promise<void>;
    private writeMessagePreparing;
    markSourceRead(sourceRef: string, readSequence: number, options?: {
        signal?: AbortSignal;
    }): Promise<ArkmeSourceReadResult>;
    private advanceChatReadCursor;
    chatSourceFromBundle(bundle: Record<string, unknown>, session: ArkmeSessionCredentials, cached: ArkmeSourceItem | undefined, timelineItems: ArkmeTimelineItem[]): Promise<ArkmeSourceItem>;
    private timelineMentionTargets;
    chatTimelineItems(data: Record<string, unknown>, session: ArkmeSessionCredentials, chatSessionUid: string, projectedSourceKind?: 'private_chat' | 'group_chat', bundle?: Record<string, unknown>, signal?: AbortSignal): Promise<ArkmeTimelineItem[]>;
    relatedQuickNoteLocator(sourceRef: string, messageActionRef: string): Promise<ArkmeRelatedQuickNoteSourceLocator>;
    chatForwardRecordsPreview(raw: unknown, viewerUserId: number, fallbackCreatedAtMillis: number): Promise<ArkmeTimelineItem['forwardRecords'] | undefined>;
    chatSharedRecordingPreview(raw: unknown): ArkmeTimelineItem['sharedRecording'] | undefined;
    private sharedRecordingParticipantsFromPayload;
    private sharedRecordingTranscriptFromPayload;
    private sharedRecordingPreviewFromPayload;
    private sharedRecordingSourceDigestCompatible;
    private withSharedRecordingDetailRef;
    private sealSharedRecordingDetailRef;
    private openSharedRecordingDetailRef;
    calendarSharedRecordingPreview(raw: unknown, session: ArkmeSessionCredentials): Promise<ArkmeSharedRecordingPreview | undefined>;
    sharedRecordingDetail(detailRef: string, options?: {
        signal?: AbortSignal;
    }): Promise<ArkmeSharedRecordingPreview>;
    messageSnapshotDetail(sourceRef: string, actionRef: string, options?: {
        signal?: AbortSignal;
        includeAttachments?: boolean;
    }): Promise<ArkmeMessageSnapshotDetail>;
    private hydratedMessageSnapshotDetail;
    saveMessageLocation(sourceRef: string, itemUid: string, location: ArkmeRecordLocationCapture, recordVersion: number | undefined, options?: {
        signal?: AbortSignal;
    }): Promise<void>;
    resolvePrivateChatPeer(sourceRef: string, signal?: AbortSignal): Promise<{
        userId: number;
        displayName: string;
    }>;
    private rawChatMembers;
    private projectChatMembers;
    projectUnifiedMemberJoins(payloads: Record<string, unknown>[], source: ArkmeSourceRefPayload, session: ArkmeSessionCredentials, signal?: AbortSignal): Promise<(ArkmeTimelineMemberJoinEvent | undefined)[]>;
    projectChatTimelineItems(rawItems: unknown[], source: ArkmeSourceRefPayload, session: ArkmeSessionCredentials, signal?: AbortSignal, options?: {
        basicPresentation?: boolean;
    }): Promise<ArkmeTimelineItem[]>;
    private timelineBotDisplayProfiles;
    private timelineSenderName;
    private timelineBotAvatar;
    private timelineExtensionProjection;
    private hydrateTimelineExtensionParents;
    private sealChatMemberRef;
    private openChatMemberRef;
    private sealChatHumanMentionRef;
    private openChatHumanMentionRef;
    private messageActionRefPayload;
    /**
     * Attach the same signed action reference used by authoritative timeline reads
     * directly to a confirmed send result. Signing is best-effort after the remote
     * write: a local key-store failure must never turn an accepted write into a
     * retryable send failure.
     */
    private withConfirmedSendReferences;
    private withPersonalRecordCapabilities;
    private withRecordMessageActionRef;
    private sealMessageActionRef;
    private openMessageActionRefs;
    private openMessageActionRef;
    private forwardPayloadItem;
    private forwardClientRequestId;
    private forwardReferencesOrderedForCommand;
    private validateForwardReferences;
    private forwardSourceItemBody;
    sealMessageRef(userId: number, chatSessionUid: string, relationUid: string, signingKey: string): string;
    private sealMessageWithdrawalRef;
    private openMessageWithdrawalRef;
    private sealJoinRestrictionCursor;
    private openJoinRestrictionCursor;
    private openSignedOpaquePayload;
    openMessageRef(messageRef: string, expectedUserId: number): Promise<ArkmeMessageRefPayload>;
}
export {};
//# sourceMappingURL=chat-service.d.ts.map