import { type ArkmeWorldShareResult } from '../types.js';
import type { ArkmeImageBytes, ArkmeConversationWriteResult, ArkmeCreateFileAssetRecordResult, ArkmeUploadedAsset, ArkmeWorldAuthorLabel, ArkmeWorldFeedItem, ArkmeWorldFeedPage, ArkmeWorldVoiceprintAvailability, ArkmeWorldVoiceprintPlaybackChunk, ArkmeWorldVoiceprintSocialContext, ArkmeWorldInteractionCreateResult, ArkmeWorldInteractionPage, ArkmeWorldInteractionSummary, ArkmeWorldNotificationSourcePage, ArkmeWorldNotificationTarget, ArkmeWorldPublishResult, ArkmeWorldPublishFileAssetsInput, ArkmeWorldPublishTextInput, ArkmeWorldRecordList } from '../types.js';
import type { ArkmeWorldImageEntry } from './media-service.js';
import type { ArkmeUserProfileSnapshot } from '../types.js';
import { ServiceRuntime } from './service.js';
export interface ArkmeWorldProfileReader {
    refreshProfile(): Promise<ArkmeUserProfileSnapshot>;
}
export interface ArkmeWorldViewerLabelReader {
    privateDisplayNamesByUserIds(userIds: readonly number[], options?: {
        signal?: AbortSignal;
    }): Promise<Map<number, string>>;
}
export interface ArkmeWorldMediaReader {
    issueWorldVoiceprintMediaRef(viewerUserId: number, input: {
        remoteUrl: string;
        mimeType: string;
    }): string;
    downloadSignedImage(signedUrl: URL, byteLimit: number, signal?: AbortSignal): Promise<ArkmeImageBytes>;
}
export interface ArkmeWorldRecordWriter {
    createTextForConversation(recordUid: string, textContent: string): Promise<ArkmeConversationWriteResult>;
    createFileAssetsForConversation(recordUid: string, textContent: string, assets: readonly ArkmeUploadedAsset[]): Promise<ArkmeCreateFileAssetRecordResult>;
}
export interface ArkmeWorldVoiceprintInviteIntent {
    peerUserId: number;
    peerDisplayName: string;
    inviteUrl: string;
    expiresAtMillis: number;
    textPreview?: string;
    imageCount?: number;
    videoCount?: number;
    voiceCount?: number;
}
export declare class WorldService {
    private readonly runtime;
    private readonly profile;
    private readonly media;
    private readonly record;
    private readonly viewerLabels?;
    private epoch;
    /** Called only for a Record-owner-authorized received-reaction response. */
    reactionReference(recordUid: string): Promise<string>;
    reactionTarget(recordRef: string): Promise<import('./reaction-service.js').ReactionWireTarget>;
    private readonly worldImageRefs;
    private readonly worldAvatarResolutionCache;
    private readonly extensionPublicationShareCache;
    private readonly extensionPublicationShareInFlight;
    private readonly worldRecordRefs;
    private readonly authorMemberships;
    private readonly authorMembershipInFlight;
    private readonly authorMembershipRequests;
    private readonly voiceprintSocialCache;
    private readonly voiceprintSocialInFlight;
    constructor(runtime: ServiceRuntime, profile: ArkmeWorldProfileReader, media: ArkmeWorldMediaReader, record: ArkmeWorldRecordWriter, viewerLabels?: ArkmeWorldViewerLabelReader | undefined);
    dispose(): void;
    /** Recheck publication at open time; cached timeline references never grant access to private records. */
    readWorldRecord(recordRef: string, signal?: AbortSignal): Promise<ArkmeWorldFeedItem>;
    /** Share the existing public URL, never a private Record or a copied media snapshot. */
    shareWorldRecord(recordRef: string, expectedUserId: number, signal?: AbortSignal): Promise<ArkmeWorldShareResult>;
    listWorldRecords(options?: {
        limit?: number;
        offset?: number;
        signal?: AbortSignal;
    }): Promise<ArkmeWorldRecordList>;
    listWorldFeed(options?: {
        limit?: number;
        offset?: number;
        signal?: AbortSignal;
    }): Promise<ArkmeWorldFeedPage>;
    listMyWorldFeed(options?: {
        limit?: number;
        offset?: number;
        signal?: AbortSignal;
    }): Promise<ArkmeWorldFeedPage>;
    listUserWorldFeed(userId: number, options?: {
        limit?: number;
        offset?: number;
        signal?: AbortSignal;
    }): Promise<ArkmeWorldFeedPage>;
    worldVoiceprintPlaybackAvailability(recordRefs: readonly string[], signal?: AbortSignal): Promise<ArkmeWorldVoiceprintAvailability>;
    generateWorldVoiceprintPlayback(input: {
        recordRef: string;
        chunkIndex?: number;
        signal?: AbortSignal;
    }): Promise<ArkmeWorldVoiceprintPlaybackChunk>;
    worldVoiceprintSocialContext(recordRef: string, options?: {
        forceRefresh?: boolean;
        signal?: AbortSignal;
    }): Promise<ArkmeWorldVoiceprintSocialContext>;
    createWorldVoiceprintInviteIntent(recordRef: string, signal?: AbortSignal): Promise<ArkmeWorldVoiceprintInviteIntent>;
    private refreshWorldVoiceprintSocialContext;
    private loadWorldVoiceprintSocialContext;
    private guardWorldVoiceprintSocialSource;
    private loadWorldVoiceprintReciprocalExpectation;
    private loadWorldVoiceprintDirectChat;
    private loadWorldVoiceprintInterwovenRelations;
    private loadWorldVoiceprintPrivateChatRelation;
    private loadWorldVoiceprintCommentRelation;
    private dedupeWorldVoiceprintRelations;
    private mergeWorldVoiceprintSocialContexts;
    listWorldInteractions(recordRef: string, options?: {
        limit?: number;
        offset?: number;
        signal?: AbortSignal;
    }): Promise<ArkmeWorldInteractionPage>;
    /** my-list includes both original posts and comments; feed filtering must not be applied here. */
    worldNotificationSources(offset?: number, signal?: AbortSignal): Promise<ArkmeWorldNotificationSourcePage>;
    /** Resolve the current public ancestor chain; an old notification never bypasses visibility. */
    worldNotificationTarget(interactionRef: string, signal?: AbortSignal): Promise<ArkmeWorldNotificationTarget>;
    worldInteractionSummary(signal?: AbortSignal): Promise<ArkmeWorldInteractionSummary>;
    markWorldInteractionsViewed(seenThroughSequence: number, signal?: AbortSignal): Promise<ArkmeWorldInteractionSummary>;
    createWorldTextInteraction(input: {
        targetRef: string;
        textContent: string;
        clientMutationId: string;
        signal?: AbortSignal;
    }): Promise<ArkmeWorldInteractionCreateResult>;
    readWorldImage(imageRef: string, options?: {
        maxBytes?: number;
        signal?: AbortSignal;
    }): Promise<ArkmeImageBytes>;
    publishWorldTextForConversation(recordUid: string, textContent: string, signal?: AbortSignal): Promise<ArkmeWorldPublishResult>;
    publishWorldText(input: ArkmeWorldPublishTextInput): Promise<ArkmeWorldPublishResult>;
    publishWorldFileAssets(input: ArkmeWorldPublishFileAssetsInput): Promise<ArkmeWorldPublishResult>;
    private worldRecordItem;
    private worldFeedItem;
    private extensionPublicationShare;
    private loadExtensionPublicationShare;
    private isTrustedWorldImageUrl;
    private resolveWorldAvatarUrls;
    private worldInteractionItem;
    private worldRecordRef;
    /** Resolve an opaque World author reference only inside the trusted Provider. */
    worldAuthorFromRef(recordRef: string): Promise<{
        userId: number;
        displayName: string;
    }>;
    /** Resolve viewer-local labels after World content has already been rendered. */
    private cachedAuthorMembership;
    /** Decoration is bounded, shared across pages/details, and never blocks the feed read. */
    private loadAuthorMemberships;
    worldAuthorLabels(recordRefs: readonly string[], signal?: AbortSignal): Promise<ArkmeWorldAuthorLabel[]>;
    private pruneWorldRecordRefs;
    private openWorldRecordRef;
    private pruneWorldImageRefs;
    private sealWorldImageRef;
    openWorldImageRef(imageRef: string, viewerUserId: number): Promise<ArkmeWorldImageEntry>;
    private worldPublishFailure;
    private worldRecordIsPublic;
}
//# sourceMappingURL=world-service.d.ts.map