@xhub-short/adapters 0.1.0-beta.0

package/dist/index.d.ts

@@ -0,0 +1,1954 @@
+import { IDataSource, VideoItem, FeedResponse, ILogger, LogLevel, LogEntry, IStorage, ISessionStorage, SessionSnapshot, IInteraction, Comment, IAnalytics, AnalyticsEvent, INetworkAdapter, NetworkType, NetworkQuality, IVideoLoader, VideoSource, PreloadConfig, PreloadResult, PreloadStatus, IPosterLoader } from '@xhub-short/contracts';
+
+/**
+ * MockDataAdapter - Development/Testing Data Source
+ *
+ * Provides mock video data for development without requiring a backend API.
+ * Simulates pagination and network delay for realistic testing.
+ *
+ * @example
+ * ```typescript
+ * const mockAdapter = new MockDataAdapter({ delay: 500 });
+ * const feed = await mockAdapter.fetchFeed();
+ * ```
+ */
+declare class MockDataAdapter implements IDataSource {
+    private readonly videos;
+    private readonly pageSize;
+    private readonly delay;
+    constructor(options?: MockDataAdapterOptions);
+    /**
+     * Fetch a page of mock videos
+     */
+    fetchFeed(cursor?: string): Promise<FeedResponse>;
+    /**
+     * Get a single video by ID
+     */
+    getVideoDetail(id: string): Promise<VideoItem>;
+    /**
+     * Prefetch videos (no-op for mock)
+     */
+    prefetch(_ids: string[]): Promise<void>;
+    /**
+     * Simulate network delay
+     */
+    private simulateDelay;
+}
+/**
+ * Configuration options for MockDataAdapter
+ */
+interface MockDataAdapterOptions {
+    /** Custom mock video data */
+    videos?: VideoItem[];
+    /** Number of items per page (default: 3) */
+    pageSize?: number;
+    /** Simulated network delay in ms (default: 300) */
+    delay?: number;
+}
+
+/**
+ * Configuration options for MockLoggerAdapter
+ */
+interface MockLoggerAdapterOptions {
+    /** Maximum entries in circular buffer (default: 50 per ADD spec) */
+    bufferSize?: number;
+    /** Minimum log level to record (default: 'debug') */
+    minLevel?: LogLevel;
+    /** Whether to also output to console (default: false) */
+    consoleOutput?: boolean;
+}
+/**
+ * MockLoggerAdapter - In-memory ILogger implementation for testing
+ *
+ * Implements Circular Buffer pattern as specified in ADD.md Section 7.3:
+ * - Maintains buffer of last N log entries in RAM
+ * - Normal operation: Only write to buffer (silent)
+ * - On error: Flush buffer for context
+ *
+ * @example
+ * ```typescript
+ * const logger = new MockLoggerAdapter({ bufferSize: 50 });
+ * logger.info('User action', { videoId: '123' });
+ * logger.error('Failed to load', new Error('Network error'));
+ *
+ * // Get buffer for debugging
+ * const entries = logger.getBuffer();
+ * ```
+ *
+ * @see ILogger - Interface definition in @xhub-short/contracts
+ */
+declare class MockLoggerAdapter implements ILogger {
+    private buffer;
+    private readonly maxSize;
+    private readonly minLevel;
+    private readonly consoleOutput;
+    constructor(options?: MockLoggerAdapterOptions);
+    /**
+     * Log a single entry to the circular buffer
+     *
+     * @param entry - Log entry to record
+     */
+    log(entry: LogEntry): void;
+    /**
+     * Flush log entries (called on error for context)
+     *
+     * @param entries - Array of log entries to flush
+     */
+    flush(entries: LogEntry[]): void;
+    /**
+     * Log debug message
+     *
+     * @param message - Debug message
+     * @param context - Optional context data
+     */
+    debug(message: string, context?: Record<string, unknown>): void;
+    /**
+     * Log info message
+     *
+     * @param message - Info message
+     * @param context - Optional context data
+     */
+    info(message: string, context?: Record<string, unknown>): void;
+    /**
+     * Log warning message
+     *
+     * @param message - Warning message
+     * @param context - Optional context data
+     */
+    warn(message: string, context?: Record<string, unknown>): void;
+    /**
+     * Log error message
+     *
+     * @param message - Error message
+     * @param error - Optional Error object
+     * @param context - Optional context data
+     */
+    error(message: string, error?: Error, context?: Record<string, unknown>): void;
+    /**
+     * Get current buffer contents (for testing)
+     *
+     * @returns Copy of current log buffer
+     */
+    getBuffer(): LogEntry[];
+    /**
+     * Get buffer size (for testing)
+     *
+     * @returns Number of entries in buffer
+     */
+    getBufferSize(): number;
+    /**
+     * Clear the buffer (for testing)
+     */
+    clearBuffer(): void;
+    /**
+     * Get entries by level (for testing)
+     *
+     * @param level - Log level to filter by
+     * @returns Entries matching the level
+     */
+    getEntriesByLevel(level: LogLevel): LogEntry[];
+    /**
+     * Force flush and return buffer contents
+     *
+     * @returns All entries in buffer before clearing
+     */
+    forceFlush(): LogEntry[];
+    /**
+     * Output entry to console (when consoleOutput is enabled)
+     */
+    private outputToConsole;
+}
+
+/**
+ * Configuration options for MockStorageAdapter
+ */
+interface MockStorageAdapterOptions {
+    /** Initial data to populate storage */
+    initialData?: Record<string, unknown>;
+    /** Simulated delay in ms (default: 0) */
+    delay?: number;
+    /** Error rate for random failures (0-1) */
+    errorRate?: number;
+    /** Simulate QuotaExceededError on set operations */
+    simulateQuotaError?: boolean;
+}
+/**
+ * MockStorageAdapter - In-memory IStorage implementation for testing
+ *
+ * Simulates localStorage/sessionStorage behavior without persisting to disk.
+ * Supports configurable delays and error simulation for testing edge cases.
+ *
+ * @example
+ * ```typescript
+ * const storage = new MockStorageAdapter({ delay: 100 });
+ * await storage.set('key', { foo: 'bar' });
+ * const value = await storage.get('key');
+ * ```
+ *
+ * @see IStorage - Interface definition in @xhub-short/contracts
+ */
+declare class MockStorageAdapter implements IStorage {
+    protected store: Map<string, string>;
+    protected readonly delay: number;
+    protected readonly errorRate: number;
+    protected readonly simulateQuotaError: boolean;
+    constructor(options?: MockStorageAdapterOptions);
+    /**
+     * Get a value from storage
+     *
+     * @param key - Storage key
+     * @returns Promise resolving to the stored value or null if not found
+     */
+    get<T>(key: string): Promise<T | null>;
+    /**
+     * Set a value in storage
+     *
+     * @param key - Storage key
+     * @param value - Value to store (will be serialized)
+     * @throws DOMException if simulateQuotaError is enabled
+     */
+    set<T>(key: string, value: T): Promise<void>;
+    /**
+     * Remove a value from storage
+     *
+     * @param key - Storage key to remove
+     */
+    remove(key: string): Promise<void>;
+    /**
+     * Clear all SDK-related storage
+     */
+    clear(): Promise<void>;
+    /**
+     * Get all keys in storage
+     *
+     * @returns Promise resolving to array of storage keys
+     */
+    keys(): Promise<string[]>;
+    /**
+     * Get storage size (for testing)
+     *
+     * @returns Number of entries in storage
+     */
+    getSize(): number;
+    /**
+     * Check if key exists (for testing)
+     *
+     * @param key - Storage key to check
+     * @returns Whether key exists
+     */
+    has(key: string): boolean;
+    /**
+     * Get raw storage Map (for testing)
+     *
+     * @returns Copy of internal storage map
+     */
+    getRawStore(): Map<string, string>;
+    /**
+     * Simulate network/processing delay
+     */
+    protected simulateDelay(): Promise<void>;
+    /**
+     * Maybe throw error based on error rate
+     */
+    protected maybeThrowError(): void;
+}
+/**
+ * Configuration options for MockSessionStorageAdapter
+ */
+interface MockSessionStorageAdapterOptions extends MockStorageAdapterOptions {
+    /** Maximum age of snapshot in ms before considered stale (default: 24h) */
+    maxSnapshotAge?: number;
+}
+/**
+ * MockSessionStorageAdapter - ISessionStorage implementation for testing
+ *
+ * Extends MockStorageAdapter with session snapshot functionality.
+ * Used by LifecycleManager for state restoration.
+ *
+ * @example
+ * ```typescript
+ * const sessionStorage = new MockSessionStorageAdapter();
+ *
+ * // Save snapshot when user navigates away
+ * await sessionStorage.saveSnapshot({
+ *   currentVideoId: 'video-123',
+ *   timestamp: 30.5,
+ *   cursor: 'abc123',
+ *   currentIndex: 5,
+ *   savedAt: Date.now(),
+ * });
+ *
+ * // Restore snapshot when user returns
+ * const snapshot = await sessionStorage.loadSnapshot();
+ * ```
+ *
+ * @see ISessionStorage - Interface definition in @xhub-short/contracts
+ */
+declare class MockSessionStorageAdapter extends MockStorageAdapter implements ISessionStorage {
+    private readonly maxSnapshotAge;
+    constructor(options?: MockSessionStorageAdapterOptions);
+    /**
+     * Save session snapshot for state restoration
+     *
+     * @param snapshot - Session state to persist
+     */
+    saveSnapshot(snapshot: SessionSnapshot): Promise<void>;
+    /**
+     * Load the most recent session snapshot
+     *
+     * @returns Promise resolving to snapshot or null if none exists
+     */
+    loadSnapshot(): Promise<SessionSnapshot | null>;
+    /**
+     * Clear session snapshot
+     */
+    clearSnapshot(): Promise<void>;
+    /**
+     * Check if snapshot exists (for testing)
+     *
+     * @returns Whether snapshot exists
+     */
+    hasSnapshot(): boolean;
+    /**
+     * Get snapshot age in ms (for testing)
+     *
+     * @returns Age in ms or null if no snapshot
+     */
+    getSnapshotAge(): Promise<number | null>;
+}
+
+/**
+ * Configuration options for MockInteractionAdapter
+ */
+interface MockInteractionAdapterOptions {
+    /** Simulated delay in ms (default: 0) */
+    delay?: number;
+    /** Error rate for random failures (0-1) */
+    errorRate?: number;
+    /** Force like operations to fail (for rollback testing) */
+    failLike?: boolean;
+    /** Force unlike operations to fail */
+    failUnlike?: boolean;
+    /** Force follow operations to fail */
+    failFollow?: boolean;
+    /** Force unfollow operations to fail */
+    failUnfollow?: boolean;
+    /** Force comment operations to fail */
+    failComment?: boolean;
+    /** Force deleteComment operations to fail */
+    failDeleteComment?: boolean;
+    /** Initial liked video IDs */
+    initialLikedVideos?: string[];
+    /** Initial followed author IDs */
+    initialFollowedAuthors?: string[];
+    /** Initial liked comment IDs */
+    initialLikedComments?: string[];
+}
+/**
+ * MockInteractionAdapter - In-memory IInteraction implementation for testing
+ *
+ * Provides mock implementations for all user interaction methods.
+ * Tracks state changes in-memory for verification in tests.
+ * Supports error simulation for testing optimistic UI rollback.
+ *
+ * @example
+ * ```typescript
+ * const interaction = new MockInteractionAdapter({ delay: 100 });
+ *
+ * // Simulate like action
+ * await interaction.like('video-123');
+ * console.log(interaction.isVideoLiked('video-123')); // true
+ *
+ * // Test rollback scenario
+ * const failingInteraction = new MockInteractionAdapter({ failLike: true });
+ * await failingInteraction.like('video-123'); // throws Error
+ * ```
+ *
+ * @see IInteraction - Interface definition in @xhub-short/contracts
+ */
+declare class MockInteractionAdapter implements IInteraction {
+    private readonly likedVideos;
+    private readonly followedAuthors;
+    private readonly likedComments;
+    private readonly comments;
+    private readonly delay;
+    private readonly errorRate;
+    private readonly failLike;
+    private readonly failUnlike;
+    private readonly failFollow;
+    private readonly failUnfollow;
+    private readonly failComment;
+    private readonly failDeleteComment;
+    constructor(options?: MockInteractionAdapterOptions);
+    /**
+     * Like a video
+     *
+     * @param videoId - ID of the video to like
+     * @throws Error if failLike is enabled or random error occurs
+     */
+    like(videoId: string): Promise<void>;
+    /**
+     * Remove like from a video
+     *
+     * @param videoId - ID of the video to unlike
+     * @throws Error if failUnlike is enabled or random error occurs
+     */
+    unlike(videoId: string): Promise<void>;
+    /**
+     * Follow a video author
+     *
+     * @param authorId - ID of the author to follow
+     * @throws Error if failFollow is enabled or random error occurs
+     */
+    follow(authorId: string): Promise<void>;
+    /**
+     * Unfollow a video author
+     *
+     * @param authorId - ID of the author to unfollow
+     * @throws Error if failUnfollow is enabled or random error occurs
+     */
+    unfollow(authorId: string): Promise<void>;
+    /**
+     * Post a comment on a video
+     *
+     * @param _videoId - ID of the video to comment on (unused in mock)
+     * @param text - Comment text content
+     * @returns Promise resolving to the created comment
+     * @throws Error if failComment is enabled or random error occurs
+     */
+    comment(_videoId: string, text: string): Promise<Comment>;
+    /**
+     * Delete a comment
+     *
+     * @param commentId - ID of the comment to delete
+     * @throws Error if comment not found, failDeleteComment is enabled, or random error occurs
+     */
+    deleteComment(commentId: string): Promise<void>;
+    /**
+     * Like a comment
+     *
+     * @param commentId - ID of the comment to like
+     */
+    likeComment(commentId: string): Promise<void>;
+    /**
+     * Unlike a comment
+     *
+     * @param commentId - ID of the comment to unlike
+     */
+    unlikeComment(commentId: string): Promise<void>;
+    /**
+     * Share a video (tracking only)
+     *
+     * @param _videoId - ID of the video being shared
+     * @param _platform - Optional platform identifier
+     */
+    share(_videoId: string, _platform?: string): Promise<void>;
+    /**
+     * Report a video
+     *
+     * @param _videoId - ID of the video to report
+     * @param _reason - Report reason code
+     * @param _description - Optional additional description
+     */
+    report(_videoId: string, _reason: string, _description?: string): Promise<void>;
+    /**
+     * Check if video is liked (for testing)
+     *
+     * @param videoId - Video ID to check
+     * @returns Whether video is liked
+     */
+    isVideoLiked(videoId: string): boolean;
+    /**
+     * Check if author is followed (for testing)
+     *
+     * @param authorId - Author ID to check
+     * @returns Whether author is followed
+     */
+    isAuthorFollowed(authorId: string): boolean;
+    /**
+     * Check if comment is liked (for testing)
+     *
+     * @param commentId - Comment ID to check
+     * @returns Whether comment is liked
+     */
+    isCommentLiked(commentId: string): boolean;
+    /**
+     * Get all liked video IDs (for testing)
+     *
+     * @returns Array of liked video IDs
+     */
+    getLikedVideos(): string[];
+    /**
+     * Get all followed author IDs (for testing)
+     *
+     * @returns Array of followed author IDs
+     */
+    getFollowedAuthors(): string[];
+    /**
+     * Get all comments (for testing)
+     *
+     * @returns Map of comment ID to Comment
+     */
+    getComments(): Map<string, Comment>;
+    /**
+     * Get a specific comment (for testing)
+     *
+     * @param commentId - Comment ID
+     * @returns Comment or undefined
+     */
+    getComment(commentId: string): Comment | undefined;
+    /**
+     * Reset all state (for testing)
+     */
+    reset(): void;
+    /**
+     * Simulate network/processing delay
+     */
+    private simulateDelay;
+    /**
+     * Maybe throw error based on error rate
+     */
+    private maybeThrowError;
+}
+
+/**
+ * Configuration options for MockAnalyticsAdapter
+ */
+interface MockAnalyticsAdapterOptions {
+    /** Batch size threshold for auto-flush (default: 10) */
+    batchSize?: number;
+    /** Whether to auto-flush when batch size is reached (default: false) */
+    autoFlush?: boolean;
+    /** Simulated delay for flush in ms (default: 0) */
+    flushDelay?: number;
+    /** Error rate for flush failures (0-1) */
+    errorRate?: number;
+}
+/**
+ * MockAnalyticsAdapter - In-memory IAnalytics implementation for testing
+ *
+ * Provides mock implementations for analytics tracking with event queue batching.
+ * Events are stored in-memory for verification in tests.
+ *
+ * Batching Strategy (per ADD spec):
+ * 1. Events are pushed to internal queue via track()
+ * 2. Auto-flush conditions (when autoFlush enabled):
+ *    - Queue >= batchSize items
+ * 3. Manual flush via flush() method
+ *
+ * @example
+ * ```typescript
+ * const analytics = new MockAnalyticsAdapter({ batchSize: 10, autoFlush: true });
+ *
+ * // Track events
+ * analytics.track({ type: 'video_view', videoId: '123', timestamp: Date.now() });
+ *
+ * // Get tracked events for verification
+ * const events = analytics.getTrackedEvents();
+ *
+ * // Manual flush
+ * await analytics.flush();
+ * ```
+ *
+ * @see IAnalytics - Interface definition in @xhub-short/contracts
+ */
+declare class MockAnalyticsAdapter implements IAnalytics {
+    private eventQueue;
+    private flushedEvents;
+    private userId;
+    private userProperties;
+    private readonly batchSize;
+    private readonly autoFlush;
+    private readonly flushDelay;
+    private readonly errorRate;
+    constructor(options?: MockAnalyticsAdapterOptions);
+    /**
+     * Track an analytics event
+     *
+     * @param event - Event to track
+     */
+    track(event: AnalyticsEvent): void;
+    /**
+     * Flush queued events immediately
+     *
+     * @returns Promise that resolves when flush is complete
+     */
+    flush(): Promise<void>;
+    /**
+     * Track video view duration
+     *
+     * @param videoId - ID of the video
+     * @param duration - Watch duration in seconds
+     * @param totalDuration - Total video duration in seconds
+     */
+    trackViewDuration(videoId: string, duration: number, totalDuration: number): void;
+    /**
+     * Track video completion
+     *
+     * @param videoId - ID of the video
+     * @param watchTime - Total time watched in seconds
+     * @param loops - Number of times video looped
+     */
+    trackCompletion(videoId: string, watchTime: number, loops: number): void;
+    /**
+     * Set user context for analytics
+     *
+     * @param userId - Optional user ID (null for anonymous)
+     * @param properties - Optional user properties
+     */
+    setUser(userId: string | null, properties?: Record<string, unknown>): void;
+    /**
+     * Get current queue size
+     *
+     * @returns Number of events in queue
+     */
+    getQueueSize(): number;
+    /**
+     * Get all tracked events (current queue)
+     *
+     * @returns Copy of current event queue
+     */
+    getTrackedEvents(): AnalyticsEvent[];
+    /**
+     * Get all flushed event batches
+     *
+     * @returns Array of flushed event batches
+     */
+    getFlushedBatches(): AnalyticsEvent[][];
+    /**
+     * Get total flushed events count
+     *
+     * @returns Total number of flushed events
+     */
+    getTotalFlushedCount(): number;
+    /**
+     * Get events by type (from current queue)
+     *
+     * @param type - Event type to filter by
+     * @returns Events matching the type
+     */
+    getEventsByType(type: AnalyticsEvent['type']): AnalyticsEvent[];
+    /**
+     * Get events for a specific video (from current queue)
+     *
+     * @param videoId - Video ID to filter by
+     * @returns Events for the video
+     */
+    getEventsByVideoId(videoId: string): AnalyticsEvent[];
+    /**
+     * Get current user context
+     *
+     * @returns User ID and properties
+     */
+    getUserContext(): {
+        userId: string | null;
+        properties: Record<string, unknown>;
+    };
+    /**
+     * Check if specific event type was tracked
+     *
+     * @param type - Event type to check
+     * @returns Whether event type was tracked
+     */
+    hasTracked(type: AnalyticsEvent['type']): boolean;
+    /**
+     * Get last tracked event
+     *
+     * @returns Last event or undefined
+     */
+    getLastEvent(): AnalyticsEvent | undefined;
+    /**
+     * Reset all state
+     */
+    reset(): void;
+    /**
+     * Clear only the event queue (keep flushed history)
+     */
+    clearQueue(): void;
+}
+
+/**
+ * Mock Network Adapter
+ *
+ * Simulates network detection for testing and development.
+ * Can be configured with initial network type and simulate network changes.
+ */
+
+/**
+ * Configuration options for MockNetworkAdapter
+ */
+interface MockNetworkAdapterOptions {
+    /** Initial network type (default: 'wifi') */
+    initialType?: NetworkType;
+    /** Initial downlink speed in Mbps (default: 10) */
+    initialDownlink?: number;
+    /** Initial RTT in ms (default: 50) */
+    initialRtt?: number;
+    /** Whether network is metered (default: false) */
+    isMetered?: boolean;
+    /** Whether initially online (default: true) */
+    isOnline?: boolean;
+}
+/**
+ * Mock implementation of INetworkAdapter
+ *
+ * Useful for:
+ * - Unit testing network-dependent logic
+ * - Development without real network APIs
+ * - Simulating various network conditions
+ *
+ * @example
+ * ```typescript
+ * const adapter = new MockNetworkAdapter({ initialType: 'cellular' });
+ *
+ * // Simulate network change
+ * adapter.setNetworkType('wifi');
+ *
+ * // Test slow network
+ * adapter.setNetworkType('slow');
+ * adapter.setDownlink(0.5);
+ * ```
+ */
+declare class MockNetworkAdapter implements INetworkAdapter {
+    private currentType;
+    private downlink;
+    private rtt;
+    private metered;
+    private online;
+    private listeners;
+    constructor(options?: MockNetworkAdapterOptions);
+    getNetworkType(): Promise<NetworkType>;
+    getNetworkQuality(): Promise<NetworkQuality>;
+    onNetworkChange(callback: (type: NetworkType) => void): () => void;
+    isOnline(): Promise<boolean>;
+    /**
+     * Set network type and notify listeners
+     */
+    setNetworkType(type: NetworkType): void;
+    /**
+     * Set downlink speed in Mbps
+     */
+    setDownlink(mbps: number): void;
+    /**
+     * Set RTT in milliseconds
+     */
+    setRtt(ms: number): void;
+    /**
+     * Set metered status (e.g., cellular data)
+     */
+    setMetered(metered: boolean): void;
+    /**
+     * Set online/offline status
+     */
+    setOnline(online: boolean): void;
+    /**
+     * Simulate network change sequence for testing
+     */
+    simulateNetworkChanges(sequence: NetworkType[], delayMs?: number): Promise<void>;
+    /**
+     * Reset to default state
+     */
+    reset(): void;
+    private notifyListeners;
+}
+
+/**
+ * Mock Video Loader
+ *
+ * Simulates video preloading for testing and development.
+ * Does not actually load video data, just tracks preload state.
+ */
+
+/**
+ * Configuration options for MockVideoLoader
+ */
+interface MockVideoLoaderOptions {
+    /** Simulated preload delay in ms (default: 100) */
+    preloadDelayMs?: number;
+    /** Whether preloads should succeed (default: true) */
+    shouldSucceed?: boolean;
+    /** Error message for failed preloads */
+    errorMessage?: string;
+    /** Simulated bytes per preload (default: 500000 = 500KB) */
+    bytesPerPreload?: number;
+}
+/**
+ * Tracked preload state
+ */
+interface PreloadState {
+    status: PreloadStatus;
+    loadedBytes: number;
+    error?: Error;
+    abortController?: AbortController;
+}
+/**
+ * Mock implementation of IVideoLoader
+ *
+ * Useful for:
+ * - Unit testing ResourceGovernor logic
+ * - Development without real video loading
+ * - Simulating various preload scenarios
+ *
+ * @example
+ * ```typescript
+ * const loader = new MockVideoLoader({ preloadDelayMs: 50 });
+ *
+ * await loader.preload('video-1', { url: '...', type: 'mp4' });
+ * expect(loader.isPreloaded('video-1')).toBe(true);
+ *
+ * // Simulate failure
+ * loader.setShouldSucceed(false);
+ * ```
+ */
+declare class MockVideoLoader implements IVideoLoader {
+    private preloads;
+    private preloadDelayMs;
+    private shouldSucceed;
+    private errorMessage;
+    private bytesPerPreload;
+    constructor(options?: MockVideoLoaderOptions);
+    preload(_videoId: string, _source: VideoSource, _config?: PreloadConfig): Promise<PreloadResult>;
+    cancelPreload(videoId: string): void;
+    isPreloaded(videoId: string): boolean;
+    getPreloadStatus(videoId: string): PreloadStatus;
+    clearPreload(videoId: string): void;
+    clearAll(): void;
+    getTotalPreloadedBytes(): number;
+    /**
+     * Set whether preloads should succeed
+     */
+    setShouldSucceed(shouldSucceed: boolean): void;
+    /**
+     * Set preload delay in milliseconds
+     */
+    setPreloadDelay(ms: number): void;
+    /**
+     * Set error message for failed preloads
+     */
+    setErrorMessage(message: string): void;
+    /**
+     * Get all tracked preloads (for testing assertions)
+     */
+    getPreloads(): Map<string, PreloadState>;
+    /**
+     * Reset all state
+     */
+    reset(): void;
+}
+/**
+ * Mock implementation of IPosterLoader
+ *
+ * Separate class for poster preloading to match interface contracts
+ */
+declare class MockPosterLoader implements IPosterLoader {
+    private posterCache;
+    private preloadDelayMs;
+    constructor(preloadDelayMs?: number);
+    preload(url: string): Promise<void>;
+    isCached(url: string): boolean;
+    clearCache(): void;
+    /**
+     * Set preload delay in milliseconds
+     */
+    setPreloadDelay(ms: number): void;
+    /**
+     * Reset all state
+     */
+    reset(): void;
+}
+
+/**
+ * Preset Adapters - Type Definitions
+ *
+ * Types cho REST Preset Adapter factory
+ * Cho phép Host App chỉ cần config thay vì viết adapter từ đầu
+ */
+
+/**
+ * Authentication configuration
+ */
+interface AuthConfig {
+    /**
+     * Get current access token
+     * Return null if not logged in
+     */
+    getAccessToken: () => string | null | Promise<string | null>;
+    /**
+     * Refresh token when access token expires
+     * Return new access token
+     * Throw error if refresh fails
+     */
+    refreshToken?: () => Promise<string>;
+    /**
+     * Callback when auth fails completely (after refresh also fails)
+     * Usually used to redirect to login page
+     */
+    onAuthError?: (error: AuthError) => void;
+    /**
+     * Custom headers for all requests
+     * Example: { 'X-App-Version': '1.0.0' }
+     */
+    headers?: Record<string, string>;
+    /**
+     * Token header name
+     * @default 'Authorization'
+     */
+    tokenHeader?: string;
+    /**
+     * Token prefix in header
+     * @default 'Bearer'
+     * Set '' if no prefix needed
+     */
+    tokenPrefix?: string;
+}
+/**
+ * Auth error information
+ */
+interface AuthError {
+    status: number;
+    message: string;
+    originalError?: Error;
+}
+/**
+ * REST endpoint mapping
+ */
+interface RESTEndpointMap {
+    /**
+     * Feed-related endpoints
+     */
+    feed: {
+        /**
+         * GET endpoint for listing videos
+         * Query params auto-added: cursor, limit
+         * Example: '/videos', '/reels', '/shorts'
+         */
+        list: string;
+        /**
+         * GET endpoint for video detail
+         * :id will be replaced with video ID
+         * Example: '/videos/:id', '/reels/:id'
+         */
+        detail: string;
+    };
+    /**
+     * Interaction endpoints
+     */
+    interaction: {
+        /** POST /videos/:id/like */
+        like: string;
+        /** DELETE /videos/:id/like */
+        unlike: string;
+        /** POST /users/:id/follow */
+        follow: string;
+        /** DELETE /users/:id/follow */
+        unfollow: string;
+        /** POST /videos/:id/comments */
+        comment: string;
+        /** DELETE /comments/:id */
+        deleteComment: string;
+        /** POST /videos/:id/share (optional) */
+        share?: string;
+    };
+    /**
+     * Analytics endpoints (optional)
+     * If not provided, analytics adapter will be no-op
+     */
+    analytics?: {
+        /** POST endpoint for batch events */
+        batch: string;
+    };
+}
+/**
+ * HTTP request configuration
+ */
+interface RESTRequestConfig {
+    /**
+     * Default query params for all requests
+     * Example: { app_id: 'my-app', version: '2' }
+     */
+    defaultParams?: Record<string, string>;
+    /**
+     * Request timeout in milliseconds
+     * @default 10000 (10s)
+     */
+    timeout?: number;
+    /**
+     * Retry configuration
+     */
+    retry?: RetryConfig;
+    /**
+     * Pagination param names
+     * @default { cursor: 'cursor', limit: 'limit' }
+     */
+    pagination?: {
+        cursor: string;
+        limit: string;
+    };
+}
+/**
+ * Retry configuration
+ */
+interface RetryConfig {
+    /**
+     * Max retry attempts
+     * @default 3
+     */
+    maxRetries: number;
+    /**
+     * Delay between retries (ms)
+     * @default 1000
+     */
+    retryDelay: number;
+    /**
+     * HTTP status codes to retry on
+     * @default [408, 429, 500, 502, 503, 504]
+     */
+    retryOn: number[];
+    /**
+     * Use exponential backoff
+     * @default true
+     */
+    exponentialBackoff?: boolean;
+}
+/**
+ * Response transform configuration
+ */
+interface TransformConfig {
+    /**
+     * Transform single video item from API response
+     * If not provided, uses default transform
+     */
+    videoItem?: (apiResponse: unknown) => VideoItem;
+    /**
+     * Transform feed response from API
+     * If not provided, uses default transform
+     */
+    feedResponse?: (apiResponse: unknown) => {
+        items: unknown[];
+        nextCursor: string | null;
+        hasMore: boolean;
+    };
+    /**
+     * Field mapping for default transforms
+     * Used when API field names differ from defaults
+     */
+    fieldMap?: FieldMapConfig;
+}
+/**
+ * Field mapping configuration for auto-transform
+ */
+interface FieldMapConfig {
+    /**
+     * VideoItem field mapping
+     * Key: SDK field path, Value: API field path (dot notation)
+     * Example: { 'author.name': 'creator.display_name' }
+     */
+    video?: Record<string, string>;
+    /**
+     * FeedResponse field mapping
+     */
+    feed?: {
+        items?: string;
+        nextCursor?: string;
+        hasMore?: string;
+    };
+}
+/**
+ * REST Preset Adapter configuration
+ */
+interface RESTPresetConfig {
+    /**
+     * Base URL for all API requests
+     * Example: 'https://api.myapp.com/v1'
+     */
+    baseUrl: string;
+    /**
+     * Auth configuration
+     */
+    auth: AuthConfig;
+    /**
+     * Endpoint mapping
+     */
+    endpoints: RESTEndpointMap;
+    /**
+     * Response transforms (optional)
+     * If not provided, uses default transforms
+     */
+    transforms?: TransformConfig;
+    /**
+     * Request configuration (optional)
+     */
+    request?: RESTRequestConfig;
+    /**
+     * Logger adapter for error/warning logging
+     * If not provided, uses console in dev, silent in prod
+     */
+    logger?: ILogger;
+}
+/**
+ * Factory output - all preset adapters
+ */
+interface PresetAdapters {
+    dataSource: IDataSource;
+    interaction: IInteraction;
+    analytics: IAnalytics;
+}
+/**
+ * HTTP request options (internal)
+ */
+interface HttpRequestOptions {
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+    path: string;
+    params?: Record<string, string | number | null | undefined>;
+    body?: unknown;
+    pathParams?: Record<string, string>;
+}
+/**
+ * Default retry config
+ */
+declare const DEFAULT_RETRY_CONFIG: Required<RetryConfig>;
+/**
+ * Default request config
+ */
+declare const DEFAULT_REQUEST_CONFIG: Required<RESTRequestConfig>;
+
+/**
+ * createRESTAdapters - Factory function for REST preset adapters
+ *
+ * Tạo bộ adapters hoàn chỉnh từ config đơn giản.
+ * Host App chỉ cần cung cấp baseUrl, auth, và endpoint mapping.
+ *
+ * @example
+ * ```typescript
+ * import { createRESTAdapters } from '@xhub-short/adapters/preset';
+ *
+ * const adapters = createRESTAdapters({
+ *   baseUrl: 'https://api.myapp.com/v1',
+ *   auth: {
+ *     getAccessToken: () => localStorage.getItem('token'),
+ *     refreshToken: async () => {
+ *       const res = await fetch('/auth/refresh', { method: 'POST' });
+ *       const { token } = await res.json();
+ *       return token;
+ *     },
+ *   },
+ *   endpoints: {
+ *     feed: { list: '/videos', detail: '/videos/:id' },
+ *     interaction: {
+ *       like: '/videos/:id/like',
+ *       unlike: '/videos/:id/like',
+ *       follow: '/users/:id/follow',
+ *       unfollow: '/users/:id/follow',
+ *       comment: '/videos/:id/comments',
+ *       deleteComment: '/comments/:id',
+ *     },
+ *   },
+ * });
+ *
+ * const sdk = createSDK({ adapters });
+ * ```
+ */
+
+/**
+ * Create REST preset adapters from config
+ *
+ * @param config - REST preset configuration
+ * @returns Object containing dataSource, interaction, and analytics adapters
+ */
+declare function createRESTAdapters(config: RESTPresetConfig): PresetAdapters;
+
+/**
+ * Browser Video Loader - Real video preloading implementation
+ *
+ * Preloads video data using appropriate strategy:
+ * - MP4: Fetch with Range header (first N bytes)
+ * - HLS: Load manifest + first segment (if hls.js available)
+ *
+ * Uses browser's Cache API for storage when available.
+ */
+
+/**
+ * Configuration for BrowserVideoLoader
+ */
+interface BrowserVideoLoaderConfig {
+    /** Logger for debugging */
+    logger?: ILogger;
+    /** Default max bytes to preload for MP4 (default: 512KB) */
+    defaultMaxBytes?: number;
+    /** Default timeout in ms (default: 10000) */
+    defaultTimeout?: number;
+    /** Use Cache API when available (default: true) */
+    useCache?: boolean;
+    /** Cache name for stored video chunks (default: 'sv-video-cache') */
+    cacheName?: string;
+}
+/**
+ * BrowserVideoLoader - Real browser video preloading
+ *
+ * Strategies:
+ * - **MP4:** Fetch first chunk (500KB-1MB) via Range request
+ * - **HLS:** Not implemented (requires hls.js injection)
+ * - **Native HLS (Safari):** Falls back to standard preload
+ *
+ * @example
+ * ```typescript
+ * const loader = new BrowserVideoLoader();
+ *
+ * // Preload next video
+ * const result = await loader.preload('video-123', {
+ *   url: 'https://example.com/video.mp4',
+ *   type: 'mp4',
+ * });
+ *
+ * console.log(result.status); // 'ready'
+ * console.log(result.loadedBytes); // 524288 (512KB)
+ * ```
+ */
+declare class BrowserVideoLoader implements IVideoLoader {
+    private readonly logger?;
+    private readonly config;
+    private readonly preloads;
+    private cache;
+    constructor(config?: BrowserVideoLoaderConfig);
+    /**
+     * Initialize Cache API
+     */
+    private initCache;
+    /**
+     * Preload video source
+     */
+    preload(videoId: string, source: VideoSource, config?: PreloadConfig): Promise<PreloadResult>;
+    /**
+     * Preload MP4 video using Range request
+     */
+    private preloadMP4;
+    /**
+     * Preload HLS - fetch manifest only
+     * Full segment preload requires hls.js which is optional
+     */
+    private preloadHLS;
+    /**
+     * Cancel preload
+     */
+    cancelPreload(videoId: string): void;
+    /**
+     * Check if video is preloaded
+     */
+    isPreloaded(videoId: string): boolean;
+    /**
+     * Get preload status
+     */
+    getPreloadStatus(videoId: string): PreloadStatus;
+    /**
+     * Clear preloaded data for a video
+     */
+    clearPreload(videoId: string): void;
+    /**
+     * Clear all preloaded data
+     */
+    clearAll(): void;
+    /**
+     * Get total preloaded bytes
+     */
+    getTotalPreloadedBytes(): number;
+}
+/**
+ * BrowserPosterLoader - Browser image preloading
+ *
+ * Uses Image object for preloading poster/thumbnail images.
+ * Simple and effective for warming browser cache.
+ *
+ * @example
+ * ```typescript
+ * const posterLoader = new BrowserPosterLoader();
+ *
+ * await posterLoader.preload('https://example.com/thumb.jpg');
+ * console.log(posterLoader.isCached('https://example.com/thumb.jpg')); // true
+ * ```
+ */
+declare class BrowserPosterLoader implements IPosterLoader {
+    private readonly logger?;
+    private readonly cache;
+    private readonly pending;
+    private readonly timeout;
+    constructor(config?: {
+        logger?: ILogger;
+        timeout?: number;
+    });
+    /**
+     * Preload a poster image
+     */
+    preload(url: string): Promise<void>;
+    /**
+     * Check if poster is cached
+     */
+    isCached(url: string): boolean;
+    /**
+     * Clear poster cache
+     */
+    clearCache(): void;
+}
+/**
+ * Create browser video loader with default config
+ */
+declare function createBrowserVideoLoader(config?: BrowserVideoLoaderConfig): BrowserVideoLoader;
+/**
+ * Create browser poster loader with default config
+ */
+declare function createBrowserPosterLoader(config?: {
+    logger?: ILogger;
+    timeout?: number;
+}): BrowserPosterLoader;
+
+/**
+ * LocalStorage Adapter - Browser localStorage implementation
+ *
+ * Real implementation of ISessionStorage using browser localStorage.
+ * Automatically handles JSON serialization and SDK namespacing.
+ */
+
+/**
+ * Configuration for LocalStorageAdapter
+ */
+interface LocalStorageConfig {
+    /** Storage key prefix for namespacing (default: 'sv-') */
+    prefix?: string;
+    /** Maximum age of snapshot in ms (default: 24h) */
+    maxSnapshotAge?: number;
+    /** Logger for debugging */
+    logger?: ILogger;
+}
+/**
+ * LocalStorageAdapter - Real browser localStorage implementation
+ *
+ * Features:
+ * - Auto JSON serialization/deserialization
+ * - SDK key namespacing (avoids conflicts with host app)
+ * - Graceful error handling (returns null instead of throwing)
+ * - Session snapshot with automatic staleness checking
+ *
+ * @example
+ * ```typescript
+ * const storage = new LocalStorageAdapter({ prefix: 'myapp-' });
+ *
+ * await storage.set('user', { id: '123', name: 'John' });
+ * const user = await storage.get('user');
+ * ```
+ */
+declare class LocalStorageAdapter implements IStorage {
+    protected readonly prefix: string;
+    protected readonly logger?: ILogger;
+    constructor(config?: LocalStorageConfig);
+    /**
+     * Build namespaced key
+     */
+    protected buildKey(key: string): string;
+    /**
+     * Get a value from localStorage
+     */
+    get<T>(key: string): Promise<T | null>;
+    /**
+     * Set a value in localStorage
+     */
+    set<T>(key: string, value: T): Promise<void>;
+    /**
+     * Remove a value from localStorage
+     */
+    remove(key: string): Promise<void>;
+    /**
+     * Clear all SDK-namespaced keys
+     */
+    clear(): Promise<void>;
+    /**
+     * Get all SDK-namespaced keys
+     */
+    keys(): Promise<string[]>;
+    /**
+     * Clear old entries when quota exceeded (simple LRU-like behavior)
+     */
+    private clearOldEntries;
+}
+/**
+ * LocalSessionStorageAdapter - ISessionStorage implementation
+ *
+ * Extends LocalStorageAdapter with session snapshot methods.
+ * Used by LifecycleManager for state restoration.
+ *
+ * @example
+ * ```typescript
+ * const sessionStorage = new LocalSessionStorageAdapter();
+ *
+ * // Save snapshot when user leaves
+ * await sessionStorage.saveSnapshot({
+ *   currentIndex: 5,
+ *   cursor: 'abc123',
+ *   savedAt: Date.now(),
+ * });
+ *
+ * // Restore when user returns
+ * const snapshot = await sessionStorage.loadSnapshot();
+ * if (snapshot) {
+ *   // Restore state
+ * }
+ * ```
+ */
+declare class LocalSessionStorageAdapter extends LocalStorageAdapter implements ISessionStorage {
+    private readonly maxSnapshotAge;
+    constructor(config?: LocalStorageConfig);
+    /**
+     * Save session snapshot
+     */
+    saveSnapshot(snapshot: SessionSnapshot): Promise<void>;
+    /**
+     * Load session snapshot (returns null if stale)
+     */
+    loadSnapshot(): Promise<SessionSnapshot | null>;
+    /**
+     * Clear session snapshot
+     */
+    clearSnapshot(): Promise<void>;
+}
+/**
+ * Create localStorage adapter with default config
+ */
+declare function createLocalStorageAdapter(config?: LocalStorageConfig): LocalStorageAdapter;
+/**
+ * Create session storage adapter with default config
+ */
+declare function createSessionStorageAdapter(config?: LocalStorageConfig): LocalSessionStorageAdapter;
+
+/**
+ * Web Network Adapter - Browser Navigator.connection implementation
+ *
+ * Real implementation of INetworkAdapter using Web APIs.
+ * Provides network detection with fallbacks for browsers without Network Information API.
+ */
+
+/**
+ * Configuration for WebNetworkAdapter
+ */
+interface WebNetworkConfig {
+    /** Logger for debugging */
+    logger?: ILogger;
+    /** Fallback network type when API not available (default: 'wifi') */
+    fallbackType?: NetworkType;
+    /** Fallback downlink in Mbps (default: 10) */
+    fallbackDownlink?: number;
+}
+/**
+ * WebNetworkAdapter - Browser Network Information API implementation
+ *
+ * Features:
+ * - Uses Navigator.connection when available
+ * - Graceful fallback for unsupported browsers
+ * - Online/offline detection via navigator.onLine
+ * - Network change listeners via connection.onchange
+ *
+ * @example
+ * ```typescript
+ * const network = new WebNetworkAdapter();
+ *
+ * const type = await network.getNetworkType();
+ * console.log('Network:', type); // 'wifi', '4g', 'offline', etc.
+ *
+ * // Listen for changes
+ * const unsubscribe = network.onNetworkChange((type) => {
+ *   console.log('Network changed to:', type);
+ * });
+ * ```
+ */
+declare class WebNetworkAdapter implements INetworkAdapter {
+    private readonly logger?;
+    private readonly fallbackType;
+    private readonly fallbackDownlink;
+    private readonly listeners;
+    private connection;
+    private boundOnlineHandler;
+    private boundOfflineHandler;
+    private boundChangeHandler;
+    constructor(config?: WebNetworkConfig);
+    /**
+     * Get current network type
+     */
+    getNetworkType(): Promise<NetworkType>;
+    /**
+     * Get detailed network quality
+     */
+    getNetworkQuality(): Promise<NetworkQuality>;
+    /**
+     * Subscribe to network changes
+     */
+    onNetworkChange(callback: (type: NetworkType) => void): () => void;
+    /**
+     * Check if currently online
+     */
+    isOnline(): Promise<boolean>;
+    /**
+     * Cleanup listeners
+     */
+    destroy(): void;
+    private setupListeners;
+    private handleOnline;
+    private handleOffline;
+    private handleConnectionChange;
+    private notifyListeners;
+}
+/**
+ * Create web network adapter with default config
+ */
+declare function createWebNetworkAdapter(config?: WebNetworkConfig): WebNetworkAdapter;
+
+/**
+ * createBrowserAdapters - Full preset factory for browser environment
+ *
+ * Creates all adapters needed for SDK with a single config object.
+ * Combines REST API adapters with browser-specific adapters.
+ *
+ * @example
+ * ```typescript
+ * import { createBrowserAdapters } from '@xhub-short/adapters';
+ *
+ * const adapters = createBrowserAdapters({
+ *   baseUrl: 'https://api.myapp.com/v1',
+ *   auth: { getAccessToken: () => token },
+ *   endpoints: { ... },
+ * });
+ *
+ * const sdk = createSDK({
+ *   dataSource: adapters.dataSource,
+ *   interaction: adapters.interaction,
+ *   analytics: adapters.analytics,
+ *   storage: adapters.storage,
+ *   network: adapters.network,
+ *   videoLoader: adapters.videoLoader,
+ *   posterLoader: adapters.posterLoader,
+ * });
+ * ```
+ */
+
+/**
+ * Configuration for createBrowserAdapters
+ */
+interface BrowserAdaptersConfig extends RESTPresetConfig {
+    /** Storage configuration */
+    storage?: LocalStorageConfig;
+    /** Network configuration */
+    network?: WebNetworkConfig;
+    /** Video loader configuration */
+    videoLoader?: BrowserVideoLoaderConfig;
+    /** Poster loader timeout */
+    posterTimeout?: number;
+}
+/**
+ * Full adapter set returned by createBrowserAdapters
+ */
+interface FullPresetAdapters {
+    /** Data source adapter (REST API) */
+    dataSource: IDataSource;
+    /** Interaction adapter (REST API) */
+    interaction: IInteraction;
+    /** Analytics adapter (REST API or no-op) */
+    analytics: IAnalytics;
+    /** Session storage adapter (localStorage) */
+    storage: ISessionStorage;
+    /** Network adapter (Navigator.connection) */
+    network: INetworkAdapter;
+    /** Video preloader (fetch + Cache API) */
+    videoLoader: IVideoLoader;
+    /** Poster preloader (Image) */
+    posterLoader: IPosterLoader;
+    /** Logger (passed through) */
+    logger?: ILogger;
+}
+/**
+ * Create full browser adapter set from config
+ *
+ * This is the recommended way to integrate SDK for web applications.
+ * Creates all adapters with sensible defaults.
+ *
+ * @param config - Combined configuration
+ * @returns Full adapter set for SDK
+ *
+ * @example
+ * ```typescript
+ * // Minimal config
+ * const adapters = createBrowserAdapters({
+ *   baseUrl: 'https://api.myapp.com',
+ *   auth: { getAccessToken: () => localStorage.getItem('token') },
+ *   endpoints: {
+ *     feed: { list: '/videos', detail: '/videos/:id' },
+ *     interaction: {
+ *       like: '/videos/:id/like',
+ *       unlike: '/videos/:id/like',
+ *       follow: '/users/:id/follow',
+ *       unfollow: '/users/:id/follow',
+ *       comment: '/videos/:id/comments',
+ *       deleteComment: '/comments/:id',
+ *     },
+ *   },
+ * });
+ *
+ * // Full config with all options
+ * const adapters = createBrowserAdapters({
+ *   baseUrl: 'https://api.myapp.com',
+ *   auth: {
+ *     getAccessToken: () => localStorage.getItem('token'),
+ *     refreshToken: () => refreshService.refresh(),
+ *     onAuthError: () => router.push('/login'),
+ *   },
+ *   endpoints: { ... },
+ *   request: {
+ *     timeout: 15000,
+ *     retry: { maxRetries: 3 },
+ *   },
+ *   storage: {
+ *     prefix: 'myapp-',
+ *     maxSnapshotAge: 12 * 60 * 60 * 1000, // 12 hours
+ *   },
+ *   videoLoader: {
+ *     defaultMaxBytes: 1024 * 1024, // 1MB
+ *   },
+ *   logger: myLogger,
+ * });
+ * ```
+ */
+declare function createBrowserAdapters(config: BrowserAdaptersConfig): FullPresetAdapters;
+
+/**
+ * HTTP Client - Shared HTTP client với auth/retry
+ *
+ * Features:
+ * - Auto auth token injection
+ * - Token refresh on 401
+ * - Retry with exponential backoff
+ * - Request timeout
+ * - Error normalization
+ */
+
+/**
+ * HTTP Client configuration
+ */
+interface HttpClientConfig {
+    baseUrl: string;
+    auth: AuthConfig;
+    request?: RESTRequestConfig;
+    logger?: ILogger;
+}
+/**
+ * HTTP error with status code
+ */
+declare class HttpError extends Error {
+    readonly status: number;
+    readonly body?: unknown | undefined;
+    constructor(status: number, message: string, body?: unknown | undefined);
+}
+/**
+ * HTTP Client class
+ */
+declare class HttpClient {
+    private readonly config;
+    private readonly retryConfig;
+    private readonly requestConfig;
+    private isRefreshing;
+    private refreshPromise;
+    constructor(config: HttpClientConfig);
+    /**
+     * Make HTTP request with auth and retry
+     */
+    request<T>(options: HttpRequestOptions): Promise<T>;
+    /**
+     * Build full URL from path and path params
+     */
+    private buildUrl;
+    /**
+     * Append query params to URL
+     */
+    private appendQueryParams;
+    /**
+     * Build headers with auth token
+     */
+    private buildHeaders;
+    /**
+     * Execute request with retry logic
+     */
+    private executeWithRetry;
+    /**
+     * Handle response status and parse result
+     */
+    private handleResponse;
+    /**
+     * Handle 401 unauthorized - attempt token refresh
+     */
+    private handleUnauthorized;
+    /**
+     * Update auth header with new token
+     */
+    private updateAuthHeader;
+    /**
+     * Check if error should trigger retry
+     */
+    private shouldRetry;
+    /**
+     * Wait before retry with backoff
+     */
+    private waitBeforeRetry;
+    /**
+     * Execute fetch with timeout
+     */
+    private doFetch;
+    /**
+     * Parse response JSON
+     */
+    private parseResponse;
+    /**
+     * Safely parse JSON from response
+     */
+    private safeParseJson;
+    /**
+     * Refresh token with deduplication
+     */
+    private refreshTokenIfNeeded;
+    /**
+     * Sleep utility
+     */
+    private sleep;
+}
+
+/**
+ * Default Transforms - Auto-transform API responses to SDK format
+ *
+ * Default convention: snake_case API → camelCase SDK
+ * Tries multiple common field names for flexibility
+ */
+
+/**
+ * Default video item transform
+ *
+ * Handles common API response formats:
+ * - snake_case (Laravel, Django, Rails)
+ * - camelCase
+ * - Nested structures
+ */
+declare function defaultVideoItemTransform(apiResponse: unknown, fieldMap?: FieldMapConfig['video'], logger?: ILogger): VideoItem;
+/**
+ * Default feed response transform
+ */
+declare function defaultFeedResponseTransform(apiResponse: unknown, fieldMap?: FieldMapConfig['feed'], logger?: ILogger): {
+    items: unknown[];
+    nextCursor: string | null;
+    hasMore: boolean;
+};
+/**
+ * Create transforms with custom overrides
+ */
+interface ResolvedTransforms {
+    videoItem: (data: unknown) => VideoItem;
+    feedResponse: (data: unknown) => {
+        items: unknown[];
+        nextCursor: string | null;
+        hasMore: boolean;
+    };
+}
+declare function createTransforms(config?: TransformConfig, logger?: ILogger): ResolvedTransforms;
+
+/**
+ * REST Data Adapter - IDataSource implementation for REST APIs
+ *
+ * Implements:
+ * - fetchFeed: GET /videos with pagination
+ * - getVideoDetail: GET /videos/:id
+ * - prefetch: Optional prefetch support
+ */
+
+/**
+ * REST Data Adapter configuration
+ */
+interface RESTDataAdapterConfig {
+    httpClient: HttpClient;
+    endpoints: RESTEndpointMap['feed'];
+    transforms: ResolvedTransforms;
+    pagination?: RESTRequestConfig['pagination'];
+    logger?: ILogger;
+}
+/**
+ * REST Data Adapter
+ */
+declare class RESTDataAdapter implements IDataSource {
+    private readonly httpClient;
+    private readonly endpoints;
+    private readonly transforms;
+    private readonly pagination;
+    private readonly logger?;
+    constructor(config: RESTDataAdapterConfig);
+    /**
+     * Fetch feed with pagination
+     */
+    fetchFeed(cursor?: string): Promise<FeedResponse>;
+    /**
+     * Get video detail by ID
+     */
+    getVideoDetail(id: string): Promise<VideoItem>;
+    /**
+     * Optional: Prefetch videos
+     * This is a no-op by default, can be overridden if API supports batch fetch
+     */
+    prefetch(ids: string[]): Promise<void>;
+    /**
+     * Unwrap response if wrapped in data/result field
+     */
+    private unwrapResponse;
+    /**
+     * Create fallback video item when transform fails
+     */
+    private createFallbackVideoItem;
+}
+
+/**
+ * REST Interaction Adapter - IInteraction implementation for REST APIs
+ *
+ * Implements all user interaction methods:
+ * - like/unlike
+ * - follow/unfollow
+ * - comment/deleteComment
+ * - share (optional)
+ */
+
+/**
+ * REST Interaction Adapter configuration
+ */
+interface RESTInteractionAdapterConfig {
+    httpClient: HttpClient;
+    endpoints: RESTEndpointMap['interaction'];
+    logger?: ILogger;
+}
+/**
+ * REST Interaction Adapter
+ */
+declare class RESTInteractionAdapter implements IInteraction {
+    private readonly httpClient;
+    private readonly endpoints;
+    private readonly logger?;
+    constructor(config: RESTInteractionAdapterConfig);
+    /**
+     * Like a video
+     */
+    like(videoId: string): Promise<void>;
+    /**
+     * Unlike a video
+     */
+    unlike(videoId: string): Promise<void>;
+    /**
+     * Follow an author
+     */
+    follow(authorId: string): Promise<void>;
+    /**
+     * Unfollow an author
+     */
+    unfollow(authorId: string): Promise<void>;
+    /**
+     * Post a comment
+     */
+    comment(videoId: string, text: string): Promise<Comment>;
+    /**
+     * Delete a comment
+     */
+    deleteComment(commentId: string): Promise<void>;
+    /**
+     * Like a comment
+     */
+    likeComment(commentId: string): Promise<void>;
+    /**
+     * Unlike a comment
+     */
+    unlikeComment(commentId: string): Promise<void>;
+    /**
+     * Share a video (optional tracking)
+     */
+    share(videoId: string, platform?: string): Promise<void>;
+    /**
+     * Transform API comment response to Comment type
+     */
+    private transformComment;
+    /**
+     * Unwrap response if wrapped
+     */
+    private unwrapResponse;
+}
+
+/**
+ * REST Analytics Adapter - IAnalytics implementation for REST APIs
+ *
+ * Implements batching strategy per ADD.md:
+ * - Events queued internally
+ * - Flush conditions: queue > 10, video change, visibility change
+ * - Uses sendBeacon for reliability when available
+ */
+
+/**
+ * REST Analytics Adapter configuration
+ */
+interface RESTAnalyticsAdapterConfig {
+    httpClient: HttpClient;
+    endpoints: NonNullable<RESTEndpointMap['analytics']>;
+    batchSize?: number;
+    flushInterval?: number;
+    logger?: ILogger;
+}
+/**
+ * REST Analytics Adapter
+ */
+declare class RESTAnalyticsAdapter implements IAnalytics {
+    private readonly httpClient;
+    private readonly endpoint;
+    private readonly batchSize;
+    private readonly logger?;
+    private queue;
+    private flushTimer;
+    private userId;
+    private userProperties;
+    constructor(config: RESTAnalyticsAdapterConfig);
+    /**
+     * Track an analytics event
+     * Fire-and-forget - doesn't throw
+     */
+    track(event: AnalyticsEvent): void;
+    /**
+     * Flush queued events
+     */
+    flush(): Promise<void>;
+    /**
+     * Track video view duration (heartbeat)
+     */
+    trackViewDuration(videoId: string, duration: number, totalDuration: number): void;
+    /**
+     * Track video completion
+     */
+    trackCompletion(videoId: string, watchTime: number, loops: number): void;
+    /**
+     * Set user context
+     */
+    setUser(userId: string | null, properties?: Record<string, unknown>): void;
+    /**
+     * Get current queue size (for debugging)
+     */
+    getQueueSize(): number;
+    /**
+     * Cleanup - stop flush interval
+     */
+    destroy(): void;
+    /**
+     * Try to send via sendBeacon (for reliability on page unload)
+     */
+    private trySendBeacon;
+    /**
+     * Build full URL for sendBeacon
+     */
+    private buildFullUrl;
+}
+/**
+ * Create a no-op analytics adapter
+ * Used when analytics endpoint is not configured
+ */
+declare function createNoOpAnalyticsAdapter(): IAnalytics;
+
+export { type AuthConfig, type AuthError, type BrowserAdaptersConfig, BrowserPosterLoader, BrowserVideoLoader, type BrowserVideoLoaderConfig, DEFAULT_REQUEST_CONFIG, DEFAULT_RETRY_CONFIG, type FieldMapConfig, type FullPresetAdapters, HttpClient, HttpError, LocalSessionStorageAdapter, LocalStorageAdapter, type LocalStorageConfig, MockAnalyticsAdapter, type MockAnalyticsAdapterOptions, MockDataAdapter, type MockDataAdapterOptions, MockInteractionAdapter, type MockInteractionAdapterOptions, MockLoggerAdapter, type MockLoggerAdapterOptions, MockNetworkAdapter, type MockNetworkAdapterOptions, MockPosterLoader, MockSessionStorageAdapter, type MockSessionStorageAdapterOptions, MockStorageAdapter, type MockStorageAdapterOptions, MockVideoLoader, type MockVideoLoaderOptions, type PresetAdapters, RESTAnalyticsAdapter, RESTDataAdapter, type RESTEndpointMap, RESTInteractionAdapter, type RESTPresetConfig, type RESTRequestConfig, type ResolvedTransforms, type RetryConfig, type TransformConfig, WebNetworkAdapter, type WebNetworkConfig, createBrowserAdapters, createBrowserPosterLoader, createBrowserVideoLoader, createLocalStorageAdapter, createNoOpAnalyticsAdapter, createRESTAdapters, createSessionStorageAdapter, createTransforms, createWebNetworkAdapter, defaultFeedResponseTransform, defaultVideoItemTransform };