import type { ArkmeImagePayload, ArkmeOpenPrivateChatResult, ArkmeWorldPublishResult, ArkmeWorldFeedItem, ArkmeWorldAuthorLabel, ArkmeWorldInteractionItem, ArkmeWorldVoiceprintAvailability, ArkmeWorldVoiceprintSocialContext, ArkmeTeam } from '../types.js';
import type { WorldPublishOrigin } from '../world-publish-source.js';
import type { ArkmeExtensionCatalogItem } from '../extensions/types.js';
import { type ArkmeWorldViewTarget } from './ui-controller.js';
type WorldScope = 'all' | 'mine';
export declare function worldScopeScrollTransition(positions: Readonly<Record<WorldScope, number>>, currentScope: WorldScope, nextScope: WorldScope, currentScrollTop: number): {
    positions: Record<WorldScope, number>;
    restoreTop: number;
};
export type ArkmeWorldViewState = {
    status: 'loading' | 'error' | 'empty' | 'success';
    items: ArkmeWorldFeedItem[];
    message?: string;
    refreshing?: boolean;
    loadingMore?: boolean;
    hasMore?: boolean;
    nextOffset?: number;
};
export declare function updateWorldViewItem(view: ArkmeWorldViewState, recordRef: string, update: (item: ArkmeWorldFeedItem) => ArkmeWorldFeedItem): ArkmeWorldViewState;
export declare function applyWorldAuthorLabels(view: ArkmeWorldViewState, labelsByRef: ReadonlyMap<string, string>, memberships?: ReadonlyMap<string, ArkmeWorldFeedItem['memberType']>): ArkmeWorldViewState;
export declare function applyWorldInteractionAuthorLabels(items: readonly ArkmeWorldInteractionItem[], labels: readonly ArkmeWorldAuthorLabel[]): ArkmeWorldInteractionItem[];
export declare function rememberWorldVoiceprintAvailability(availability: ArkmeWorldVoiceprintAvailability): void;
export declare function cachedWorldVoiceprintResolvedRefs(): Set<string>;
export declare function cachedWorldVoiceprintPlayableRefs(): Set<string>;
export declare function pendingWorldVoiceprintRecordRefs(items: readonly Pick<ArkmeWorldFeedItem, 'recordRef'>[], resolvedRefs: ReadonlySet<string>): string[];
export declare function mergeWorldVoiceprintPlayableRefs(current: ReadonlySet<string>, availability: ArkmeWorldVoiceprintAvailability): Set<string>;
export declare function voiceprintInvitePromptTitle(item: Pick<ArkmeWorldFeedItem, 'headline' | 'textContent'>, variantIndex?: number): string;
export declare function cachedWorldImageDataUrl(imageRef: string): string | undefined;
type WorldImageReader = (imageRef: string) => Promise<ArkmeImagePayload>;
export declare function loadWorldImageDataUrl(imageRef: string, reader?: WorldImageReader): Promise<string>;
/** Shrinks large still images before the local-to-OSS upload while preserving unsupported/animated formats. */
export declare function optimizeWorldPublishImage(file: File): Promise<File>;
export declare function WorldImagePreviewMedia({ imageRef, alt, zoomed }: {
    imageRef: string;
    alt: string;
    zoomed?: boolean;
}): import("react").JSX.Element;
export interface WorldImagePreviewDragOrigin {
    pointerId: number;
    clientX: number;
    clientY: number;
    scrollLeft: number;
    scrollTop: number;
}
export declare function worldImagePreviewDragPosition(origin: WorldImagePreviewDragOrigin, clientX: number, clientY: number): {
    left: number;
    top: number;
};
export declare function WorldImagePreviewDialog({ item, previewIndex, onClose, onSelect }: {
    item: ArkmeWorldFeedItem;
    previewIndex: number;
    onClose(): void;
    onSelect(index: number): void;
}): import("react").JSX.Element | null;
export declare function worldTextCollapsedLines(hasMedia: boolean): number;
/**
 * Give obviously long posts the correct first-frame presentation. The browser
 * then measures the clamped paragraph so responsive widths are handled exactly.
 */
export declare function worldTextLikelyNeedsCollapse(value: string, maxLines: number): boolean;
interface WorldExtensionShareLink {
    url: string;
    label: string;
}
export declare function WorldCollapsibleText({ recordRef, authorName, textContent, hasMedia, extensionShareLink }: {
    recordRef: string;
    authorName: string;
    textContent: string;
    hasMedia: boolean;
    extensionShareLink?: WorldExtensionShareLink;
}): import("react").JSX.Element;
export interface WorldInteractionReplyPresentation {
    item: ArkmeWorldInteractionItem;
    replyToName: string;
    replyToMemberType?: ArkmeWorldInteractionItem['memberType'];
}
export interface WorldInteractionThread {
    root: ArkmeWorldInteractionItem;
    replies: WorldInteractionReplyPresentation[];
}
/** Keep replies visually under the top-level comment while retaining their direct addressee. */
export declare function worldInteractionThreads(rootRef: string, items: readonly ArkmeWorldInteractionItem[]): WorldInteractionThread[];
export declare function WorldInteractionThreadList({ rootRef, items, maxVisibleItems, compact, replyTargetRef, onReply }: {
    rootRef: string;
    items: readonly ArkmeWorldInteractionItem[];
    maxVisibleItems?: number;
    compact?: boolean;
    replyTargetRef?: string;
    onReply?(item: ArkmeWorldInteractionItem): void;
}): import("react").JSX.Element;
export declare function worldInteractionCountLabel(count: number, hasMore?: boolean): string;
export declare function WorldInteractionPreviewContent({ item, items, onOpen }: {
    item: ArkmeWorldFeedItem;
    items: readonly ArkmeWorldInteractionItem[];
    onOpen(): void;
}): import("react").JSX.Element;
export declare function worldExtensionPublicationTextContent(item: ArkmeWorldFeedItem): string;
export declare const WORLD_EXTENSION_SHELF_PREVIEW_LIMIT = 6;
export declare function worldExtensionShelfPreview(items: readonly ArkmeExtensionCatalogItem[], limit?: number): ArkmeExtensionCatalogItem[];
export declare function WorldCard({ item, playable, voiceprintActive, voiceprintLoading, interactionsOpen, onOpenInteractions, onInteractionCreated, onToggleVoiceprint, onInviteVoiceprint, onOpenAuthor, onOpenDetail, selected, detail }: {
    item: ArkmeWorldFeedItem;
    playable: boolean;
    voiceprintActive: boolean;
    voiceprintLoading: boolean;
    interactionsOpen: boolean;
    onOpenInteractions(item: ArkmeWorldFeedItem): void;
    onInteractionCreated(recordRef: string): void;
    onToggleVoiceprint(recordRef: string): void;
    onInviteVoiceprint?(item: ArkmeWorldFeedItem): void;
    onOpenAuthor?(item: ArkmeWorldFeedItem): void;
    onOpenDetail?(item: ArkmeWorldFeedItem): void;
    selected?: boolean;
    detail?: boolean;
}): import("react").JSX.Element;
export declare function VoiceprintInviteDialog({ item, variantIndex, socialContext, sending, message, onClose, onConfirm }: {
    item: ArkmeWorldFeedItem;
    variantIndex: number;
    socialContext?: ArkmeWorldVoiceprintSocialContext;
    sending: boolean;
    message?: string;
    onClose(): void;
    onConfirm(item: ArkmeWorldFeedItem): void;
}): import("react").JSX.Element;
export declare function WorldInfiniteScrollTrigger({ scrollRootRef, loading, error, onLoadMore }: {
    scrollRootRef: {
        readonly current: HTMLElement | null;
    };
    loading: boolean;
    error: boolean;
    onLoadMore(): void;
}): import("react").JSX.Element;
export declare function ArkmeWorldContent({ state, scope, target, catalogOwnerUserId, catalogOwnerName, voiceprintPlayableRefs, voiceprintRecordRef, voiceprintLoadingRecordRef, interactionRecordRef, actionMessage, onRefresh, onBackToWorld, onSelectScope, onOpenComposer, onOpenInteractions, onInteractionCreated, onToggleVoiceprint, onInviteVoiceprint, onOpenAuthor, onOpenExtension, onOpenAllExtensions, onLoadMore }: {
    state: ArkmeWorldViewState;
    scope: WorldScope;
    target?: ArkmeWorldViewTarget;
    catalogOwnerUserId?: number;
    catalogOwnerName?: string;
    voiceprintPlayableRefs: ReadonlySet<string>;
    voiceprintRecordRef: string | undefined;
    voiceprintLoadingRecordRef?: string;
    interactionRecordRef?: string;
    actionMessage?: string;
    onRefresh(): void;
    onBackToWorld?(): void;
    onSelectScope(scope: WorldScope): void;
    onOpenComposer(): void;
    onOpenInteractions(item: ArkmeWorldFeedItem): void;
    onInteractionCreated?(recordRef: string): void;
    onToggleVoiceprint(recordRef: string): void;
    onInviteVoiceprint?(item: ArkmeWorldFeedItem): void;
    onOpenAuthor?(item: ArkmeWorldFeedItem): void;
    onOpenExtension(extensionId: string): void;
    onOpenAllExtensions?(ownerUserId: number, ownerName: string): void;
    onLoadMore?(): void;
}): import("react").JSX.Element;
export declare function appendWorldPublishFiles(current: readonly File[], selected: readonly File[]): File[];
export declare function removeWorldPublishFile(current: readonly File[], index: number): File[];
interface PublishDialogProps {
    onClose(): void;
    onPublished(result: ArkmeWorldPublishResult): void;
    initialTeam?: ArkmeTeam | undefined;
    actorName?: string | undefined;
    actorAvatarRef?: string | undefined;
    origin?: WorldPublishOrigin;
}
export declare function PublishDialog(props: PublishDialogProps): import("react").JSX.Element;
export declare function ArkmeWorldSurface({ notificationRef, target, initialScope, currentUserId, onBackToWorld, onSourceActivated }?: {
    notificationRef?: string;
    target?: ArkmeWorldViewTarget;
    initialScope?: WorldScope;
    currentUserId?: number;
    actorName?: string | undefined;
    actorAvatarRef?: string | undefined;
    onBackToWorld?(): void;
    onSourceActivated?(source: ArkmeOpenPrivateChatResult['source']): void;
}): import("react").JSX.Element;
export {};
//# sourceMappingURL=ArkmeWorldSurface.d.ts.map