import type { TeamMemberAvatarPort } from './team-service.js';
import type { ArkmeSessionCredentials } from '../keychain-store.js';
import type { TeamMessage, TeamSide, TeamAppOperation } from '../team-app-contract.js';
import { type ServiceRuntime } from './service.js';
import type { ChatService } from './chat-service.js';
import type { SourceService } from './source-service.js';
import type { TeamMemberCandidatePort } from '../team-member-add-contract.js';
/** App business adapter. Never uses Team OpenAPI or stores Chat session state. */
export declare class TeamAppService {
    private readonly runtime;
    private readonly avatars;
    private readonly privateChat?;
    private readonly contacts?;
    private readonly memberCandidates?;
    private readonly outboundTargets?;
    private readonly policies;
    private policy;
    private readonly codec;
    private readonly memberAvatars;
    constructor(runtime: ServiceRuntime, avatars: TeamMemberAvatarPort, privateChat?: (Pick<ChatService, "openPrivateChatFromUser"> & Partial<Pick<ChatService, "chatSharedRecordingPreview">>) | undefined, contacts?: (Pick<SourceService, "privateRemarksByUserIds"> & Partial<Pick<SourceService, "openSourceRef">>) | undefined, memberCandidates?: TeamMemberCandidatePort | undefined, outboundTargets?: import("../team-outbound-contract.js").TeamOutboundTargetPort | undefined);
    private ref;
    private open;
    resolveConversation(ref: string, actor: number): Promise<{
        conversation_uid: string;
        side: TeamSide;
    }>;
    resolveMessageSelection(conversationRef: string, selections: unknown, actor: number): Promise<{
        conversation_uid: string;
        message_uid: string;
        side: TeamSide;
        expected_record_version: number;
    }[]>;
    messageReceipt(raw: unknown, actor: number, context: {
        conversation_uid: string;
        side: TeamSide;
    }): Promise<TeamMessage>;
    conversationKey(ref: string, actor: number): Promise<string>;
    reactionTarget(conversationRef: string, messageRef: string): Promise<import('./reaction-service.js').ReactionWireTarget>;
    /** Presentation aliases for actors already authorized by the reaction owner. */
    reactionActorKeys(conversationRef: string, ids: readonly number[]): Promise<Map<number, string>>;
    replyKey(conversationRef: string, messageRef: string, actor: number): Promise<string>;
    private mentionContent;
    private key;
    private identity;
    searchContactTeam(jotmoId: string, session: ArkmeSessionCredentials, signal?: AbortSignal): Promise<import('../types.js').ArkmeContactTeamSearchResult | undefined>;
    private team;
    private avatar;
    private profile;
    private profileResult;
    private channel;
    private conversation;
    private mediaItems;
    private message;
    private externalShare;
    resolveMessageNotification(hint: {
        eventUid: string;
        messageUid: string;
        conversationUid: string;
    }, session: ArkmeSessionCredentials, signal: AbortSignal): Promise<{
        eventUid: string;
        sourceRef: string;
        sourceKey: string;
        sourceKind: "team_conversation";
        title: string;
        body: string;
        eventAtMillis: number;
        expiresAtMillis: number;
    } | undefined>;
    assertViewer(expectedAccountKey: unknown): Promise<ArkmeSessionCredentials>;
    /** Private annotations reuse the local SQLite store. No cloud write or Chat reference. */
    private localMarks;
    execute(operation: TeamAppOperation, p: Record<string, unknown>, signal?: AbortSignal): Promise<unknown>;
    private checkTeamJotmoId;
    private dispatch;
    private readBytes;
    fetchMedia(mediaRef: string, range: string | undefined, signal: AbortSignal): Promise<{
        response: Response;
        fileName: string;
        mimeType: string;
        size: number;
    }>;
    private image;
}
//# sourceMappingURL=team-app-service.d.ts.map