import { ArkmeRequestCoordinator, type ArkmeRequestLane, type ArkmeRequestService, type ArkmeRequestStats } from '../request-coordinator.js';
import type { ArkmeSessionCredentials, ArkmeSessionStore } from '../keychain-store.js';
import { ArkmeAccountSessionOwner } from '../account-session-owner.js';
import type { RecentEmojiStore } from '../emoji-recent.js';
import type { ArkmeCachedQueryResult, ArkmeCachedSnapshot, ArkmeEnvironment, ArkmeLongArticleDraft, ArkmePendingWrite, ArkmeRecordReeditDraft, ArkmeRecordCursor, ArkmeSelfRecordList, ArkmeSelfSummary, ArkmeUserProfile, ArkmeUserProfileSnapshot, ArkmePluginErrorBody } from '../types.js';
import type { ArkmeExtensionReviewOperation } from '../extensions/types.js';
import type { RecordingImportAdmission, RecordingImportJob } from '../recording-import-contract.js';
export interface StateStore extends RecentEmojiStore {
    teamOutboundTarget(scope: string, requestUid: string): Promise<import('../team-outbound-contract.js').TeamOutboundRecovery | undefined>;
    retainTeamOutboundTarget(scope: string, requestUid: string, value: import('../team-outbound-contract.js').TeamOutboundRecovery): Promise<void>;
    readonly selfNoteQuotes?: import('../local-self-note-quotes.js').LocalSelfNoteQuotes;
    readonly worldReactions?: import('../local-world-reactions.js').LocalWorldReactions;
    localTranscriptEntries?(account: string, scope: string, ids: string[], change?: import('../local-transcript-state.js').LocalTranscriptChange): Promise<Record<string, import('../local-transcript-state.js').LocalTranscriptEntry>>;
    arkoPendingTurns(userId: number): Promise<import('../arko-turn-contract.js').ArkmeArkoPendingTurn[]>;
    arkoTurn(userId: number, uid: string): Promise<import('../arko-turn-contract.js').ArkmeArkoStoredTurn | undefined>;
    prepareArkoTurn(userId: number, turn: import('../arko-turn-contract.js').ArkmeArkoPendingTurn, request?: Record<string, unknown>): Promise<void>;
    acknowledgeArkoTurn(userId: number, uid: string): Promise<void>;
    arkoFileRefs(userId: number): Promise<string[]>;
    readDayReviewPending?(scope: string, day: string): Promise<unknown>;
    prepareDayReview?(scope: string, day: string, request: Record<string, unknown>): Promise<void>;
    acknowledgeDayReview?(scope: string, day: string, requestId: string): Promise<void>;
    readOfflineContextJournal?(scope: string): Promise<Record<string, import('../offline-context-contract.js').OfflineContextJournalEntry>>;
    putOfflineContextJournal?(scope: string, id: string, entry: import('../offline-context-contract.js').OfflineContextJournalEntry): Promise<void>;
    deleteOfflineContextJournal?(scope: string, id: string, fingerprint: string): Promise<void>;
    localDirectoryPreferences?(accountKey: string, entries?: import('../local-directory-preferences.js').LocalDirectoryPreferences, migrate?: boolean): Promise<import('../local-directory-preferences.js').LocalDirectoryPreferences>;
    readConversationViewports?(accountKey: string, surface: string): Promise<import('../conversation-viewport-state.js').ConversationViewportEntries>;
    writeConversationViewports?(accountKey: string, surface: string, entries: import('../conversation-viewport-state.js').ConversationViewportEntries): Promise<void>;
    arrangementBoardCache?(environment: string, userId: number, pages?: import('../arrangement-board-cache.js').ArkmeArrangementBoardCachePages): Promise<import('../arrangement-board-cache.js').ArkmeArrangementBoardCachePages>;
    readCancellationCompletion?(): Promise<import('../state-store.js').ArkmeCancellationCompletion | undefined>;
    writeCancellationCompletion?(completion: import('../state-store.js').ArkmeCancellationCompletion | undefined): Promise<void>;
    readonly messageMarks?: import('../local-message-marks.js').LocalMessageMarkStore;
    readonly commonGroups?: import('../common-groups.js').CommonGroupStore;
    readRecordingSpeakerCache?(scope: string, userId: number): Promise<import('../types.js').ArkmeRecordingSpeakerCandidate[] | undefined>;
    writeRecordingSpeakerCache?(scope: string, userId: number, candidates: import('../types.js').ArkmeRecordingSpeakerCandidate[]): Promise<void>;
    clearRecordingSpeakerCache?(scope: string, userId: number): Promise<void>;
    readDirectoryCache?(userId: number): Promise<import('../types.js').ArkmeSourceList | undefined>;
    writeDirectoryCache?(userId: number, page: import('../types.js').ArkmeSourceList): Promise<void>;
    readAvatarCache?(userId: number, imageRef: string): Promise<import('../types.js').ArkmeImageBytes | undefined>;
    writeAvatarCache?(userId: number, imageRef: string, image: import('../types.js').ArkmeImageBytes): Promise<void>;
    selfRoleAvatarLocalRef?(userId: number, fileAssetUid: string): Promise<string | undefined>;
    forgetCachedMembers?(userId: number, group: string, refs: readonly string[]): Promise<void>;
    cachedConversationMembers?(userId: number, group: string): Promise<import('../types.js').ArkmeConversationMemberCache | undefined>;
    mergeConversationMembers?(userId: number, group: string, page: import('../types.js').ArkmeConversationMemberUpdate): Promise<void>;
    clearConversationMembers?(userId: number, group: string): Promise<void>;
    uniqueCode(): Promise<string>;
    cachedSnapshot(userId: number): Promise<ArkmeCachedSnapshot>;
    cacheSummary(userId: number, summary: ArkmeSelfSummary): Promise<void>;
    cachePage(userId: number, page: ArkmeSelfRecordList, requestCursor?: ArkmeRecordCursor): Promise<void>;
    queryCached(userId: number, options: {
        query?: string;
        limit: number;
        beforeMillis?: number;
    }): Promise<ArkmeCachedQueryResult>;
    revision(userId: number): Promise<number>;
    cachedProfile(userId: number): Promise<ArkmeUserProfileSnapshot>;
    cacheProfile(userId: number, profile: ArkmeUserProfile): Promise<ArkmeUserProfileSnapshot>;
    listPending(userId: number): Promise<ArkmePendingWrite[]>;
    putPending(userId: number, pending: ArkmePendingWrite): Promise<void>;
    markAttempt(userId: number, recordUid: string, error: string): Promise<void>;
    markSynced(userId: number, recordUid: string, status: number): Promise<void>;
    listExtensionReviewOperations(userId: number): Promise<ArkmeExtensionReviewOperation[]>;
    putExtensionReviewOperation(userId: number, operation: ArkmeExtensionReviewOperation): Promise<void>;
    markExtensionReviewOperation(userId: number, clientMutationId: string, state: ArkmeExtensionReviewOperation['state'], error?: string): Promise<void>;
    removeExtensionReviewOperation(userId: number, clientMutationId: string): Promise<void>;
    getLongArticleDraft(userId: number, sourceRef: string, itemUid?: string, draftScope?: string): Promise<ArkmeLongArticleDraft | undefined>;
    putLongArticleDraft(userId: number, draft: ArkmeLongArticleDraft): Promise<void>;
    removeLongArticleDraft(userId: number, sourceRef: string, itemUid?: string, expectedRecordUid?: string, draftScope?: string): Promise<void>;
    getRecordReeditDraft(userId: number, sourceIdentityKey: string, itemUid: string): Promise<ArkmeRecordReeditDraft | undefined>;
    putRecordReeditDraft(userId: number, draft: Omit<ArkmeRecordReeditDraft, 'draftRevision'>, expectedRevision?: number): Promise<ArkmeRecordReeditDraft>;
    recordReeditFileRefs(userId: number): Promise<string[]>;
    listRecordReeditSubmissions(userId: number): Promise<import('../record-reedit-contract.js').ArkmeRecordReeditSubmission[]>;
    acknowledgeRecordReeditSubmission(userId: number, identity: string, submissionId: string, version: number): Promise<void>;
    discardRecordReeditCandidate(userId: number, sourceIdentityKey: string, itemUid: string, expectedRevision: number): Promise<boolean>;
    putRecordReeditSubmission(userId: number, job: import('../record-reedit-contract.js').ArkmeRecordReeditSubmission, expectedId?: string): Promise<void>;
    removeRecordReeditDraft(userId: number, sourceIdentityKey: string, itemUid: string, expectedRevision: number, expectedCandidate?: ArkmeRecordReeditDraft): Promise<boolean>;
    listRecordingImportJobs(userId: number): Promise<RecordingImportJob[]>;
    planRecordingToolBatch?(scope: string, candidates: Array<{
        key: string;
        isNew: boolean;
        strategy?: import('../recording-strategy-contract.js').RecordingStrategy;
    }>, timeZone: string, signal?: AbortSignal): Promise<Record<string, import('../recording-tool-batch.js').RecordingToolBatchMember>>;
    listAllRecordingImportJobs(): Promise<RecordingImportJob[]>;
    getRecordingImportJob(userId: number, jobId: string): Promise<RecordingImportJob | undefined>;
    putRecordingImportJob(userId: number, job: RecordingImportJob): Promise<void>;
    admitRecordingImportJob(userId: number, job: RecordingImportJob, signal?: AbortSignal): Promise<RecordingImportAdmission>;
    replaceRecordingImportJob(userId: number, job: RecordingImportJob, expectedRevision: number, signal?: AbortSignal): Promise<boolean>;
    removeRecordingImportJob(userId: number, jobId: string): Promise<void>;
}
export interface ArkmeServiceConfig {
    environment: ArkmeEnvironment;
    dshRemoteRealtimeBaseUrl?: string;
    authBaseUrl: string;
    subjectBaseUrl: string;
    recordBaseUrl: string;
    dataBaseUrl?: string;
    teamBaseUrl?: string;
    chatBaseUrl: string;
    botBaseUrl: string;
    imBaseUrl: string;
    webrtcBaseUrl: string;
    worldBaseUrl: string;
    relationBaseUrl: string;
    intelligentBaseUrl: string;
    memoryCoreBaseUrl?: string;
    routePath: string;
    audioBaseUrl: string;
    extensionPublishBaseUrl?: string;
    requestTimeoutMs: number;
    maxTextLength: number;
    geetestCaptchaId: string;
    baiduMapBrowserAk?: string;
    relatedRecordingsEnabled?: boolean;
    interwovenMomentsEnabled: boolean;
    /** Explicit rollback only; never fall back automatically after a view-query error. */
    selfCalendarViewsEnabled?: boolean;
    recordingWorkbenchEnabled?: boolean;
    chatMemberJoinEventsEnabled?: boolean;
    shareWebsite?: string;
    richMediaRenderEnabled?: boolean;
    markdownQuickNotesEnabled?: boolean;
    markdownLongArticlesEnabled?: boolean;
    richMediaSendEnabled?: boolean;
    maxUploadBytes?: number;
    recordingImportDirectory?: string;
    fileStateDirectory?: string;
}
export type FetchLike = typeof fetch;
type ArkmePostBody = Record<string, unknown> | FormData;
export interface ArkmeRemoteRequestOptions {
    /** Reserved for realtime message projection; only exact read routes are eligible. */
    traffic?: 'message-sync';
    lane?: ArkmeRequestLane;
    service?: ArkmeRequestService;
    scope?: string;
    key?: string;
    cacheMs?: number;
    failureCooldownMs?: number;
    bypassCache?: boolean;
    /** Cancel a shared read transport once its last subscriber leaves. */
    cancelWhenUnobserved?: boolean;
    /** Optional writes may avoid publishing service-wide cooldowns; existing admission limits still apply. */
    publishServiceCooldown?: boolean;
    /** Mark only transport outcomes where a mutation may have reached its owner without a usable acknowledgement. */
    trackWriteOutcome?: boolean;
}
export declare class ArkmePluginError extends Error {
    readonly code: string;
    readonly retryable: boolean;
    readonly httpStatus: number;
    readonly publishReceipt?: ArkmePluginErrorBody['publishReceipt'];
    readonly upstreamStatus?: number;
    readonly retryAfterMillis?: number;
    readonly failureKind?: ArkmePluginErrorBody['failureKind'];
    readonly retryScope?: ArkmePluginErrorBody['retryScope'];
    readonly recovery?: ArkmePluginErrorBody['recovery'];
    readonly imageFailures?: ArkmePluginErrorBody['imageFailures'];
    /** The owner mutation may have completed, but the caller did not receive a usable acknowledgement. */
    readonly writeOutcomeUnknown?: true;
    constructor(code: string, message: string, retryable: boolean, httpStatus?: number, options?: ErrorOptions & {
        upstreamStatus?: number;
        retryAfterMillis?: number;
        writeOutcomeUnknown?: boolean;
        publishReceipt?: ArkmePluginErrorBody['publishReceipt'];
        failureKind?: ArkmePluginErrorBody['failureKind'];
        retryScope?: ArkmePluginErrorBody['retryScope'];
        recovery?: ArkmePluginErrorBody['recovery'];
        imageFailures?: ArkmePluginErrorBody['imageFailures'];
    });
}
/** Opaque upstream body, for the owning business adapter only. Never serialize this error wholesale. */
export declare class ArkmeUpstreamResponseError extends ArkmePluginError {
    readonly responseData: unknown;
    constructor(code: string, message: string, retryable: boolean, httpStatus: number, responseData: unknown, options?: ConstructorParameters<typeof ArkmePluginError>[4]);
}
export interface ArkmeOwnerReadPort {
    runOwnerRead<T>(route: string, parameters: Record<string, unknown>, operation: (signal: AbortSignal) => Promise<T>, signal?: AbortSignal): Promise<T>;
    withOwnerReadInvalidation<T>(route: string, operation: () => Promise<T>): Promise<T>;
}
export declare function stringValue(value: unknown): string;
export declare function knownStringValue<T extends string>(value: unknown, allowed: ReadonlySet<T>): T | undefined;
export declare function clippedText(value: unknown, limit?: number): string;
export declare function objectValue(value: unknown): Record<string, unknown>;
export declare function joinUrl(baseUrl: string, path: string): string;
export declare class ServiceRuntime {
    readonly config: ArkmeServiceConfig;
    readonly sessionStore: ArkmeSessionStore;
    readonly stateStore: StateStore;
    readonly fetchImpl: FetchLike;
    readonly pendingSessionStore?: ArkmeSessionStore | undefined;
    private memberCacheRevision;
    memberCacheEpoch(): number;
    invalidateMemberCache(): void;
    readonly requestCoordinator: ArkmeRequestCoordinator;
    private readonly messageSyncCoordinator;
    private readonly messageSyncLane;
    private readonly refreshInFlightByUserId;
    private readonly accountSessions;
    private pendingBindingSession;
    constructor(config: ArkmeServiceConfig, sessionStore: ArkmeSessionStore, stateStore: StateStore, fetchImpl?: FetchLike, pendingSessionStore?: ArkmeSessionStore | undefined, accountSessions?: ArkmeAccountSessionOwner);
    startAccountScope(): Promise<void>;
    attachGuestConversationProbe(probe: () => Promise<boolean>): void;
    accountScopeReady(): boolean;
    subscribeAccountScope(listener: () => void): () => void;
    accountScopedSession(): Promise<ArkmeSessionCredentials | undefined>;
    writeSession(session: ArkmeSessionCredentials): Promise<void>;
    deleteSession(): Promise<void>;
    deleteSessionIfCurrent(expected: ArkmeSessionCredentials): Promise<boolean>;
    activatePendingBindingSession(expected: ArkmeSessionCredentials): Promise<void>;
    moveSessionToPendingBinding(expected: ArkmeSessionCredentials): Promise<boolean>;
    requestStats(): Record<string, ArkmeRequestStats>;
    requestScope(userId: number | undefined): string;
    private readonly readRevisions;
    readRevision(scope: string): number;
    private readonly calendarRevisions;
    private calendarVersion;
    calendarReadRevision(scope: string, start: string, end: string, timezone: string): string;
    /** Chat deltas invalidate only affected composite month results (in any timezone). */
    invalidateCalendarDates(scope: string, stamps: number[]): void;
    withOwnerReadInvalidation<T>(route: string, operation: () => Promise<T>): Promise<T>;
    runOwnerRead<T>(route: string, parameters: Record<string, unknown>, operation: (signal: AbortSignal) => Promise<T>, signal?: AbortSignal): Promise<T>;
    /** Only for composites whose child requests already pass through transport admission. */
    runBackgroundMessageProjection<T>(operation: () => Promise<T>): Promise<T>;
    runCompositeOwnerRead<T>(route: string, parameters: Record<string, unknown>, operation: (signal: AbortSignal) => Promise<T>, signal?: AbortSignal, lane?: 'interactive-read' | 'background-read'): Promise<T>;
    private ownerRead;
    invalidateScope(scope: string): void;
    invalidateKey(scope: string, key: string): void;
    dispose(): void;
    requireSession(): Promise<ArkmeSessionCredentials>;
    requireAuthFlowSession(): Promise<ArkmeSessionCredentials>;
    isPendingBindingSession(session: ArkmeSessionCredentials): boolean;
    readPendingBindingSession(): Promise<ArkmeSessionCredentials | undefined>;
    writePendingBindingSession(session: ArkmeSessionCredentials): Promise<void>;
    clearPendingBindingSession(): Promise<void>;
    clearRefreshForUser(userId: number): void;
    refreshAccessToken(session: ArkmeSessionCredentials, signal?: AbortSignal): Promise<ArkmeSessionCredentials>;
    private requestService;
    private remoteServiceCooldownMs;
    private registeredRead;
    post<T>(baseUrl: string, path: string, body: ArkmePostBody, bearer: string | undefined, successCodes: readonly number[], signal?: AbortSignal, preferDataError?: boolean, options?: ArkmeRemoteRequestOptions, preserveHttpError?: boolean, preserveForbiddenError?: boolean): Promise<T>;
    postDirect<T>(baseUrl: string, path: string, body: ArkmePostBody, bearer: string | undefined, successCodes: readonly number[], signal?: AbortSignal, preferDataError?: boolean, preserveHttpError?: boolean, preserveForbiddenError?: boolean): Promise<T>;
    get<T>(baseUrl: string, path: string, bearer: string | undefined, successCodes: readonly number[], signal?: AbortSignal, options?: ArkmeRemoteRequestOptions, preferDataError?: boolean): Promise<T>;
    getDirect<T>(baseUrl: string, path: string, bearer: string | undefined, successCodes: readonly number[], signal?: AbortSignal, preferDataError?: boolean): Promise<T>;
    authenticatedRequestOptions(session: ArkmeSessionCredentials, service: ArkmeRequestService, defaultLane: ArkmeRequestLane, options: ArkmeRemoteRequestOptions): ArkmeRemoteRequestOptions;
    authenticatedAuthGet<T>(path: string, initialSession?: ArkmeSessionCredentials, signal?: AbortSignal, options?: ArkmeRemoteRequestOptions): Promise<T>;
    authenticatedDshRemoteGet<T>(path: string, signal?: AbortSignal): Promise<T>;
    authenticatedPost<T>(path: string, body: Record<string, unknown>, initialSession?: ArkmeSessionCredentials, signal?: AbortSignal, options?: ArkmeRemoteRequestOptions): Promise<T>;
    authenticatedCalendarPost<T>(path: string, body: Record<string, unknown>, initialSession?: ArkmeSessionCredentials, signal?: AbortSignal, options?: ArkmeRemoteRequestOptions): Promise<T>;
    authenticatedDataPost<T>(path: string, body: Record<string, unknown>, initialSession?: ArkmeSessionCredentials, signal?: AbortSignal, options?: ArkmeRemoteRequestOptions): Promise<T>;
    authenticatedAuthPost<T>(path: string, body: Record<string, unknown>, initialSession?: ArkmeSessionCredentials, signal?: AbortSignal, options?: ArkmeRemoteRequestOptions): Promise<T>;
    authenticatedAuthMultipartPost<T>(path: string, body: FormData, initialSession?: ArkmeSessionCredentials, signal?: AbortSignal): Promise<T>;
    /** Read a legacy private owner hosted by the main authenticated API. */
    authenticatedAuthReadPost<T>(path: string, body: Record<string, unknown>, initialSession?: ArkmeSessionCredentials, signal?: AbortSignal, options?: ArkmeRemoteRequestOptions): Promise<T>;
    /** Read a public auth endpoint while isolating coordination and caching to the active account. */
    accountScopedPublicAuthReadPost<T>(path: string, body: Record<string, unknown>, viewerUserId: number, signal?: AbortSignal, options?: ArkmeRemoteRequestOptions): Promise<T>;
    authenticatedDshRemotePost<T>(path: string, body: Record<string, unknown>, initialSession?: ArkmeSessionCredentials, signal?: AbortSignal): Promise<T>;
    authenticatedSubjectPost<T>(path: string, body: Record<string, unknown>, initialSession?: ArkmeSessionCredentials, signal?: AbortSignal): Promise<T>;
    authenticatedTeamPost<T>(path: string, body: Record<string, unknown>, initialSession?: ArkmeSessionCredentials, signal?: AbortSignal, read?: boolean): Promise<T>;
    authenticatedChatPost<T>(path: string, body: Record<string, unknown>, initialSession?: ArkmeSessionCredentials, signal?: AbortSignal, options?: ArkmeRemoteRequestOptions & {
        refreshOnUnauthorized?: boolean;
    }): Promise<T>;
    authenticatedBotPost<T>(path: string, body: Record<string, unknown>, initialSession?: ArkmeSessionCredentials, signal?: AbortSignal, options?: ArkmeRemoteRequestOptions & {
        refreshOnUnauthorized?: boolean;
    }): Promise<T>;
    authenticatedWebrtcPost<T>(path: string, body: Record<string, unknown>, initialSession?: ArkmeSessionCredentials, signal?: AbortSignal, options?: ArkmeRemoteRequestOptions): Promise<T>;
    authenticatedAudioPost<T>(path: string, body: Record<string, unknown>, initialSession?: ArkmeSessionCredentials, signal?: AbortSignal, options?: ArkmeRemoteRequestOptions): Promise<T>;
    /** Binary service reads keep account scope and credentials in the Host. */
    authenticatedAudioStream(path: string, options: {
        expectedUserId: number;
        maxBytes?: number;
        range?: string;
        signal?: AbortSignal;
        method?: 'GET' | 'HEAD';
    }): Promise<Response>;
    private openAudioStream;
    authenticatedAudioMultipartPost<T>(path: string, body: FormData, initialSession?: ArkmeSessionCredentials, signal?: AbortSignal, options?: ArkmeRemoteRequestOptions): Promise<T>;
    authenticatedRelationPost<T>(path: string, body: Record<string, unknown>, initialSession?: ArkmeSessionCredentials, signal?: AbortSignal, options?: ArkmeRemoteRequestOptions): Promise<T>;
    authenticatedRelationGet<T>(path: string, initialSession?: ArkmeSessionCredentials, signal?: AbortSignal): Promise<T>;
    authenticatedMemoryCorePost<T>(path: string, body: Record<string, unknown>, initialSession?: ArkmeSessionCredentials, signal?: AbortSignal, write?: boolean): Promise<T>;
    authenticatedWorldPost<T>(path: string, body: Record<string, unknown>, initialSession?: ArkmeSessionCredentials, signal?: AbortSignal, options?: ArkmeRemoteRequestOptions): Promise<T>;
    /** Keep the body inside coordinator admission until consumption ends. No stream
     * recovery: a retry after a delivered item would splice two snapshots. */
    intelligentExportStream<T>(initialSession: ArkmeSessionCredentials, consume: (body: ReadableStream<Uint8Array>, signal: AbortSignal) => Promise<T>, signal?: AbortSignal): Promise<T>;
    authenticatedIntelligentPost<T>(path: string, body: Record<string, unknown>, initialSession?: ArkmeSessionCredentials, signal?: AbortSignal, options?: ArkmeRemoteRequestOptions): Promise<T>;
    extensionPost<T>(path: string, body: Record<string, unknown>, signal?: AbortSignal, options?: ArkmeRemoteRequestOptions): Promise<T>;
}
export {};
//# sourceMappingURL=service.d.ts.map