@rixl/media-core 1.0.1 → 1.1.0

package/dist/index.d.ts

@@ -1,82 +1,2005 @@
-import { ProgressBarControls, ProgressBarProps, initProgressBar } from "./progressbar.js";
-import { getFeedPost, getFeedPosts } from "./store/feed-store.js";
-import { getImage } from "./store/image-store.js";
-import { getVideo } from "./store/video-store.js";
-import { FeedPost, FeedPostsResponse } from "./types/feed.js";
-import { UUID } from "./types/uuid.js";
-import { formatTime } from "./lib/time.js";
-import { clamp, formatNumber, formatNumberSm } from "./lib/numbers.js";
-import { CSSProperties, DEFAULT_IMAGE_ASPECT_RATIO, IMAGE_ASPECT_RATIO_THRESHOLD, ImageContainerStyleParams, ImageRenderAction, ImageRenderState, getImageAspectRatio, getImageContainerStyle, getImageStyle, imageRenderReducer, initialImageRenderState } from "./lib/image-render.js";
-import { hexToRGB, hexToRGBAString } from "./lib/colors.js";
-import { shouldIgnoreKeyboardEvent } from "./lib/keyboard-utils.js";
-import { PLAYER_LANGUAGES, PlayerControlLabels, PlayerLanguage, getPlayerControlLabels, resolvePlayerLanguage } from "./lib/player-labels.js";
-import { PLAY_PAUSE_KEYS, SEEK_LARGE_SECONDS, SEEK_SMALL_SECONDS, SHORTCUTS_CONFIG, ShortcutAction, ShortcutDefinition, VOLUME_DELTA, VideoKeyboardHandlers, VideoSdkKey, executeShortcutAction, getSeekAmount, getSeekPercent, getVolumeDelta, resolveShortcutAction } from "./lib/keyboard-config.js";
-import { calculateVolumeToSet, clampVolume, getPointerClientX, getRestoredVolume, getVolumeFromPointer, isEffectivelyMuted, shouldBeMuted } from "./lib/volume-utils.js";
-import { CaptionTextSettings, CaptionWindowSettings, SmartCaptionPositionParams, getCaptionTextStyle, getCaptionWindowStyle, getSmartCaptionPosition } from "./lib/caption-styles.js";
-import { isDocumentFullscreen } from "./lib/fullscreen-utils.js";
-import { isVideoPictureInPicture, togglePictureInPicture } from "./lib/pip-utils.js";
-import { PERSIST_INTERVAL_MS, RESUME_MIN_POSITION_SECONDS, RESUME_MIN_REMAINING_SECONDS, getPersistedProgress, persistProgress, shouldPersistProgress, shouldResumeFromPosition } from "./lib/progress-persist.js";
-import { PRELOAD_RANGE, UNLOAD_DISTANCE, VideoLoadState, getVideoLoadState } from "./lib/video-preload-config.js";
-import { LOADING_SPINNER_DELAY_MS, LoadingDebounceState, UpdateLoadingStateOptions, cleanupLoadingDebounce, createLoadingDebounceState, updateLoadingState } from "./lib/loading-debounce.js";
-import { PlaybackHandlerCallbacks, calculateAspectRatio, handleVideoError, handleVideoPause, handleVideoPlay, handleVideoRateChange, updatePlayerLoadingState } from "./lib/playback-handlers.js";
-import { ClickDisambiguationState, DOUBLE_CLICK_THRESHOLD_MS, HandleClickOptions, HandleDoubleClickOptions, SINGLE_CLICK_DELAY_MS, cleanupClickDisambiguation, createClickDisambiguationState, handleClick, handleDoubleClick } from "./lib/click-disambiguation.js";
-import { AppliedVolumeSync, DeriveVolumeSyncOptions, PipReentryOptions, bindFullscreenChangeListener, bindPictureInPictureChangeListener, bindPipVisibilityReentry, deriveVolumeSync, observeViewport, shouldReenterPictureInPicture } from "./lib/environment-effects.js";
-import { FeedPlaybackAction, FeedPlaybackDecisionInput, PosterDimensions, VideoPreloadAttribute, bindEndedListener, bindPlaybackRateSync, getAspectRatioFromPoster, getFeedPlaybackAction, getPreloadAttribute } from "./lib/lifecycle-effects.js";
-import { ClickOutsideOptions, bindClickOutside, bindDocumentHidden, isClickOutside, isInsideExcludedElement } from "./lib/click-outside.js";
-import { shouldShowSpinner } from "./lib/video-spinner.js";
-import { HlsController, HlsInstance, SetupHlsOptions, createHlsConfig, setupHls } from "./lib/hls-setup.js";
-import { AudioTrack, QualityLevel, generateLevelName, getQualityLabel, isHlsStream, sortLevelsByQuality } from "./lib/hls-utils.js";
-import { getPersistedAudioTrack, getPersistedSubtitleTrack, persistAudioTrack, persistSubtitleTrack } from "./lib/track-persistence.js";
-import { analyticsStore, analyticsStoreActions } from "./store/analytics-store.js";
-import { SegmentAnalyticsParams, endSegment, restartSegmentIfPlaying, startSegment } from "./lib/segment-analytics.js";
-import { ControlsState, controlsStore } from "./store/controls-store.js";
-import { HlsErrorAction, HlsErrorInput, HlsErrorPayload, HlsErrorRecoveryState, MAX_MEDIA_RECOVERIES, MAX_NETWORK_RETRIES, createHlsErrorRecoveryState, decideHlsErrorAction } from "./lib/hls-error-recovery.js";
-import { feedCacheAtom, feedCacheStore } from "./store/feed-cache-store.js";
-import { PostStoreState, postStore, postStoreActions } from "./store/postStore.js";
-import { FEED_COMPONENTS_COUNT, FEED_TRANSITION_THRESHOLD, feedStore, initializeVideo, setHasInteracted } from "./store/feed-interaction-store.js";
-import { playerContainerElementStore } from "./store/player-container-element-store.js";
-import { playerMediaElementStore } from "./store/player-media-element-store.js";
-import { CaptionLangType, SettingsState, VideoTheme } from "./store/settings/types.js";
-import { defaultSettings } from "./store/settings/defaults.js";
-import { COLORS, EDGE_STYLES, FONT_FAMILIES, FONT_SIZES, FontFamilyKey, LANG_TYPES, PLAYBACK_SPEEDS } from "./store/settings/constants.js";
-import { validateSettings } from "./store/settings/validation.js";
-import { loadSettings, saveSettings } from "./store/settings/storage.js";
-import { settingsStore } from "./store/settings/store.js";
-import { MenuKey, activeMenu, menuStack, navigationDirection, popMenu, pushMenu, resetMenu } from "./store/settings-menu-store.js";
-import { PlaybackPointerOptions, computePlaybackFillPercentage, computePlaybackValueFromPointer } from "./lib/playback-slider.js";
-import { PlayerMenuLabels, getPlayerMenuLabels } from "./lib/player-menu-labels.js";
-import { PlayerState, PlayerStateStore, playerStateStore } from "./store/player-store.js";
-import { hidePlayerControls, showPlayerControls, togglePlayerFullscreen, togglePlayerPictureInPicture } from "./lib/player-ui-actions.js";
-import { clearSubtitles, handleCueChange, handleLoadedMetadata } from "./lib/subtitle-utils.js";
-import { BufferRange, computeBufferRanges, computeBufferedAhead } from "./lib/buffer-progress.js";
-import { computeProgressFraction } from "./lib/progress-fraction.js";
-import { BuildVideoAnalyticsPayloadParams, VideoAnalyticsPayload, VideoSnapshot, buildVideoAnalyticsPayload, postContentEvent } from "./lib/content-analytics.js";
-import { analyticsContextStore, setAnalyticsContext } from "./store/analytics-context-store.js";
-import { analyticsDeviceStore, getOrCreateDeviceId, setDeviceId } from "./store/analytics-device-store.js";
-import { analyticsSessionStore, getOrCreateSessionId } from "./store/analytics-session-store.js";
-import { initializeAnalyticsContext } from "./lib/analytics-initialize.js";
-import { BOTTOM_OFFSET_CONTROLS_HIDDEN, BOTTOM_OFFSET_CONTROLS_VISIBLE, BOTTOM_SNAP_THRESHOLD, CAPTION_WIDTH_RATIO, CalculateDragPositionOptions, DEFAULT_CAPTION_FONT_SIZE, DEFAULT_FONT_SIZE, FONT_SIZE_RATIO, FONT_SIZE_VIEWPORT_RATIO, GetPointerOffsetsOptions, MAX_FONT_SIZE, MIN_FONT_SIZE, PointerOffsets, Position, SAFE_ZONE_MARGIN, Viewport, calculateDragPosition, calculateFontSize, calculateSafeViewport, constrainPercentagePosition, getPointerOffsets, getTextShadowValue, pixelsToPercentage, shouldPinToBottom } from "./lib/caption-utils.js";
-import { BuildEventParams, buildContentViewEvent, calculateWatchDuration, getEffectivePage, msToSeconds, roundMs, secondsToMs, shouldIncludeSegments } from "./lib/analytics-utils.js";
-import { ChapterWithEnd, calculateChaptersWithEnd, calculateFlexGrow, calculateGlobalMax, calculateHeatmapSlices, calculateSegmentBufferRanges, calculateSegmentProgress, findHoveredSegmentIndex, getCurrentPosition, getNextChapterStart, getPrevChapterTarget, isChapterWithinDuration, sliceHeatmapData, validateChapters } from "./lib/chapter-utils.js";
-import { SubtitleTrack, calculateSmoothedEndTime, extractSubtitleTracks, findNextCue, getCleanCueText, processCues, stripHtmlTags } from "./lib/subtitle-logic.js";
-import { FileData, FileStatus } from "./types/file.js";
-import { ImageData } from "./types/image.js";
-import { Chapter, VideoData } from "./types/video.js";
-import { flushAnalytics, postAnalytics, postEngagement, postError, postInteraction } from "./api/analytics.js";
-import { AnalyticsContext, AnalyticsEvent, ContentType, ContentViewEvent, EngagementEvent, ErrorEvent, InteractionEvent, Page, Segment, SessionStartEvent, ViewType } from "./types/analytics.js";
-import { BuildEngagementParams, BuildErrorParams, BuildInteractionParams, BuildSessionStartParams } from "./lib/analytics-builders.js";
-import { GetVideoHeatmapOptions, getVideoHeatmap } from "./api/heatmap.js";
-import { VideoHeatmap } from "./types/heatmap.js";
-import { GetHotSegmentsOptions, getHotSegments } from "./api/hot-segments.js";
-import { HotSegment } from "./types/hot-segments.js";
-import { CollectStatsInput, VideoStats, collectVideoStats, getBufferHealth, getDroppedFrames } from "./lib/video-stats.js";
-import { LOOP_REBASE_BASE_MULTIPLIER, LOOP_REBASE_THRESHOLD_MULTIPLIER, buildTransforms, calcShiftCountArray, shiftArray } from "./lib/feed-transforms.js";
-import { ShouldFetchMoreInput, computeScrollIndex, isAtEndOfFeed, isFeedExhausted, shouldFetchMore } from "./lib/feed-scroll.js";
-import { LoopRebaseInput, getLoopRebaseThreshold, getRebasedLoopIndex, resolvePostIndex, shouldRebaseLoopIndex } from "./lib/feed-loop.js";
-import { IMAGE_DWELL_MS, shouldDwellAdvance } from "./lib/feed-dwell.js";
-import { AutoAdvanceInput, gateVideoEnded, shouldAutoAdvance } from "./lib/feed-autoscroll.js";
-import { ContainerHeightInput, getViewportFallbackHeight, resolveContainerHeight } from "./lib/feed-container-height.js";
-import { checkIsCut } from "./lib/feed-description-overflow.js";
-import { AuthConfig, ConnectConfig, connect } from "./api/rixl-client.js";
-import { AudioTrackUploadItem, AudioTrackUploadResult, CreateImageUploadOptions, CreatePostUploadOptions, CreateVideoUploadOptions, ImageUploadResult, PostUploadResult, SubtitleUploadItem, SubtitleUploadResult, VideoUploadResult, createAudioTrackUpload, createImageUpload, createPostUpload, createSubtitleUpload, createVideoUpload, uploadImage, uploadPost, uploadVideo } from "./api/upload.js";
-export { type AnalyticsContext, type AnalyticsEvent, type AppliedVolumeSync, type AudioTrack, type AudioTrackUploadItem, type AudioTrackUploadResult, type AuthConfig, type AutoAdvanceInput, BOTTOM_OFFSET_CONTROLS_HIDDEN, BOTTOM_OFFSET_CONTROLS_VISIBLE, BOTTOM_SNAP_THRESHOLD, type BufferRange, type BuildEngagementParams, type BuildErrorParams, type BuildEventParams, type BuildInteractionParams, type BuildSessionStartParams, type BuildVideoAnalyticsPayloadParams, CAPTION_WIDTH_RATIO, COLORS, type CSSProperties, type CalculateDragPositionOptions, type CaptionLangType, type CaptionTextSettings, type CaptionWindowSettings, type Chapter, type ChapterWithEnd, type ClickDisambiguationState, type ClickOutsideOptions, type CollectStatsInput, type ConnectConfig, type ContainerHeightInput, type ContentType, type ContentViewEvent, type ControlsState, type CreateImageUploadOptions, type CreatePostUploadOptions, type CreateVideoUploadOptions, DEFAULT_CAPTION_FONT_SIZE, DEFAULT_FONT_SIZE, DEFAULT_IMAGE_ASPECT_RATIO, DOUBLE_CLICK_THRESHOLD_MS, type DeriveVolumeSyncOptions, EDGE_STYLES, type EngagementEvent, type ErrorEvent, FEED_COMPONENTS_COUNT, FEED_TRANSITION_THRESHOLD, FONT_FAMILIES, FONT_SIZES, FONT_SIZE_RATIO, FONT_SIZE_VIEWPORT_RATIO, type FeedPlaybackAction, type FeedPlaybackDecisionInput, type FeedPost, type FeedPostsResponse, type FileData, type FileStatus, type FontFamilyKey, type GetHotSegmentsOptions, type GetPointerOffsetsOptions, type GetVideoHeatmapOptions, type HandleClickOptions, type HandleDoubleClickOptions, type HlsController, type HlsErrorAction, type HlsErrorInput, type HlsErrorPayload, type HlsErrorRecoveryState, type HlsInstance, type HotSegment, IMAGE_ASPECT_RATIO_THRESHOLD, IMAGE_DWELL_MS, type ImageContainerStyleParams, type ImageData, type ImageRenderAction, type ImageRenderState, type ImageUploadResult, type InteractionEvent, LANG_TYPES, LOADING_SPINNER_DELAY_MS, LOOP_REBASE_BASE_MULTIPLIER, LOOP_REBASE_THRESHOLD_MULTIPLIER, type LoadingDebounceState, type LoopRebaseInput, MAX_FONT_SIZE, MAX_MEDIA_RECOVERIES, MAX_NETWORK_RETRIES, MIN_FONT_SIZE, type MenuKey, PERSIST_INTERVAL_MS, PLAYBACK_SPEEDS, PLAYER_LANGUAGES, PLAY_PAUSE_KEYS, PRELOAD_RANGE, type Page, type PipReentryOptions, type PlaybackHandlerCallbacks, type PlaybackPointerOptions, type PlayerControlLabels, type PlayerLanguage, type PlayerMenuLabels, type PlayerState, type PlayerStateStore, type PointerOffsets, type Position, type PostStoreState, type PostUploadResult, type PosterDimensions, type ProgressBarControls, type ProgressBarProps, type QualityLevel, RESUME_MIN_POSITION_SECONDS, RESUME_MIN_REMAINING_SECONDS, SAFE_ZONE_MARGIN, SEEK_LARGE_SECONDS, SEEK_SMALL_SECONDS, SHORTCUTS_CONFIG, SINGLE_CLICK_DELAY_MS, type Segment, type SegmentAnalyticsParams, type SessionStartEvent, type SettingsState, type SetupHlsOptions, ShortcutAction, type ShortcutAction as ShortcutActionType, type ShortcutDefinition, type ShouldFetchMoreInput, type SmartCaptionPositionParams, type SubtitleTrack, type SubtitleUploadItem, type SubtitleUploadResult, UNLOAD_DISTANCE, type UUID, type UpdateLoadingStateOptions, VOLUME_DELTA, type VideoAnalyticsPayload, type VideoData, type VideoHeatmap, type VideoKeyboardHandlers, VideoLoadState, type VideoPreloadAttribute, type VideoSdkKey, type VideoSnapshot, type VideoStats, type VideoTheme, type VideoUploadResult, type ViewType, type Viewport, activeMenu, analyticsContextStore, analyticsDeviceStore, analyticsSessionStore, analyticsStore, analyticsStoreActions, bindClickOutside, bindDocumentHidden, bindEndedListener, bindFullscreenChangeListener, bindPictureInPictureChangeListener, bindPipVisibilityReentry, bindPlaybackRateSync, buildContentViewEvent, buildTransforms, buildVideoAnalyticsPayload, calcShiftCountArray, calculateAspectRatio, calculateChaptersWithEnd, calculateDragPosition, calculateFlexGrow, calculateFontSize, calculateGlobalMax, calculateHeatmapSlices, calculateSafeViewport, calculateSegmentBufferRanges, calculateSegmentProgress, calculateSmoothedEndTime, calculateVolumeToSet, calculateWatchDuration, checkIsCut, clamp, clampVolume, cleanupClickDisambiguation, cleanupLoadingDebounce, clearSubtitles, collectVideoStats, computeBufferRanges, computeBufferedAhead, computePlaybackFillPercentage, computePlaybackValueFromPointer, computeProgressFraction, computeScrollIndex, connect, constrainPercentagePosition, controlsStore, createAudioTrackUpload, createClickDisambiguationState, createHlsConfig, createHlsErrorRecoveryState, createImageUpload, createLoadingDebounceState, createPostUpload, createSubtitleUpload, createVideoUpload, decideHlsErrorAction, defaultSettings, deriveVolumeSync, endSegment, executeShortcutAction, extractSubtitleTracks, feedCacheAtom, feedCacheStore, feedStore, findHoveredSegmentIndex, findNextCue, flushAnalytics, formatNumber, formatNumberSm, formatTime, gateVideoEnded, generateLevelName, getAspectRatioFromPoster, getBufferHealth, getCaptionTextStyle, getCaptionWindowStyle, getCleanCueText, getCurrentPosition, getDroppedFrames, getEffectivePage, getFeedPlaybackAction, getFeedPost, getFeedPosts, getHotSegments, getImage, getImageAspectRatio, getImageContainerStyle, getImageStyle, getLoopRebaseThreshold, getNextChapterStart, getOrCreateDeviceId, getOrCreateSessionId, getPersistedAudioTrack, getPersistedProgress, getPersistedSubtitleTrack, getPlayerControlLabels, getPlayerMenuLabels, getPointerClientX, getPointerOffsets, getPreloadAttribute, getPrevChapterTarget, getQualityLabel, getRebasedLoopIndex, getRestoredVolume, getSeekAmount, getSeekPercent, getSmartCaptionPosition, getTextShadowValue, getVideo, getVideoHeatmap, getVideoLoadState, getViewportFallbackHeight, getVolumeDelta, getVolumeFromPointer, handleClick, handleCueChange, handleDoubleClick, handleLoadedMetadata, handleVideoError, handleVideoPause, handleVideoPlay, handleVideoRateChange, hexToRGB, hexToRGBAString, hidePlayerControls, imageRenderReducer, initProgressBar, initialImageRenderState, initializeAnalyticsContext, initializeVideo, isAtEndOfFeed, isChapterWithinDuration, isClickOutside, isDocumentFullscreen, isEffectivelyMuted, isFeedExhausted, isHlsStream, isInsideExcludedElement, isVideoPictureInPicture, loadSettings, menuStack, msToSeconds, navigationDirection, observeViewport, persistAudioTrack, persistProgress, persistSubtitleTrack, pixelsToPercentage, playerContainerElementStore, playerMediaElementStore, playerStateStore, popMenu, postAnalytics, postContentEvent, postEngagement, postError, postInteraction, postStore, postStoreActions, processCues, pushMenu, resetMenu, resolveContainerHeight, resolvePlayerLanguage, resolvePostIndex, resolveShortcutAction, restartSegmentIfPlaying, roundMs, saveSettings, secondsToMs, setAnalyticsContext, setDeviceId, setHasInteracted, settingsStore, setupHls, shiftArray, shouldAutoAdvance, shouldBeMuted, shouldDwellAdvance, shouldFetchMore, shouldIgnoreKeyboardEvent, shouldIncludeSegments, shouldPersistProgress, shouldPinToBottom, shouldRebaseLoopIndex, shouldReenterPictureInPicture, shouldResumeFromPosition, shouldShowSpinner, showPlayerControls, sliceHeatmapData, sortLevelsByQuality, startSegment, stripHtmlTags, togglePictureInPicture, togglePlayerFullscreen, togglePlayerPictureInPicture, updateLoadingState, updatePlayerLoadingState, uploadImage, uploadPost, uploadVideo, validateChapters, validateSettings };
+import { AuthConfig, ConnectConfig, client } from "@rixl/sdk";
+import { MapStore, ReadableAtom, WritableAtom } from "nanostores";
+import Hls, { MediaPlaylist } from "hls.js";
+interface ProgressBarProps {
+  video: HTMLVideoElement;
+  onDraggingChange?: (isDragging: boolean) => void;
+  onProgressChange?: (progress: number) => void;
+}
+type ProgressBarCoordinates = {
+  clientX: number;
+} | {
+  touches: ArrayLike<{
+    clientX: number;
+  }>;
+  changedTouches?: ArrayLike<{
+    clientX: number;
+  }>;
+};
+type ProgressBarStartEvent = ProgressBarCoordinates & {
+  currentTarget: EventTarget | null;
+};
+interface ProgressBarControls {
+  handleDragStart: (event: ProgressBarStartEvent) => void;
+  destroy: () => void;
+}
+export declare const initProgressBar: ({ video, onDraggingChange, onProgressChange }: ProgressBarProps) => ProgressBarControls;
+type FileStatus = "uploading" | "uploaded" | "processing" | "ready" | "error";
+interface FileData {
+  id: string;
+  project_id: string;
+  format: string;
+  url: string;
+  name: string;
+  size: number;
+  status: FileStatus;
+  created_at: Date;
+  updated_at: Date;
+}
+interface ImageData {
+  id: string;
+  thumbhash: string;
+  width: number;
+  height: number;
+  attached_to_video: boolean;
+  file: FileData;
+}
+interface Chapter {
+  title: string;
+  start_time_sec: number;
+  end_time_sec: number;
+  duration_label: string;
+}
+interface VideoData {
+  id: string;
+  file: FileData;
+  poster: ImageData;
+  duration: number;
+  width: number;
+  height: number;
+  codec: string;
+  bitrate: number;
+  framerate: string;
+  hdr: boolean;
+  chapters?: Chapter[];
+  plan_type?: "free" | "pro" | "pay-as-you-go" | "custom";
+}
+interface FeedPost {
+  id: string;
+  feedId: string;
+  creatorId: string;
+  type: "image" | "video";
+  description: string;
+  createdAt: string;
+  image?: ImageData;
+  video?: VideoData;
+  projectId?: string;
+  planType?: string;
+  updatedAt?: string;
+}
+interface FeedPostsResponse {
+  posts: FeedPost[];
+  total: number;
+  offset: number;
+  limit: number;
+}
+/**
+ * Get a feed post by ID, using cache if available
+ * @param feedId ID of the feed
+ * @param postId ID of the post to fetch
+ * @returns Promise with the feed post
+ */
+export declare const getFeedPost: (feedId: string, postId: string) => Promise<FeedPost>;
+/**
+ * Get posts from a specific feed, with pagination
+ * @param feedId ID of the feed
+ * @param offset Pagination offset
+ * @param limit Maximum number of items to return
+ * @returns Promise with feed posts response
+ */
+export declare const getFeedPosts: (feedId: string, offset?: number, limit?: number) => Promise<FeedPostsResponse>;
+export declare const getImage: (imageId: string) => Promise<ImageData>;
+export declare const getVideo: (videoId: string) => Promise<VideoData>;
+type UUID = `${string}-${string}-${string}-${string}-${string}`;
+export declare const formatTime: (seconds: number) => string;
+/**
+ * Returns a copy of `obj` with all `undefined` values removed.
+ * A type assertion is required because `Object.fromEntries` cannot infer
+ * `Partial<T>` from filtered entries.
+ */
+export declare function filterUndefined<T extends Record<string, unknown>>(obj: T): Partial<T>;
+/**
+ * Clamp a value between min and max bounds
+ */
+export declare function clamp(value: number, min: number, max: number): number;
+export declare function formatNumber(number: number): string;
+export declare function formatNumberSm(number: number): string;
+type CSSProperties = Record<string, string | number | null | undefined>;
+interface ImageRenderState {
+  isLoading: boolean;
+  isVisible: boolean;
+  aspectRatio: number;
+}
+type ImageRenderAction = {
+  type: "reset";
+  aspectRatio?: number;
+} | {
+  type: "loaded";
+} | {
+  type: "visible";
+} | {
+  type: "set_aspect_ratio";
+  aspectRatio: number;
+};
+export declare const DEFAULT_IMAGE_ASPECT_RATIO = .5;
+export declare const IMAGE_ASPECT_RATIO_THRESHOLD = .7;
+export declare const initialImageRenderState: ImageRenderState;
+interface ImageContainerStyleParams {
+  aspectRatio: number;
+  isVisible: boolean;
+  thumbhashUrl?: string;
+}
+export declare function imageRenderReducer(state: ImageRenderState, action: ImageRenderAction): ImageRenderState;
+export declare function getImageAspectRatio(width?: number, height?: number): number | undefined;
+export declare function getImageContainerStyle({ aspectRatio, isVisible, thumbhashUrl }: ImageContainerStyleParams): CSSProperties;
+export declare function getImageStyle(aspectRatio: number, isLoading: boolean): CSSProperties;
+export declare function hexToRGB(hex: string): {
+  r: number;
+  g: number;
+  b: number;
+};
+export declare function hexToRGBAString(hex: string, alpha?: number): string;
+/**
+ * Check if keyboard event should be ignored (input fields, textareas, etc.)
+ */
+export declare function shouldIgnoreKeyboardEvent(target: EventTarget | null): boolean;
+export declare const PLAYER_LANGUAGES: readonly ["en", "de", "es", "fr", "it", "pl", "ru", "tr", "uk"];
+type PlayerLanguage = (typeof PLAYER_LANGUAGES)[number];
+/**
+ * Control-bar strings for the player UI. Values mirror the `controls.*` and
+ * `captions.toggle` keys of packages/react/src/locales/<lang>.json — one
+ * label per button regardless of state, keyboard hint included, same as the
+ * React tooltips.
+ */
+interface PlayerControlLabels {
+  play: string;
+  pause: string;
+  replay: string;
+  mute: string;
+  unmute: string;
+  volume: string;
+  settings: string;
+  pip: string;
+  fullScreen: string;
+  captionsToggle: string;
+}
+/** Same semantics as the React resolveSupportedLanguage: lowercase exact match, fallback en. */
+export declare function resolvePlayerLanguage(code: string | null | undefined): PlayerLanguage;
+export declare function getPlayerControlLabels(code: string | null | undefined): PlayerControlLabels;
+/**
+ * Media SDK video keyboard shortcuts configuration
+ */
+type VideoSdkKey = "Space" | "KeyK" | "KeyJ" | "KeyL" | "KeyI" | "KeyF" | "KeyM" | "KeyN" | "KeyP" | "ArrowUp" | "ArrowDown" | "ArrowLeft" | "ArrowRight" | "MediaPlay" | "MediaPause" | "MediaPlayPause" | "F1" | "F12" | "Digit0" | "Digit1" | "Digit2" | "Digit3" | "Digit4" | "Digit5" | "Digit6" | "Digit7" | "Digit8" | "Digit9";
+export declare const ShortcutAction: {
+  readonly PLAY_PAUSE: "play_pause";
+  readonly SEEK_10: "seek_10";
+  readonly SEEK_5: "seek_5";
+  readonly FULLSCREEN: "fullscreen";
+  readonly MINIPLAYER: "miniplayer";
+  readonly MUTE: "mute";
+  readonly VOLUME: "volume";
+};
+export type ShortcutAction = (typeof ShortcutAction)[keyof typeof ShortcutAction];
+interface ShortcutDefinition {
+  action: ShortcutAction;
+  keys: VideoSdkKey[];
+  labelKey: string;
+}
+/**
+ * Default keyboard shortcuts configuration
+ */
+export declare const SHORTCUTS_CONFIG: ShortcutDefinition[];
+/**
+ * Seek amounts in seconds
+ */
+export declare const SEEK_SMALL_SECONDS = 5;
+export declare const SEEK_LARGE_SECONDS = 10;
+/**
+ * Volume change delta (0-1 range)
+ */
+export declare const VOLUME_DELTA = .1;
+interface VideoKeyboardHandlers {
+  onPlayPause: () => void;
+  onSeek: (seconds: number) => void;
+  onFullscreen: () => void;
+  onMiniplayer: () => void;
+  onMute: () => void;
+  onVolume: (delta: number) => void;
+}
+/**
+ * Get seek amount for a keyboard event
+ * @returns number of seconds to seek (positive = forward, negative = backward)
+ */
+export declare function getSeekAmount(keyCode: string, action: ShortcutAction): number;
+/**
+ * Get volume delta for a keyboard event
+ * @returns volume change amount (positive = increase, negative = decrease)
+ */
+export declare function getVolumeDelta(keyCode: string): number;
+/**
+ * Execute keyboard shortcut action
+ */
+export declare function executeShortcutAction(action: ShortcutAction, keyCode: string, handlers: VideoKeyboardHandlers): void;
+/**
+ * Full play/pause key set including media keys — mirrors React's
+ * component-level PlayPauseShortcuts, which extends SHORTCUTS_CONFIG.
+ */
+export declare const PLAY_PAUSE_KEYS: VideoSdkKey[];
+/** Resolve a KeyboardEvent.code to its shortcut action, or null when unmapped. */
+export declare function resolveShortcutAction(keyCode: string): ShortcutAction | null;
+/**
+ * Digit0–Digit9 → 0–90 percent seek targets — mirrors React's
+ * PercentageShortcuts table.
+ */
+export declare function getSeekPercent(keyCode: string): number | null;
+/**
+ * Volume and mute utility functions
+ * Pure functions for volume calculations and mute state logic
+ */
+/**
+ * Calculate the volume to set, ensuring it's never 0 when unmuting
+ * @param currentVolume - The current volume from settings (0-1)
+ * @param defaultVolume - The default volume to use if current is 0 (default: 1.0)
+ * @returns The volume to set (0-1)
+ */
+export declare function calculateVolumeToSet(currentVolume: number, defaultVolume?: number): number;
+/**
+ * Determine if video should be muted based on player state and interaction state
+ * @param playerMuted - Whether the current player is muted
+ * @param isFeed - Whether this is a feed video
+ * @param feedInteracted - Whether user has interacted with the feed
+ * @param playerInteracted - Whether user has interacted with the player
+ * @returns Whether the video should be muted
+ */
+interface MuteCheckParams {
+  playerMuted: boolean;
+  playerInteracted: boolean;
+}
+export declare function shouldBeMuted({ playerMuted, playerInteracted }: MuteCheckParams): boolean;
+/**
+ * Get the volume to restore when unmuting, with a minimum threshold
+ * @param currentVolume - The current volume (0-1)
+ * @param previousVolume - The previously saved volume before muting (0-1)
+ * @param minVolume - The minimum volume to restore to (default: 0.1)
+ * @returns The volume to restore (0-1)
+ */
+export declare function getRestoredVolume(currentVolume: number, previousVolume: number, minVolume?: number): number;
+/**
+ * Clamp volume to valid range (0-1)
+ * @param volume - The volume to clamp
+ * @returns Volume clamped to 0-1 range
+ */
+export declare function clampVolume(volume: number): number;
+/**
+ * Check if volume is effectively muted (0 or very close to 0)
+ * @param volume - The volume to check
+ * @param threshold - The threshold below which volume is considered muted (default: 0.01)
+ * @returns Whether volume is effectively muted
+ */
+export declare function isEffectivelyMuted(volume: number, threshold?: number): boolean;
+interface MousePointerLike {
+  clientX: number;
+}
+interface TouchPointerLike {
+  touches: ArrayLike<MousePointerLike>;
+}
+/** clientX of a mouse or touch event (first touch) — shared by the volume sliders. */
+export declare function getPointerClientX(event: MousePointerLike | TouchPointerLike): number;
+/** Map a pointer position over a slider rect to a clamped 0-1 volume. */
+export declare function getVolumeFromPointer(rect: {
+  left: number;
+  width: number;
+}, clientX: number): number;
+type Viewport = {
+  width: number;
+  height: number;
+};
+interface Position {
+  x: number;
+  y: number;
+}
+export declare const DEFAULT_FONT_SIZE = 16;
+export declare const MIN_FONT_SIZE = 12;
+export declare const MAX_FONT_SIZE = 120;
+export declare const FONT_SIZE_RATIO = .03;
+export declare const FONT_SIZE_VIEWPORT_RATIO = .07;
+export declare const DEFAULT_CAPTION_FONT_SIZE = 100;
+export declare const SAFE_ZONE_MARGIN = 8;
+export declare const CAPTION_WIDTH_RATIO = .6;
+/**
+ * Smart caption positioning constants
+ */
+export declare const BOTTOM_SNAP_THRESHOLD = 85;
+export declare const BOTTOM_OFFSET_CONTROLS_VISIBLE = 80;
+export declare const BOTTOM_OFFSET_CONTROLS_HIDDEN = 24;
+/**
+ * Calculates the font size based on the viewport width and user preference.
+ * Uses a logarithmic scale
+ * 100% -> 1.0x
+ * 200% -> 1.5x
+ * 400% -> 2.0x
+ */
+export declare const calculateFontSize: (viewport: Viewport, captionFontSize: number) => number;
+/**
+ * Constrains a percentage-based position to be within safe bounds (0-100).
+ * Assumes the input position is already in percentages.
+ */
+export declare const constrainPercentagePosition: (position: Position, elementWidthRatio?: number) => Position;
+/**
+ * Converts pixel coordinates to percentage coordinates relative to the viewport.
+ */
+export declare const pixelsToPercentage: (x: number, y: number, viewport: Viewport) => Position;
+/**
+ * Calculate pointer offsets for caption dragging
+ */
+interface PointerOffsets {
+  clickXRelative: number;
+  clickYRelative: number;
+  currentVisualX: number;
+  currentVisualY: number;
+}
+interface GetPointerOffsetsOptions {
+  containerRect: DOMRect;
+  elementRect: DOMRect;
+  clientX: number;
+  clientY: number;
+}
+export declare function getPointerOffsets(options: GetPointerOffsetsOptions): PointerOffsets;
+/**
+ * Calculate new drag position from delta
+ */
+interface CalculateDragPositionOptions {
+  startPositionPixels: Position;
+  startX: number;
+  startY: number;
+  currentXRelative: number;
+  currentYRelative: number;
+  viewport: Viewport;
+}
+export declare function calculateDragPosition(options: CalculateDragPositionOptions): Position;
+/**
+ * Calculate safe zone viewport dimensions
+ */
+export declare function calculateSafeViewport(viewport: Viewport): Viewport;
+/**
+ * Determine if caption should be pinned to bottom
+ */
+export declare function shouldPinToBottom(positionY: number, isDragging: boolean): boolean;
+/**
+ * CSS text-shadow value for a caption character edge style.
+ * Shadow size scales with font size so edges stay proportional.
+ */
+export declare function getTextShadowValue(edgeStyle: string, fontSize: number): string;
+type VideoTheme = "default" | "minimal" | "feed" | "hover" | "hideUI";
+type CaptionLangType = "off" | "eng" | "auto";
+interface SettingsState {
+  volume: number;
+  playbackSpeed: number;
+  customPlayback: number;
+  allowCaptions: boolean;
+  captionPosition: {
+    x: number;
+    y: number;
+  };
+  captionLang: CaptionLangType;
+  captionFontFamily: string;
+  captionFontSize: number;
+  captionFontColor: string;
+  captionFontOpacity: number;
+  captionBGColor: string;
+  captionBGOpacity: number;
+  captionWindowColor: string;
+  captionWindowOpacity: number;
+  captionCharacterEdgeStyle: string;
+  selectedLanguageCode?: string;
+  globalMutedPreference: boolean;
+  preferredQuality?: number;
+  preferredAudioLanguage?: string;
+  preferredSubtitleLanguage?: string;
+}
+interface SmartCaptionPositionParams {
+  position: Position;
+  isDragging: boolean;
+  controlsVisible: boolean;
+}
+/**
+ * Caption window placement: percent-based within the safe zone, snapping to
+ * the bottom (above the controls bar when visible) once dragged past the
+ * snap threshold. Single source for the React hook and the Lit overlay.
+ */
+export declare function getSmartCaptionPosition({ position, isDragging, controlsVisible }: SmartCaptionPositionParams): CSSProperties;
+type CaptionWindowSettings = Pick<SettingsState, "captionWindowColor" | "captionWindowOpacity">;
+/** Caption window box: width from the safe viewport, settings-driven background, drag cursor. */
+export declare function getCaptionWindowStyle(settings: CaptionWindowSettings, safeViewportWidth: number, isDragging: boolean): CSSProperties;
+type CaptionTextSettings = Pick<SettingsState, "captionFontFamily" | "captionFontColor" | "captionFontOpacity" | "captionBGColor" | "captionBGOpacity" | "captionCharacterEdgeStyle">;
+/** Caption text styling from the user's caption settings (font, colors, edge-style shadow). */
+export declare function getCaptionTextStyle(settings: CaptionTextSettings, fontSize: number): CSSProperties;
+export declare function isDocumentFullscreen(): boolean;
+/**
+ * Utility functions for Picture-in-Picture logic
+ */
+/**
+ * Check if a video element is currently in Picture-in-Picture mode.
+ *
+ * Browsers disagree for a video inside shadow DOM: by the spec,
+ * `document.pictureInPictureElement` is retargeted to the shadow host and the
+ * owning ShadowRoot reports the video, but Chromium reports the video on the
+ * document and nothing on the ShadowRoot. Either match counts.
+ */
+export declare function isVideoPictureInPicture(video: HTMLVideoElement | null): boolean;
+/**
+ * Helper to toggle PIP mode safely
+ */
+export declare function togglePictureInPicture(video: HTMLVideoElement | null): Promise<void>;
+/**
+ * Minimum position in seconds to resume from (skip if too close to start)
+ */
+export declare const RESUME_MIN_POSITION_SECONDS = 5;
+/**
+ * Minimum remaining duration in seconds to resume (skip if too close to end)
+ */
+export declare const RESUME_MIN_REMAINING_SECONDS = 5;
+/**
+ * Interval in milliseconds between progress persistence operations
+ */
+export declare const PERSIST_INTERVAL_MS = 2e3;
+export declare const getPersistedProgress: (videoId: string) => number;
+export declare const persistProgress: (videoId: string, positionMs: number) => void;
+/**
+ * Determine if a saved progress position should be used to resume playback
+ * @param savedPositionSeconds - The saved position in seconds
+ * @param durationSeconds - The total video duration in seconds
+ * @returns true if position is valid for resuming (not too close to start or end)
+ */
+export declare function shouldResumeFromPosition(savedPositionSeconds: number, durationSeconds: number): boolean;
+/**
+ * Determine if enough time has elapsed to persist progress again
+ * @param lastPersistTime - Timestamp of last persist operation (from performance.now())
+ * @param currentTime - Current timestamp (from performance.now())
+ * @returns true if interval has elapsed
+ */
+export declare function shouldPersistProgress(lastPersistTime: number, currentTime: number): boolean;
+/**
+ * PRELOAD_RANGE determines how many videos around the current one should be loaded
+ *
+ * Example with BEFORE: 1, AFTER: 2, current index is 5:
+ *
+ * Legend:
+ * PRELOADING (buffering in background)
+ * PLAYING (currently visible)
+ * IDLE (exists but not loaded)
+ * UNLOADED (too far, save memory)
+ */
+export declare const PRELOAD_RANGE: {
+  BEFORE: number;
+  AFTER: number;
+};
+/**
+ * UNLOAD_DISTANCE determines when to unload videos to free memory
+ * If a video is more than this distance from current, unload it
+ */
+export declare const UNLOAD_DISTANCE = 5;
+/**
+ * Video loading states
+ */
+export declare const VideoLoadState: {
+  readonly UNLOADED: "unloaded";
+  readonly IDLE: "idle";
+  readonly PRELOADING: "preloading";
+  readonly PLAYING: "playing";
+};
+export type VideoLoadState = (typeof VideoLoadState)[keyof typeof VideoLoadState];
+/**
+ * Calculate what state a video should be in based on its distance from current
+ */
+export declare function getVideoLoadState(videoIndex: number, currentIndex: number, isCurrent: boolean): VideoLoadState;
+/**
+ * Delay in milliseconds before showing the loading spinner
+ * This prevents flash-of-spinner for brief buffering moments
+ */
+export declare const LOADING_SPINNER_DELAY_MS = 300;
+interface LoadingDebounceState {
+  timerId: ReturnType<typeof setTimeout> | null;
+}
+interface UpdateLoadingStateOptions {
+  state: LoadingDebounceState;
+  shouldShow: boolean;
+  onShow: () => void;
+  onHide: () => void;
+}
+/**
+ * Create initial loading debounce state
+ */
+export declare function createLoadingDebounceState(): LoadingDebounceState;
+/**
+ * Update loading state with debounce
+ */
+export declare function updateLoadingState(options: UpdateLoadingStateOptions): void;
+/**
+ * Clean up loading debounce state (clear any pending timers)
+ */
+export declare function cleanupLoadingDebounce(state: LoadingDebounceState): void;
+/**
+ * Calculate aspect ratio from video element dimensions
+ * @returns aspect ratio (width/height) or undefined if dimensions not available
+ */
+export declare function calculateAspectRatio(videoElement: HTMLVideoElement | null, videoData: VideoData | undefined): number | undefined;
+interface PlaybackHandlerCallbacks {
+  onSegmentStart: () => void;
+  onSegmentEnd: () => void;
+  onRestartSegment: (isPaused?: boolean) => void;
+  onShowSpinner: (show: boolean) => void;
+}
+/**
+ * Handle video play event
+ */
+export declare function handleVideoPlay(playerId: UUID, callbacks: Pick<PlaybackHandlerCallbacks, "onSegmentStart">): void;
+/**
+ * Handle video pause event
+ */
+export declare function handleVideoPause(playerId: UUID, callbacks: Pick<PlaybackHandlerCallbacks, "onSegmentEnd">): void;
+/**
+ * Handle video rate change event
+ */
+export declare function handleVideoRateChange(playerId: UUID, videoElement: HTMLVideoElement | null, callbacks: Pick<PlaybackHandlerCallbacks, "onRestartSegment">): void;
+/**
+ * Handle video error event
+ */
+export declare function handleVideoError(playerId: UUID, callbacks: Pick<PlaybackHandlerCallbacks, "onShowSpinner">): void;
+/**
+ * Update player loading state in store
+ */
+export declare function updatePlayerLoadingState(playerId: UUID, isLoading: boolean): void;
+/**
+ * Delay in milliseconds for single-click detection
+ * Used to distinguish between single click (toggle play) and double click (fullscreen)
+ */
+export declare const SINGLE_CLICK_DELAY_MS = 250;
+/**
+ * Maximum time between clicks to be considered a double-click
+ */
+export declare const DOUBLE_CLICK_THRESHOLD_MS = 400;
+interface ClickDisambiguationState {
+  singleClickTimerId: ReturnType<typeof setTimeout> | null;
+  lastClickTime: number;
+}
+/**
+ * Create initial click disambiguation state
+ */
+export declare function createClickDisambiguationState(): ClickDisambiguationState;
+interface HandleClickOptions {
+  state: ClickDisambiguationState;
+  hideUI: boolean;
+  allowFullscreen: boolean;
+  isExcludedTarget: boolean;
+  onTogglePlay: () => void;
+}
+/**
+ * Handle a click event with disambiguation logic
+ * Returns true if the click was handled, false if ignored
+ */
+export declare function handleClick(options: HandleClickOptions): boolean;
+interface HandleDoubleClickOptions {
+  state: ClickDisambiguationState;
+  allowFullscreen: boolean;
+  isExcludedTarget: boolean;
+  onToggleFullscreen: () => void;
+}
+/**
+ * Handle a double-click event
+ * Returns true if the double-click was handled, false if ignored
+ */
+export declare function handleDoubleClick(options: HandleDoubleClickOptions): boolean;
+/**
+ * Clean up click disambiguation state (clear any pending timers)
+ */
+export declare function cleanupClickDisambiguation(state: ClickDisambiguationState): void;
+/**
+ * Pure helpers for video-element environment effects.
+ *
+ * "Environment effects" = things the player has to keep in sync with the
+ * surrounding document/window: fullscreen state, picture-in-picture state,
+ * tab visibility, viewport size, and the volume/mute state derived from
+ * player + user-interaction inputs.
+ *
+ * Everything in this module is framework-agnostic. React/Lit/Vue wrappers
+ * supply the DOM listeners and the store-update callbacks; this module
+ * supplies the predicates, the state derivations, and the listener factories.
+ */
+/**
+ * Bind the `document` `fullscreenchange` event to a callback that receives the
+ * current fullscreen state.
+ *
+ * Returns a teardown function that removes the listener.
+ */
+export declare function bindFullscreenChangeListener(onChange: (isFullscreen: boolean) => void): () => void;
+/**
+ * Bind `enterpictureinpicture` and `leavepictureinpicture` events on a
+ * video element to a callback that receives the current PiP state.
+ *
+ * Returns a teardown function.
+ */
+export declare function bindPictureInPictureChangeListener(videoElement: HTMLVideoElement | null, onChange: (isPip: boolean) => void): () => void;
+interface PipReentryOptions {
+  videoElement: HTMLVideoElement | null;
+  isCurrentlyInPip: boolean;
+}
+/**
+ * Decide whether to re-request PiP when the document becomes hidden.
+ *
+ * Returns `true` when the caller should re-enter PiP on the supplied
+ * video element. The actual `requestPictureInPicture()` call is left to the
+ * caller (since it returns a promise and the caller chooses how to handle
+ * errors).
+ */
+export declare function shouldReenterPictureInPicture({ videoElement, isCurrentlyInPip }: PipReentryOptions): boolean;
+/**
+ * Bind a `visibilitychange` handler that re-enters PiP whenever the document
+ * becomes hidden and the player believes itself to be in PiP but the browser
+ * has dropped out.
+ *
+ * Returns a teardown function.
+ */
+export declare function bindPipVisibilityReentry(getOptions: () => PipReentryOptions, onError?: (error: unknown) => void): () => void;
+interface AppliedVolumeSync {
+  /** The `muted` value that should be assigned to the video element. */
+  muted: boolean;
+  /** The `volume` value that should be assigned, or `null` if not changing. */
+  volume: number | null;
+  /** When non-null, the store's current `volume` should be updated to this value. */
+  storeVolumeUpdate: number | null;
+}
+interface DeriveVolumeSyncOptions {
+  /** Hard mute applied by the consumer (e.g. theme override). */
+  forcedMuted: boolean;
+  /** The player's persisted `muted` state. */
+  playerMuted: boolean;
+  /** Whether the user has interacted with the player yet. */
+  playerInteracted: boolean;
+  /** The player's persisted `volume`. */
+  playerVolume: number;
+  /** The player's persisted `previousVolume` (used to restore on unmute). */
+  playerPreviousVolume: number;
+}
+/**
+ * Pure derivation of the values that should be written to the video element
+ * (and back to the store) given the current player state.
+ *
+ * Mirrors the behaviour previously implemented inside `useVolumeEffect`:
+ *
+ * 1. When the caller forces mute, nothing else is touched.
+ * 2. Otherwise, `shouldBeMuted` decides the effective mute state.
+ * 3. When unmuted, `getRestoredVolume` resolves the volume to assign, and the
+ *    store is updated only when the current persisted volume is `0`.
+ */
+export declare function deriveVolumeSync({ forcedMuted, playerMuted, playerInteracted, playerVolume, playerPreviousVolume }: DeriveVolumeSyncOptions): AppliedVolumeSync | null;
+/**
+ * Observe a container element's viewport size, invoking the callback with the
+ * current `{width, height}` whenever it changes (via `ResizeObserver`) or
+ * the window resizes.
+ *
+ * Returns a teardown function.
+ */
+export declare function observeViewport(container: HTMLElement | null, onChange: (viewport: Viewport) => void): () => void;
+/**
+ * Pure helpers and DOM-listener factories for player lifecycle effects:
+ * playback rate sync, ended handling, preload state machine, reset-on-data
+ * derivations, and feed playback gating.
+ *
+ * Framework-agnostic. React/Lit/Vue wrappers supply the store-update callbacks;
+ * this module supplies the predicates, derivations, and listener factories.
+ */
+/** Valid values for `<video preload>`. */
+type VideoPreloadAttribute = "auto" | "metadata" | "none";
+/**
+ * Map a feed virtualization `VideoLoadState` to the appropriate
+ * `<video preload>` attribute value.
+ *
+ * - UNLOADED  → "none"     (slot is far from viewport; don't fetch anything)
+ * - IDLE      → "metadata" (slot is reachable but not active; fetch headers only)
+ * - PRELOADING / PLAYING → "auto" (slot is active or about to be; fetch segments)
+ */
+export declare function getPreloadAttribute(loadState: VideoLoadState): VideoPreloadAttribute;
+/**
+ * Bind a `loadeddata` listener that re-applies the playback rate after the
+ * browser resets it (most browsers reset `playbackRate` to `1.0` on each
+ * `<source>` change).
+ *
+ * Also writes the rate immediately so that callers don't have to do so
+ * separately. Returns a teardown function.
+ */
+export declare function bindPlaybackRateSync(videoElement: HTMLVideoElement | null, playbackRate: number): () => void;
+/**
+ * Bind an `ended` listener that invokes `onEnded()` exactly once per native
+ * `ended` event. Returns a teardown function.
+ */
+export declare function bindEndedListener(videoElement: HTMLVideoElement | null, onEnded: () => void): () => void;
+interface PosterDimensions {
+  width?: number;
+  height?: number;
+}
+/**
+ * Compute the aspect ratio (width / height) from poster dimensions, returning
+ * `null` when either dimension is missing or zero.
+ *
+ * Mirrors the conditional in `useResetOnDataChangeEffect`:
+ *
+ *   if (videoData?.poster?.width && videoData?.poster?.height) {
+ *     setAspectRatio(videoData.poster.width / videoData.poster.height);
+ *   }
+ */
+export declare function getAspectRatioFromPoster(poster: PosterDimensions | undefined): number | null;
+interface FeedPlaybackDecisionInput {
+  isFeed: boolean;
+  isCurrent: boolean;
+  loadState: VideoLoadState;
+  showSpinner: boolean;
+  videoReadyState: number;
+}
+type FeedPlaybackAction = "play" | "pause" | "none";
+/**
+ * Decide what a feed-virtualized player should do given the current slot state.
+ *
+ * - In a non-feed context, returns "none" (caller handles its own playback).
+ * - If the slot is not current, returns "pause" so the off-screen player stops.
+ * - If the slot is current, in PLAYING load state, not spinning, and the video
+ *   has enough data (readyState >= 2), returns "play".
+ * - Otherwise returns "none" (still loading / preloading; wait).
+ */
+export declare function getFeedPlaybackAction({ isFeed, isCurrent, loadState, showSpinner, videoReadyState }: FeedPlaybackDecisionInput): FeedPlaybackAction;
+/**
+ * Generic "click outside" detection with an optional exclusion attribute.
+ *
+ * Use case: a settings menu that should close when the user clicks outside it,
+ * but NOT when the user clicks the button that opens it (otherwise the button
+ * both opens and immediately closes the menu in the same pointer cycle).
+ *
+ * Pure, DOM-only, framework-agnostic. React/Lit/Vue wrappers call
+ * `bindClickOutside` from their lifecycle hooks.
+ */
+interface ClickOutsideOptions {
+  /**
+   * Function that returns the "inside" element. Called on every pointer event,
+   * so the caller can pass a ref-like getter that may be null until the
+   * referenced element is mounted.
+   */
+  getContainer: () => HTMLElement | null;
+  /**
+   * Optional attribute name (e.g. `"data-settings-button"`). Any pointer event
+   * whose target is inside an element carrying this attribute is treated as
+   * "inside" and does NOT trigger `onOutsideClick`.
+   *
+   * This is what lets the button that toggles the menu coexist with a
+   * close-on-outside-click listener: the button's own clicks are ignored here,
+   * letting the button's own onClick decide whether to toggle.
+   */
+  excludeAttribute?: string;
+  /**
+   * Invoked when a pointer event lands outside both the container and (if
+   * configured) any element carrying `excludeAttribute`.
+   */
+  onOutsideClick: (event: MouseEvent) => void;
+}
+/**
+ * Returns `true` when the given event target is inside an element carrying
+ * the supplied attribute. When `attribute` is undefined, always returns false.
+ */
+export declare function isInsideExcludedElement(target: EventTarget | null, attribute: string | undefined): boolean;
+/**
+ * Returns `true` when the event lands outside both the container and any
+ * excluded element.
+ *
+ * Checks the composed path as well as the plain target: document-level
+ * listeners see shadow-DOM events retargeted to the host, and
+ * `document.querySelector` cannot see into shadow roots — the composed path
+ * is the only reliable record of where the click really landed.
+ */
+export declare function isClickOutside(event: MouseEvent, container: HTMLElement | null, excludeAttribute: string | undefined): boolean;
+/**
+ * Bind a `mousedown` listener on the document that invokes `onOutsideClick`
+ * whenever the event lands outside the container and outside any element
+ * carrying `excludeAttribute`.
+ *
+ * Returns a teardown function that removes the listener.
+ *
+ * The container is looked up via `getContainer()` on every event so the caller
+ * can wire it to a ref that may be null at bind time.
+ */
+export declare function bindClickOutside({ getContainer, excludeAttribute, onOutsideClick }: ClickOutsideOptions): () => void;
+/**
+ * Bind a `visibilitychange` listener that fires `onHidden` when the document
+ * is hidden. Returns a teardown function.
+ *
+ * Settings menus use this to close themselves when the user tabs away.
+ * Lives next to `bindClickOutside` because the two are almost always wired
+ * together for "dismissible overlay" behaviour.
+ */
+export declare function bindDocumentHidden(onHidden: () => void): () => void;
+/**
+ * Live "is the player buffering right now?" predicate.
+ *
+ * Different from `video-preload-config.ts` despite the similar name:
+ *  - `video-preload-config.ts` decides the `<video preload>` attribute for
+ *    a slot in the feed virtualization (one-time decision per slot).
+ *  - `shouldShowSpinner` is called continuously during playback to decide
+ *    whether the buffering spinner should currently be visible.
+ *
+ * Inputs come from a live `<HTMLVideoElement>`. The function is otherwise
+ * pure and framework-agnostic.
+ */
+/**
+ * Decide whether the buffering spinner should be visible for the given
+ * video element.
+ *
+ * Logic, in order:
+ * 1. No video → never show.
+ * 2. Playing past the start → if the current time falls inside any buffered
+ *    range, the player has the bytes it needs; never show.
+ * 3. Otherwise fall back to `readyState`/`seeking`: show when the browser
+ *    reports `HAVE_CURRENT_DATA` (2) or is actively seeking with
+ *    `readyState < 3` (HAVE_FUTURE_DATA).
+ */
+export declare function shouldShowSpinner(video: HTMLVideoElement | null): boolean;
+interface QualityLevel {
+  height: number;
+  width: number;
+  bitrate: number;
+  name: string;
+  index: number;
+}
+interface AudioTrack {
+  index: number;
+  label: string;
+  language: string;
+  kind: string;
+  /** The raw Hls.js MediaPlaylist object for this audio track. */
+  track: MediaPlaylist;
+}
+export declare const sortLevelsByQuality: (levels: QualityLevel[]) => QualityLevel[];
+export declare const isHlsStream: (url: string) => boolean;
+export declare const generateLevelName: (level: {
+  height: number;
+  width: number;
+  bitrate: number;
+}) => string;
+interface QualityLabelParams {
+  resolution: number;
+  levels: QualityLevel[];
+  currentLevel: number;
+  autoText: string;
+}
+export declare const getQualityLabel: ({ resolution, levels, currentLevel, autoText }: QualityLabelParams) => string;
+export declare const MAX_NETWORK_RETRIES = 3;
+export declare const MAX_MEDIA_RECOVERIES = 1;
+interface HlsErrorPayload {
+  /** The hls.js error type, e.g. `"networkError"`, `"mediaError"`. */
+  error: string;
+  /** Specific hls.js error details (e.g. `"manifestLoadError"`) or undefined. */
+  code?: string;
+}
+interface HlsErrorRecoveryState {
+  networkRetries: number;
+  mediaRecoveries: number;
+}
+export declare function createHlsErrorRecoveryState(): HlsErrorRecoveryState;
+type HlsErrorAction = {
+  kind: "retry-network";
+  attempt: number;
+} | {
+  kind: "recover-media";
+  attempt: number;
+} | {
+  kind: "give-up";
+  payload: HlsErrorPayload;
+};
+interface HlsErrorInput {
+  type: string;
+  details?: string;
+  fatal: boolean;
+}
+/**
+ * Decide what to do given an HLS error and the current recovery counters.
+ *
+ * Mutates `state` to advance the appropriate counter when retry/recover is
+ * selected. Non-fatal errors return `null` (the caller should ignore them).
+ */
+export declare function decideHlsErrorAction(error: HlsErrorInput, state: HlsErrorRecoveryState): HlsErrorAction | null;
+/**
+ * Framework-agnostic HLS setup.
+ *
+ * Owns:
+ *  - HLS.js configuration tuned for the SDK's playback profile.
+ *  - Media-attached / manifest-parsed / level-switched / audio-track-switched
+ *    event handlers.
+ *  - Buffer-flush-on-far-seek heuristic (see `createSeekingHandler`).
+ *  - Error recovery policy (see Error recovery section below).
+ *  - Safari native HLS fallback.
+ *
+ * hls.js itself is loaded on first use (see `loadHls`), so `setupHls` is
+ * async and pages that never attach an HLS stream never download it.
+ *
+ * Resolves to a `HlsController` whose lifetime the caller manages via `destroy()`.
+ * Caller responsibilities:
+ *  - Provide the `<video>` element and a `playerId`.
+ *  - Subscribe to quality/level/audio changes via the controller's getters or
+ *    by reading `playerStateStore`.
+ *  - Surface errors to UI via the `onError` callback.
+ */
+type HlsInstance = Hls;
+interface HlsController {
+  hls: Hls | null;
+  levels: QualityLevel[];
+  currentLevel: number;
+  isAuto: boolean;
+  destroy: () => void;
+  setQuality: (index: number) => void;
+}
+interface SetupHlsOptions {
+  videoElement: HTMLVideoElement;
+  videoUrl: string;
+  playerId: UUID;
+  isPreloading?: boolean;
+  /**
+   * Invoked when an HLS error is given up on (after retries are exhausted, or
+   * for non-recoverable error types). Callers typically dispatch a custom event
+   * and/or show an error overlay.
+   */
+  onError?: (payload: HlsErrorPayload) => void;
+  /**
+   * Invoked whenever HLS reports updated quality levels (after manifest parse
+   * or level update). Useful for framework wrappers that mirror controller
+   * state into reactive store/state (e.g. React `useState`).
+   */
+  onLevelsChange?: (levels: QualityLevel[]) => void;
+  /**
+   * Invoked whenever HLS switches to a different quality level.
+   */
+  onLevelSwitch?: (level: number) => void;
+}
+export declare function createHlsConfig(isPreloading?: boolean): Partial<Hls["config"]>;
+/**
+ * Set up HLS streaming on a video element, resolving to a controller for
+ * quality/audio switching and teardown.
+ *
+ * - For non-HLS URLs: sets `videoElement.src` directly and resolves to `null`
+ *   without loading hls.js.
+ * - For HLS URLs on Safari (no `Hls.isSupported()` but native canPlayType):
+ *   sets `videoElement.src` and returns `null` (UI features that depend on
+ *   the HLS controller — quality switching, audio tracks — won't be available
+ *   in native mode).
+ * - Otherwise: instantiates HLS.js, attaches the media, wires events
+ *   (including error recovery), and returns the controller.
+ */
+export declare function setupHls(opts: SetupHlsOptions): Promise<HlsController | null>;
+export declare const getPersistedSubtitleTrack: () => number;
+export declare const persistSubtitleTrack: (trackIndex: number) => void;
+export declare const getPersistedAudioTrack: () => number;
+export declare const persistAudioTrack: (trackIndex: number) => void;
+type ContentType = "video" | "image";
+type ViewType = "start" | "watch" | "end";
+type Page = "feed" | "standalone" | "profile";
+interface Segment {
+  start_ms: number;
+  end_ms: number;
+  speed: number;
+}
+interface ContentViewEvent {
+  _type: "content_views";
+  timestamp?: number;
+  content_id: string;
+  content_type: ContentType;
+  view_type: ViewType;
+  watch_duration_ms: number;
+  page: Page;
+  feed_id?: string;
+  post_id?: string;
+  video_position_ms?: number;
+  video_total_duration_ms?: number;
+  segments?: Segment[];
+  device_id?: string;
+  country?: string;
+}
+interface EngagementEvent {
+  _type: "engagement";
+  timestamp?: number;
+  engagement_type: string;
+  resource_type?: string;
+  resource_id?: string;
+  page?: string;
+  comment_text?: string;
+  share_platform?: string;
+  country?: string;
+  device_type?: string;
+  session_id?: string;
+}
+interface InteractionEvent {
+  _type: "interaction";
+  timestamp?: number;
+  interaction_type: string;
+  element_type?: string;
+  element_id?: string;
+  session_id?: string;
+  page?: string;
+  page_url?: string;
+  scroll_depth?: number;
+  search_query?: string;
+  click_x?: number;
+  click_y?: number;
+  device_type?: string;
+  browser?: string;
+  resource_id?: string;
+  resource_type?: string;
+  feed_id?: string;
+  post_id?: string;
+  content_id?: string;
+}
+interface ErrorEvent {
+  _type: "error";
+  timestamp?: number;
+  error_type: string;
+  error_code?: string;
+  error_message?: string;
+  stack_trace?: string;
+  resource_type?: string;
+  resource_id?: string;
+  endpoint?: string;
+  session_id?: string;
+  device_type?: string;
+  browser?: string;
+  os?: string;
+}
+interface SessionStartEvent {
+  _type: "session_start";
+  timestamp?: number;
+  utm_source?: string;
+  utm_campaign?: string;
+  browser?: string;
+  language?: string;
+  screen_resolution?: string;
+  platform?: string;
+  tg_platform?: string;
+  tg_version?: string;
+  timezone?: string;
+  timezone_offset?: number;
+  color_depth?: number;
+  touch_support?: boolean;
+  country?: string;
+  user_id?: string;
+}
+interface AnalyticsContext {
+  user_id?: string;
+  country?: string;
+  city?: string;
+  region?: string;
+  device?: string;
+  os?: string;
+  os_version?: string;
+  language?: string;
+  browser?: string;
+  screen_resolution?: string;
+  platform?: string;
+  tg_platform?: string;
+  tg_version?: string;
+  timezone?: string;
+  timezone_offset?: number;
+  color_depth?: number;
+  touch_support?: boolean;
+  utm_source?: string;
+  utm_campaign?: string;
+}
+type AnalyticsEvent = ContentViewEvent | EngagementEvent | InteractionEvent | ErrorEvent | SessionStartEvent;
+interface CurrentSegment {
+  start_ms: number;
+  speed: number;
+}
+interface AnalyticsState {
+  segments: Map<string, Segment[]>;
+  currentSegment: Map<string, CurrentSegment | null>;
+}
+export declare const analyticsStore: WritableAtom<AnalyticsState>;
+export declare const analyticsStoreActions: {
+  /**
+   * Start tracking a new segment
+   */
+  startSegment(playerId: string, positionMs: number, speed: number): void;
+  /**
+   * End the current segment being tracked
+   */
+  endSegment(playerId: string, positionMs: number): void;
+  /**
+   * Get segments including the current in-progress segment
+   */
+  getSegmentsWithCurrent(playerId: string, currentPositionMs: number): Segment[];
+  /**
+   * Clear all segments for a player
+   */
+  clearSegments(playerId: string): void;
+};
+interface SegmentAnalyticsParams {
+  playerId: UUID;
+  currentTimeMs: number;
+  playbackRate: number;
+  isPaused: boolean;
+}
+/**
+ * Start tracking a new analytics segment
+ */
+export declare function startSegment(params: SegmentAnalyticsParams): void;
+/**
+ * End the current analytics segment
+ */
+export declare function endSegment(params: Pick<SegmentAnalyticsParams, "playerId" | "currentTimeMs">): void;
+/**
+ * Restart segment if video is currently playing
+ * This is useful when playback rate changes or other segment-breaking events occur
+ */
+export declare function restartSegmentIfPlaying(params: SegmentAnalyticsParams): void;
+interface ControlsState {
+  visible: boolean;
+  hideTimeout: ReturnType<typeof setTimeout> | null;
+}
+interface ControlsStore {
+  state: Map<UUID, MapStore<ControlsState>>;
+  get: (id: UUID) => MapStore<ControlsState>;
+  deleteControls: (id: UUID) => void;
+  setVisible: (id: UUID, visible: boolean) => void;
+  showControls: (id: UUID, autoHideMs?: number) => void;
+  hideControls: (id: UUID) => void;
+}
+export declare const controlsStore: ControlsStore;
+interface FeedCacheState {
+  cachedPosts: FeedPost[];
+  isLoadingFromCache: boolean;
+}
+export declare const feedCacheAtom: WritableAtom<FeedCacheState>;
+interface FeedCacheStore {
+  currentFeedId: string | undefined;
+  loadCache: (feedId?: string) => FeedPost[];
+  /**
+   * Append posts to the cache. Pass the feed the posts came from and the batch
+   * is refused if the cache has since moved to another feed.
+   */
+  saveNewPosts: (newPosts: FeedPost[], feedId?: string) => void;
+  removePost: (postId: string) => void;
+  clearCache: () => void;
+  getCacheStats: () => {
+    size: number;
+    timestamp: number | null;
+  };
+}
+export declare const feedCacheStore: FeedCacheStore;
+interface PostStoreState {
+  initialized: boolean;
+  feedId: string;
+  posts: FeedPost[];
+  isLoadedInitial: boolean;
+  isFetchingVideos: boolean;
+  currentIndex: number;
+  total: number;
+}
+export declare const postStore: WritableAtom<PostStoreState>;
+interface PostStoreActions {
+  init: (feedId: string) => void;
+  loadInitialPosts: () => Promise<void>;
+  fetchNewVideos: () => Promise<void>;
+  setCurrentIndex: (index: number) => void;
+}
+export declare const postStoreActions: PostStoreActions;
+export declare const FEED_COMPONENTS_COUNT = 5;
+export declare const FEED_TRANSITION_THRESHOLD: number;
+interface FeedInteractionStore {
+  hasInteracted: WritableAtom<boolean>;
+  whenInteracted: WritableAtom<Date>;
+  hasInitialized: WritableAtom<boolean>;
+  videosInitialized: WritableAtom<number>;
+  components: WritableAtom<number[]>;
+  originalPositions: WritableAtom<number[]>;
+  transforms: WritableAtom<number[]>;
+  setTransforms: (transforms: number[]) => void;
+}
+export declare const feedStore: FeedInteractionStore;
+export declare const setHasInteracted: () => boolean;
+export declare const initializeVideo: () => void;
+interface PlayerContainerElementStore {
+  register: (playerId: UUID, element: HTMLDivElement) => void;
+  unregister: (playerId: UUID) => void;
+  get: (playerId: UUID) => HTMLDivElement | null;
+  subscribe: (playerId: UUID, listener: () => void) => () => void;
+  clear: () => void;
+}
+export declare const playerContainerElementStore: PlayerContainerElementStore;
+interface PlayerMediaElementStore {
+  register: (playerId: UUID, element: HTMLVideoElement) => void;
+  unregister: (playerId: UUID) => void;
+  get: (playerId: UUID) => HTMLVideoElement | null;
+  subscribe: (playerId: UUID, listener: () => void) => () => void;
+  clear: () => void;
+}
+export declare const playerMediaElementStore: PlayerMediaElementStore;
+export declare const defaultSettings: SettingsState;
+export declare const FONT_FAMILIES: {
+  readonly monospace_serif: "\"Courier New\", Courier, \"Nimbus Mono L\", \"Cutive Mono\", monospace";
+  readonly proportional_serif: "\"Times New Roman\", Times, Georgia, Cambria, \"PT Serif Caption\", serif";
+  readonly monospace_sans: "\"Deja Vu Sans Mono\", \"Lucida Console\", Monaco, Consolas, \"PT Mono\", monospace";
+  readonly proportional_sans: "Roboto, Arial, Helvetica, Verdana, \"PT Sans Caption\", sans-serif";
+  readonly casual: "\"Comic Sans MS\", Impact, Handlee, fantasy";
+  readonly cursive: "\"Monotype Corsiva\", \"URW Chancery L\", \"Apple Chancery\", \"Dancing Script\", cursive";
+  readonly small_caps: "Arial, Helvetica, Verdana, \"Marcellus SC\", sans-serif";
+};
+type FontFamilyKey = keyof typeof FONT_FAMILIES;
+export declare const FONT_SIZES: number[];
+export declare const COLORS: Record<string, string>;
+export declare const EDGE_STYLES: string[];
+export declare const PLAYBACK_SPEEDS: number[];
+export declare const LANG_TYPES: string[];
+/**
+ * Validate and parse settings, returning defaults for invalid values
+ * @param parsed - Raw settings object (e.g., from localStorage)
+ * @returns Validated settings with defaults applied for invalid values
+ */
+export declare const validateSettings: (parsed: unknown) => SettingsState;
+export declare const loadSettings: () => SettingsState;
+export declare const saveSettings: (settings: SettingsState) => void;
+interface SettingsStore {
+  state: MapStore<SettingsState>;
+  getSettings: () => SettingsState;
+  setVolume: (volume: number) => number;
+  setPlaybackSpeed: (playbackSpeed: number) => number;
+  setCustomPlayback: (customPlayback: number) => number;
+  setAllowCaptions: (allowCaptions: boolean) => boolean;
+  setCaptionPosition: (x: number, y: number) => {
+    x: number;
+    y: number;
+  };
+  setSubtitleLang: (captionLang: CaptionLangType) => CaptionLangType;
+  setCaptionFontFamily: (captionFontFamily: string) => string;
+  setCaptionFontSize: (captionFontSize: number) => number;
+  setCaptionFontColor: (captionFontColor: string) => string;
+  setCaptionBGColor: (captionBGColor: string) => string;
+  setCaptionBGOpacity: (captionOpacity: number) => number;
+  setCaptionWindowColor: (captionWindowColor: string) => string;
+  setCaptionWindowOpacity: (captionWindowOpacity: number) => number;
+  setCaptionFontOpacity: (captionFontOpacity: number) => number;
+  setCaptionCharacterEdgeStyle: (captionCharacterEdgeStyle: string) => string;
+  resetCaptionSettings: () => void;
+  setSelectedLanguageCode: (languageCode: string) => string | undefined;
+  setMuted: (muted: boolean) => boolean;
+  setPreferredQuality: (quality: number | undefined) => number | undefined;
+  setPreferredAudioLanguage: (language: string | undefined) => string | undefined;
+  setPreferredSubtitleLanguage: (language: string | undefined) => string | undefined;
+}
+export declare const settingsStore: SettingsStore;
+/**
+ * Settings-menu keys follow a hierarchical naming convention:
+ * - Root menus: simple names (main, quality, audio, captions, playback)
+ * - Nested menus: parent-child pattern (captions.style, captions.font, etc.)
+ */
+type MenuKey = "main" | "quality" | "audio" | "captions" | "playback" | "captions.style" | "captions.font" | "captions.background" | "captions.window" | "captions.font-family" | "captions.edge-style";
+/** Stack of visited menus for navigation history */
+export declare const menuStack: WritableAtom<MenuKey[]>;
+/** Direction of the last navigation (for animation) */
+export declare const navigationDirection: WritableAtom<"forward" | "back">;
+/** Current active menu is the top of the stack */
+export declare const activeMenu: ReadableAtom<MenuKey>;
+/** Navigate to a new menu (pushes to stack) */
+export declare const pushMenu: (menuId: MenuKey) => void;
+/** Go back to previous menu (pops from stack) */
+export declare const popMenu: () => void;
+/** Reset to main menu */
+export declare const resetMenu: () => void;
+/**
+ * Fill percentage for the custom playback-speed slider. Piecewise on purpose:
+ * normal speed (1.0x) sits at the visual middle of the track, with min–1.0
+ * mapped to the lower half and 1.0–max to the upper half. Note the pointer
+ * mapping below is linear — the same asymmetry the React slider ships with.
+ */
+export declare function computePlaybackFillPercentage(value: number, min: number, max: number): number;
+interface PlaybackPointerOptions {
+  rect: {
+    left: number;
+    width: number;
+  };
+  clientX: number;
+  min: number;
+  max: number;
+  step: number;
+}
+/**
+ * Linear pointer-position → playback value: clamped to the track, snapped to
+ * the step grid, formatted to two decimals (the value React persists via
+ * settingsStore.setCustomPlayback).
+ */
+export declare function computePlaybackValueFromPointer({ rect, clientX, min, max, step }: PlaybackPointerOptions): number;
+/**
+ * Settings-menu strings, mirroring the corresponding keys of
+ * packages/react/src/locales/<lang>.json verbatim (quality.*, audio.*,
+ * playback.*, captions.* and common.*). Edge-style options are keyed by the
+ * EDGE_STYLES runtime values and font families by FontFamilyKey, so menus can
+ * look labels up directly from the constants they render.
+ *
+ * Import this module from the lazy settings chunk only — it must not be
+ * pulled into the initial player bundle.
+ */
+interface PlayerMenuLabels {
+  quality: {
+    title: string;
+    auto: string;
+  };
+  audio: {
+    title: string;
+    noTracks: string;
+  };
+  playback: {
+    speed: string;
+    custom: string;
+    normal: string;
+  };
+  captions: {
+    title: string;
+    off: string;
+    style: string;
+    font: string;
+    background: string;
+    window: string;
+    resetAll: string;
+    edgeStyle: {
+      title: string;
+      options: Record<string, string>;
+    };
+    fontFamilies: Record<FontFamilyKey, string>;
+  };
+  stats: {
+    title: string;
+    copyDebug: string;
+    videoId: string;
+    playerId: string;
+    viewport: string;
+    dropped: string;
+    resolution: string;
+    volume: string;
+    codecs: string;
+    color: string;
+    connectionSpeed: string;
+    bufferHealth: string;
+  };
+  shortcuts: {
+    title: string;
+    playPause: string;
+    seek10s: string;
+    seek5s: string;
+    pip: string;
+    fullscreen: string;
+    mute: string;
+    volume: string;
+  };
+  colors: Record<string, string>;
+  common: {
+    back: string;
+    family: string;
+    more: string;
+    less: string;
+    settings: string;
+    size: string;
+    opacity: string;
+    color: string;
+    reset: string;
+    custom: string;
+    options: string;
+    off: string;
+  };
+}
+export declare function getPlayerMenuLabels(code: string | null | undefined): PlayerMenuLabels;
+interface SubtitleTrack {
+  index: number;
+  label: string;
+  language: string;
+  kind: string;
+  track: TextTrack;
+}
+/**
+ * Calculates the efficient end time for a cue to prevent flickering and ensure readability.
+ */
+export declare const calculateSmoothedEndTime: (cue: TextTrackCue | VTTCue, nextCue?: TextTrackCue | VTTCue) => number;
+/**
+ * Helper to find the next cue in a TextTrackCueList by reference.
+ */
+export declare const findNextCue: (activeCue: TextTrackCue, allCues: TextTrackCueList | null) => TextTrackCue | undefined;
+export declare function stripHtmlTags(input: string): string;
+/**
+ * Extracts and cleans text from a cue object.
+ * Handles VTTCue vs TextTrackCue differences.
+ */
+export declare const getCleanCueText: (cue: TextTrackCue | VTTCue) => string;
+/**
+ * Applies smoothing logic to a list of cues (typically activeCues).
+ * Modifies the cues in-place and caches them to avoid re-processing.
+ */
+export declare const processCues: (cues: TextTrackCueList | TextTrackCue[], allCues: TextTrackCueList | null) => void;
+/**
+ * Parses the video element's text tracks and extracts relevant subtitle/caption tracks.
+ * Also normalizes track state.
+ */
+export declare const extractSubtitleTracks: (tracks: TextTrackList) => SubtitleTrack[];
+interface PlayerState {
+  paused: boolean;
+  loading: boolean;
+  ended: boolean;
+  mounted: boolean;
+  hasInteracted: boolean;
+  whenInteracted: Date;
+  isFullscreen: boolean;
+  isPictureInPicture: boolean;
+  muted: boolean;
+  playbackRate: number;
+  volume: number;
+  previousVolume: number;
+  viewport: {
+    width: number;
+    height: number;
+  };
+  resolution: number;
+  subtitleTrack: number;
+  availableSubtitleTracks: SubtitleTrack[];
+  currentSubtitleText: string;
+  audioTrack: number;
+  availableAudioTracks: AudioTrack[];
+  hlsInstance: Hls | null;
+}
+interface PlayerProgressSnapshot {
+  currentTime: number;
+  duration: number;
+  progress: number;
+  buffered: number;
+}
+interface PlayerStateStore {
+  state: Map<UUID, MapStore<PlayerState>>;
+  get: (id: UUID) => MapStore<PlayerState>;
+  deletePlayer: (id: UUID) => void;
+  getEffectiveMediaMuted: (player: Pick<PlayerState, "muted" | "volume" | "hasInteracted">) => boolean;
+  muteMedia: (id: UUID) => void;
+  unmuteMedia: (id: UUID) => void;
+  toggleMediaMute: (id: UUID) => void;
+  setMediaVolume: (id: UUID, volume: number) => void;
+  playMedia: (id: UUID) => Promise<void>;
+  pauseMedia: (id: UUID) => void;
+  toggleMediaPlayback: (id: UUID) => Promise<void>;
+  pauseOtherMedia: (except: UUID) => void;
+  setMediaPlaybackRate: (id: UUID, playbackRate: number) => void;
+  readProgressSnapshot: (id: UUID) => PlayerProgressSnapshot;
+  subscribeToProgress: (id: UUID, onStoreChange: () => void) => () => void;
+  seekProgressTo: (id: UUID, seconds: number) => void;
+  seekProgressBy: (id: UUID, deltaSeconds: number) => void;
+  getTrackOptions: (tracks: {
+    label: string;
+    language: string;
+    kind: string;
+  }[]) => {
+    index: number;
+    label: string;
+    language: string;
+    kind: string;
+  }[];
+  selectAudioTrack: (id: UUID, trackIndex: number) => void;
+  selectSubtitleTrack: (id: UUID, trackIndex: number) => void;
+  setAudioTrack: (id: UUID, audioTrack: number) => void;
+  setAvailableAudioTracks: (id: UUID, tracks: AudioTrack[]) => void;
+  setGlobalMuted: (muted: boolean) => void;
+  setGlobalVolume: (volume: number) => void;
+  setGlobalPlaybackRate: (rate: number) => void;
+  setGlobalPreferredQuality: (quality: number | undefined) => void;
+  setGlobalPreferredAudioLanguage: (language: string | undefined) => void;
+  setGlobalPreferredSubtitleLanguage: (language: string | undefined) => void;
+  pauseAllPlayers: () => void;
+  setMounted: (id: UUID) => void;
+  setHasInteracted: (id: UUID) => void;
+  setPaused: (id: UUID, paused: boolean) => void;
+  setLoading: (id: UUID, loading: boolean) => void;
+  setEnded: (id: UUID, ended: boolean) => void;
+  setFullscreen: (id: UUID, isFullscreen: boolean) => void;
+  setPictureInPicture: (id: UUID, isPictureInPicture: boolean) => void;
+  setMuted: (id: UUID, muted: boolean) => void;
+  setPlaybackRate: (id: UUID, playbackRate: number) => void;
+  setPreviousVolume: (id: UUID, previousVolume: number) => void;
+  setVolume: (id: UUID, volume: number) => void;
+  setViewport: (id: UUID, width: number, height: number) => void;
+  setResolution: (id: UUID, resolution: number) => void;
+  setSubtitleTrack: (id: UUID, subtitleTrack: number) => void;
+  setAvailableSubtitleTracks: (id: UUID, tracks: SubtitleTrack[]) => void;
+  setCurrentSubtitleText: (id: UUID, text: string) => void;
+  setHlsInstance: (id: UUID, hlsInstance: Hls | null) => void;
+}
+export declare const playerStateStore: PlayerStateStore;
+interface PlayerUiActionTargets {
+  container?: HTMLDivElement | null;
+  video?: HTMLVideoElement | null;
+}
+export declare function showPlayerControls(playerId: UUID): void;
+export declare function hidePlayerControls(playerId: UUID): void;
+export declare function togglePlayerFullscreen(playerId: UUID, overrides?: PlayerUiActionTargets): Promise<void>;
+export declare function togglePlayerPictureInPicture(playerId: UUID, overrides?: PlayerUiActionTargets): Promise<void>;
+/**
+ * Structural shape of a video element ref. Compatible with React.RefObject
+ * but does not depend on React, keeping this module framework-agnostic.
+ */
+interface VideoElementRef {
+  current: HTMLVideoElement | null;
+}
+export declare const handleLoadedMetadata: (videoElement: HTMLVideoElement, playerId: UUID) => void;
+export declare const clearSubtitles: (playerId: UUID) => void;
+/**
+ * Handles the 'cuechange' event to update subtitles.
+ * Uses event-driven logic + lookahead smoothing to prevent flickering.
+ */
+export declare const handleCueChange: (playerId: UUID, videoRef: VideoElementRef) => void;
+/**
+ * Pure buffer-progress computations extracted from useBufferProgress.
+ * Operate on plain TimeRanges + numbers, not HTMLVideoElement, so they
+ * are framework-agnostic and trivially testable.
+ */
+interface BufferRange {
+  start: number;
+  end: number;
+}
+/**
+ * Convert a TimeRanges into normalized 0-100 percentage ranges.
+ * Returns [] when duration is zero/invalid or timeRanges is missing.
+ */
+export declare const computeBufferRanges: (timeRanges: TimeRanges | null | undefined, duration: number) => BufferRange[];
+/**
+ * How much buffer (as a 0-100 percentage) is loaded ahead of the
+ * current playback position. Considers only ranges that cover the
+ * current position; takes the maximum contiguous lookahead.
+ */
+export declare const computeBufferedAhead: (ranges: BufferRange[], currentTime: number, duration: number) => number;
+/**
+ * Pure progress-fraction helper extracted from useProgressBar.
+ *
+ * Returns a value in [0, 1] representing how far through `duration`
+ * `currentTime` is. Defensive against the common edge cases where
+ * duration is zero, NaN, or Infinity (e.g. before metadata loads),
+ * and against non-finite currentTime values. The previous inline
+ * `video.currentTime / video.duration` formula produced NaN in
+ * those cases, which leaked into React state.
+ */
+export declare function computeProgressFraction(currentTime: number, duration: number): number;
+interface BuildEventParams {
+  contentId: string;
+  contentType: ContentType;
+  viewType: ViewType;
+  watchDurationMs: number;
+  page: Page;
+  feedId?: string;
+  postId?: string;
+  videoPositionMs?: number;
+  videoTotalDurationMs?: number;
+  segments?: Segment[];
+}
+/**
+ * Build a content view event for analytics
+ * Pure function that constructs the event payload
+ */
+export declare function buildContentViewEvent(params: BuildEventParams): ContentViewEvent;
+/**
+ * Calculate watch duration from start time to now
+ */
+export declare function calculateWatchDuration(startTimeMs: number | null): number;
+/**
+ * Determine the effective page based on feedId presence
+ */
+export declare function getEffectivePage(page: Page, feedId?: string): Page;
+/**
+ * Check if segments should be included in the event
+ * Only include for "watch" and "end" view types
+ */
+export declare function shouldIncludeSegments(viewType: ViewType): boolean;
+/**
+ * Round milliseconds for video position/duration
+ */
+export declare function roundMs(ms: number): number;
+/**
+ * Convert seconds to milliseconds
+ */
+export declare function secondsToMs(seconds: number): number;
+/**
+ * Convert milliseconds to seconds (for timestamp)
+ */
+export declare function msToSeconds(ms: number): number;
+interface VideoAnalyticsPayload {
+  videoPositionMs?: number;
+  videoTotalDurationMs?: number;
+  segments?: Segment[];
+}
+interface VideoSnapshot {
+  currentTime: number;
+  duration: number;
+}
+interface BuildVideoAnalyticsPayloadParams {
+  contentType: ContentType;
+  viewType: ViewType;
+  video?: VideoSnapshot | null;
+  playerId?: string;
+}
+/**
+ * Build and POST a single content-view event.
+ */
+export declare function postContentEvent(params: BuildEventParams): void;
+/**
+ * Compute the video position / duration / segments to attach to a
+ * content-view event. Returns an empty payload for non-video content
+ * or when the video snapshot is unavailable.
+ */
+export declare function buildVideoAnalyticsPayload({ contentType, viewType, video, playerId }: BuildVideoAnalyticsPayloadParams): VideoAnalyticsPayload;
+export declare const analyticsContextStore: WritableAtom<AnalyticsContext>;
+export declare function setAnalyticsContext(context: Partial<AnalyticsContext>): void;
+interface DeviceState {
+  deviceId: string | undefined;
+}
+export declare const analyticsDeviceStore: WritableAtom<DeviceState>;
+export declare function getOrCreateDeviceId(): string;
+export declare function setDeviceId(deviceId: string): void;
+interface SessionState {
+  sessionId: string | undefined;
+  started: boolean;
+}
+export declare const analyticsSessionStore: WritableAtom<SessionState>;
+export declare function getOrCreateSessionId(): string;
+export declare function initializeAnalyticsContext(): void;
+/**
+ * Chapter with calculated end time and duration
+ */
+interface ChapterWithEnd extends Chapter {
+  endTime: number;
+  durationSec: number;
+}
+/**
+ * Check if a single chapter is within the video duration
+ * @param chapter - The chapter to validate
+ * @param videoDuration - The total video duration in seconds
+ * @param tolerance - Tolerance in seconds for rounding errors (default: 1)
+ * @returns Whether the chapter is within valid bounds
+ */
+export declare function isChapterWithinDuration(chapter: Chapter, videoDuration: number, tolerance?: number): boolean;
+/**
+ * Validate chapters for use with chaptered progress bar
+ * Returns false if:
+ * - chapters is undefined or empty
+ * - less than 2 chapters (need multiple for chaptered bar)
+ * - any chapter exceeds video duration
+ *
+ * @param chapters - Array of chapters to validate
+ * @param videoDuration - The total video duration in seconds
+ * @param tolerance - Tolerance in seconds for rounding errors (default: 1)
+ * @returns Whether chapters are valid for chaptered progress bar
+ */
+export declare function validateChapters(chapters: Chapter[] | undefined, videoDuration: number, tolerance?: number): boolean;
+/**
+ * Calculate chapter end times based on next chapter start or video duration
+ */
+export declare function calculateChaptersWithEnd(chapters: Chapter[], duration: number): ChapterWithEnd[];
+/**
+ * Slice heatmap data for a specific chapter based on its time range
+ */
+interface HeatmapSliceParams {
+  heatmapData: number[];
+  chapterStartTime: number;
+  chapterEndTime: number;
+  videoDuration: number;
+}
+export declare function sliceHeatmapData({ heatmapData, chapterStartTime, chapterEndTime, videoDuration }: HeatmapSliceParams): number[];
+/**
+ * Calculate all heatmap slices for chapters
+ */
+export declare function calculateHeatmapSlices(heatmapData: number[] | null, chapters: ChapterWithEnd[], duration: number): number[][];
+/**
+ * Calculate global max value from heatmap data for consistent normalization
+ */
+export declare function calculateGlobalMax(heatmapData: number[] | null): number;
+/**
+ * Calculate progress percentage within a chapter segment
+ * @returns 0-100 percentage
+ */
+export declare function calculateSegmentProgress(currentPosition: number, chapterStart: number, chapterEnd: number): number;
+/**
+ * Calculate buffer ranges within a chapter segment
+ * Converts global buffer ranges to segment-local 0-100 scale
+ */
+type SegmentBufferParams = {
+  globalBufferRanges: BufferRange[];
+  chapterStart: number;
+  chapterEnd: number;
+  videoDuration: number;
+};
+export declare function calculateSegmentBufferRanges({ globalBufferRanges, chapterStart, chapterEnd, videoDuration }: SegmentBufferParams): BufferRange[];
+/**
+ * Calculate flex grow ratio for a chapter based on its duration
+ */
+export declare function calculateFlexGrow(chapterDuration: number, videoDuration: number): number;
+/**
+ * Determine current playback position
+ * Uses progress during drag for real-time feedback, currentTime otherwise
+ */
+interface CurrentPositionParams {
+  isDragging: boolean;
+  progress: number;
+  duration: number;
+  currentTime: number;
+}
+export declare function getCurrentPosition({ isDragging, progress, duration, currentTime }: CurrentPositionParams): number;
+/**
+ * Find which segment is hovered based on mouse X position
+ * @param segments - Array of segment DOM elements
+ * @param mouseX - Mouse X coordinate (clientX)
+ * @returns Index of hovered segment, or null if none
+ */
+export declare function findHoveredSegmentIndex(segments: Array<HTMLDivElement | null>, mouseX: number): number | null;
+/**
+ * Start time of the first chapter after the current position, or null when
+ * already in the last chapter. Mirrors React useChapterNavigation.
+ */
+export declare function getNextChapterStart(chapters: Chapter[] | undefined, currentTime: number): number | null;
+/**
+ * Target for "previous chapter": restart the current chapter when more than
+ * 3s in (or when it is the first), otherwise jump to the previous chapter.
+ * Mirrors React useChapterNavigation.
+ */
+export declare function getPrevChapterTarget(chapters: Chapter[] | undefined, currentTime: number): number | null;
+interface BuildEngagementParams {
+  engagementType: string;
+  resourceType?: string;
+  resourceId?: string;
+  page?: string;
+  commentText?: string;
+  sharePlatform?: string;
+  country?: string;
+  deviceType?: string;
+  sessionId?: string;
+}
+interface BuildInteractionParams {
+  interactionType: string;
+  elementType?: string;
+  elementId?: string;
+  sessionId?: string;
+  page?: string;
+  pageUrl?: string;
+  scrollDepth?: number;
+  searchQuery?: string;
+  clickX?: number;
+  clickY?: number;
+  deviceType?: string;
+  browser?: string;
+  resourceId?: string;
+  resourceType?: string;
+  feedId?: string;
+  postId?: string;
+  contentId?: string;
+}
+interface BuildErrorParams {
+  errorType: string;
+  errorCode?: string;
+  errorMessage?: string;
+  stackTrace?: string;
+  resourceType?: string;
+  resourceId?: string;
+  endpoint?: string;
+  sessionId?: string;
+  deviceType?: string;
+  browser?: string;
+  os?: string;
+}
+interface BuildSessionStartParams {
+  browser?: string;
+  language?: string;
+  screenResolution?: string;
+  platform?: string;
+  tgPlatform?: string;
+  tgVersion?: string;
+  timezone?: string;
+  timezoneOffset?: number;
+  colorDepth?: number;
+  touchSupport?: boolean;
+  country?: string;
+  userId?: string;
+  utmSource?: string;
+  utmCampaign?: string;
+}
+export declare function postAnalytics(events: AnalyticsEvent[]): Promise<void>;
+export declare function postEngagement(params: BuildEngagementParams): void;
+export declare function postInteraction(params: BuildInteractionParams): void;
+export declare function postError(params: BuildErrorParams): void;
+/**
+ * Resolves once the events outstanding at call time have been sent, rather than
+ * once a flush has merely been started. Two paths used to return early: a call
+ * during an active flush reported a drain that had not happened, and a call
+ * while the only outstanding batch was already in flight (so the queue looked
+ * empty) returned before that request finished. Delegating to flushQueue makes
+ * it wait for whichever drain covers the outstanding work — starting one now,
+ * bypassing the timer, when nothing is running yet.
+ */
+export declare function flushAnalytics(): Promise<void>;
+interface VideoHeatmap {
+  video_id: string;
+  total_duration_ms: number;
+  data: number[];
+}
+interface GetVideoHeatmapOptions {
+  videoId: string;
+  buckets?: number;
+}
+export declare function getVideoHeatmap({ videoId, buckets }: GetVideoHeatmapOptions): Promise<VideoHeatmap | null>;
+/**
+ * Hot segment data for a video
+ * Represents a segment with higher-than-average viewership
+ */
+interface HotSegment {
+  start_second: number;
+  end_second: number;
+  multiplier: number;
+}
+interface GetHotSegmentsOptions {
+  videoId: string;
+  startDate?: string;
+  endDate?: string;
+}
+export declare function getHotSegments({ videoId, startDate, endDate }: GetHotSegmentsOptions): Promise<HotSegment[]>;
+interface VideoStats {
+  droppedFrames: number;
+  volume: number;
+  networkSpeed: number;
+  bufferHealth: number;
+  currentRes: {
+    width: number;
+    height: number;
+  } | null;
+  optimalRes: {
+    width: number;
+    height: number;
+  } | null;
+}
+interface CollectStatsInput {
+  video: HTMLVideoElement | null;
+  hlsBandwidthEstimate: number | null;
+  hlsLevels: ReadonlyArray<{
+    width: number;
+    height: number;
+  }>;
+  hlsCurrentLevel: number;
+  hlsAutoLevelEnabled: boolean;
+  hlsAutoLevelCapping: number;
+}
+export declare function getDroppedFrames(video: HTMLVideoElement): number;
+export declare function getBufferHealth(video: HTMLVideoElement): number;
+export declare function collectVideoStats(input: CollectStatsInput): VideoStats;
+export declare const LOOP_REBASE_BASE_MULTIPLIER = 2;
+export declare const LOOP_REBASE_THRESHOLD_MULTIPLIER = 50;
+export declare function shiftArray(arr: number[], shiftBy: number): number[];
+export declare function calcShiftCountArray(index: number, arraySize: number): number[];
+export declare function buildTransforms(currentIndex: number, originalPositions: number[]): number[];
+export declare function computeScrollIndex(scrollTop: number, containerHeight: number, gap?: number): number;
+export declare function isAtEndOfFeed(currentIndex: number, postsLength: number): boolean;
+export declare function isFeedExhausted(postsLength: number, total: number): boolean;
+interface ShouldFetchMoreInput {
+  currentIndex: number;
+  postsLength: number;
+  total: number;
+  isFetching: boolean;
+  isLoaded: boolean;
+}
+export declare function shouldFetchMore({ currentIndex, postsLength, total, isFetching, isLoaded }: ShouldFetchMoreInput): boolean;
+export declare function resolvePostIndex(transform: number, postsLength: number, loop: boolean): number;
+export declare function getLoopRebaseThreshold(postsLength: number): number;
+interface LoopRebaseInput {
+  currentIndex: number;
+  postsLength: number;
+  loop: boolean;
+  total: number;
+}
+export declare function shouldRebaseLoopIndex({ currentIndex, postsLength, loop, total }: LoopRebaseInput): boolean;
+export declare function getRebasedLoopIndex(currentIndex: number, postsLength: number): number;
+export declare const IMAGE_DWELL_MS = 5e3;
+export declare function shouldDwellAdvance(autoscroll: boolean, isCurrent: boolean, isImage: boolean): boolean;
+export declare function gateVideoEnded(isCurrent: boolean, autoscroll: boolean): boolean;
+interface AutoAdvanceInput {
+  isCurrent: boolean;
+  autoscroll: boolean;
+  loop: boolean;
+  currentIndex: number;
+  postsLength: number;
+  total: number;
+}
+export declare function shouldAutoAdvance({ isCurrent, autoscroll, loop, currentIndex, postsLength, total }: AutoAdvanceInput): boolean;
+export declare function getViewportFallbackHeight(safeAreaTabBar: number): number;
+interface ContainerHeightInput {
+  measuredHeight: number;
+  scrollContainerHeight: number;
+  safeAreaTabBar: number;
+}
+export declare function resolveContainerHeight({ measuredHeight, scrollContainerHeight, safeAreaTabBar }: ContainerHeightInput): number;
+export declare function checkIsCut(el: HTMLElement | null): boolean;
+export declare function connect(config: ConnectConfig): Promise<string | undefined>;
+interface CreateImageUploadOptions {
+  projectId: string;
+  orgId?: string;
+  name: string;
+}
+interface ImageUploadResult {
+  imageId: string;
+  uploadUrl: string;
+}
+export declare function createImageUpload(options: CreateImageUploadOptions): Promise<ImageUploadResult>;
+export declare function uploadImage(file: Blob | Uint8Array, options: CreateImageUploadOptions): Promise<ImageUploadResult>;
+interface CreateVideoUploadOptions {
+  projectId: string;
+  orgId?: string;
+  name: string;
+  videoQuality?: string;
+}
+interface VideoUploadResult {
+  videoId: string;
+  posterId: string;
+  videoUploadUrl: string;
+  posterUploadUrl: string;
+}
+export declare function createVideoUpload(options: CreateVideoUploadOptions): Promise<VideoUploadResult>;
+export declare function uploadVideo(videoFile: Blob | Uint8Array, posterFile: Blob | Uint8Array, options: CreateVideoUploadOptions): Promise<VideoUploadResult>;
+interface AudioTrackUploadItem {
+  languageCode: string;
+  label?: string;
+  fileName: string;
+  format: string;
+  size?: number;
+}
+interface AudioTrackUploadTarget {
+  id: string;
+  languageCode?: string;
+  uploadUrl?: string;
+}
+interface AudioTrackUploadResult {
+  targets: AudioTrackUploadTarget[];
+}
+export declare function createAudioTrackUpload(projectId: string, videoId: string, items: AudioTrackUploadItem[]): Promise<AudioTrackUploadResult>;
+interface SubtitleUploadItem {
+  languageCode: string;
+  label?: string;
+  fileName: string;
+  format: string;
+  size?: number;
+}
+interface SubtitleUploadTarget {
+  id: string;
+  languageCode?: string;
+  uploadUrl?: string;
+}
+interface SubtitleUploadResult {
+  targets: SubtitleUploadTarget[];
+}
+export declare function createSubtitleUpload(projectId: string, videoId: string, items: SubtitleUploadItem[]): Promise<SubtitleUploadResult>;
+interface CreatePostUploadOptions {
+  projectId: string;
+  feedId: string;
+  orgId?: string;
+  creatorId: string;
+  description?: string;
+  contentType: string;
+  fileName: string;
+  videoQuality?: string;
+}
+interface PostUploadResult {
+  postId: string;
+  contentId: string;
+  posterId: string;
+  contentUploadUrl: string;
+  posterUploadUrl: string;
+}
+export declare function uploadPost(contentFile: Blob | Uint8Array, posterFile: Blob | Uint8Array, options: CreatePostUploadOptions): Promise<PostUploadResult>;
+export declare function createPostUpload(options: CreatePostUploadOptions): Promise<PostUploadResult>;
+export type { AnalyticsContext, AnalyticsEvent, AppliedVolumeSync, AudioTrack, AudioTrackUploadItem, AudioTrackUploadResult, AuthConfig, AutoAdvanceInput, BufferRange, BuildEngagementParams, BuildErrorParams, BuildEventParams, BuildInteractionParams, BuildSessionStartParams, BuildVideoAnalyticsPayloadParams, CSSProperties, CalculateDragPositionOptions, CaptionLangType, CaptionTextSettings, CaptionWindowSettings, Chapter, ChapterWithEnd, ClickDisambiguationState, ClickOutsideOptions, CollectStatsInput, ConnectConfig, ContainerHeightInput, ContentType, ContentViewEvent, ControlsState, CreateImageUploadOptions, CreatePostUploadOptions, CreateVideoUploadOptions, DeriveVolumeSyncOptions, EngagementEvent, ErrorEvent, FeedPlaybackAction, FeedPlaybackDecisionInput, FeedPost, FeedPostsResponse, FileData, FileStatus, FontFamilyKey, GetHotSegmentsOptions, GetPointerOffsetsOptions, GetVideoHeatmapOptions, HandleClickOptions, HandleDoubleClickOptions, HlsController, HlsErrorAction, HlsErrorInput, HlsErrorPayload, HlsErrorRecoveryState, HlsInstance, HotSegment, ImageContainerStyleParams, ImageData, ImageRenderAction, ImageRenderState, ImageUploadResult, InteractionEvent, LoadingDebounceState, LoopRebaseInput, MenuKey, Page, PipReentryOptions, PlaybackHandlerCallbacks, PlaybackPointerOptions, PlayerControlLabels, PlayerLanguage, PlayerMenuLabels, PlayerState, PlayerStateStore, PointerOffsets, Position, PostStoreState, PostUploadResult, PosterDimensions, ProgressBarControls, ProgressBarProps, ProgressBarStartEvent, QualityLevel, Segment, SegmentAnalyticsParams, SessionStartEvent, SettingsState, SetupHlsOptions, ShortcutAction as ShortcutActionType, ShortcutDefinition, ShouldFetchMoreInput, SmartCaptionPositionParams, SubtitleTrack, SubtitleUploadItem, SubtitleUploadResult, UUID, UpdateLoadingStateOptions, VideoAnalyticsPayload, VideoData, VideoHeatmap, VideoKeyboardHandlers, VideoPreloadAttribute, VideoSdkKey, VideoSnapshot, VideoStats, VideoTheme, VideoUploadResult, ViewType, Viewport };