@xhub-short/adapters 0.1.0-beta.1 → 0.1.0-beta.10

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-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';
+import { IDataSource, VideoItem, FeedResponse, ILogger, LogLevel, LogEntry, IStorage, ISessionStorage, SessionSnapshot, IInteraction, Comment, ICommentAdapter, MockCommentAdapterConfig, CommentListResponse, ReplyListResponse, PostCommentPayload, CommentItem, PostReplyPayload, ReplyItem, EditCommentPayload, DeleteCommentPayload, ReportCommentPayload, IAnalytics, AnalyticsEvent, INetworkAdapter, NetworkType, NetworkQuality, IVideoLoader, VideoSource, PreloadConfig, PreloadResult, PreloadStatus, IPosterLoader, CommentTransformers } from '@xhub-short/contracts';
 
 /**
  * MockDataAdapter - Development/Testing Data Source
@@ -511,6 +511,48 @@ declare class MockInteractionAdapter implements IInteraction {
     private maybeThrowError;
 }
 
+/**
+ * Mock Comment Adapter for testing and development
+ *
+ * Features:
+ * - Simulated network delay
+ * - Configurable error simulation
+ * - In-memory storage
+ */
+declare class MockCommentAdapter implements ICommentAdapter {
+    private comments;
+    private replies;
+    private delay;
+    private simulateErrors;
+    private errorRate;
+    private idCounter;
+    constructor(config?: MockCommentAdapterConfig);
+    private simulateNetworkDelay;
+    private generateId;
+    getComments(videoId: string, cursor?: string | null, limit?: number): Promise<CommentListResponse>;
+    getReplies(commentId: string, cursor?: string | null, limit?: number): Promise<ReplyListResponse>;
+    postComment(payload: PostCommentPayload): Promise<CommentItem>;
+    postReply(payload: PostReplyPayload): Promise<ReplyItem>;
+    editComment(payload: EditCommentPayload): Promise<CommentItem | ReplyItem>;
+    deleteComment(payload: DeleteCommentPayload): Promise<void>;
+    likeComment(id: string): Promise<void>;
+    unlikeComment(id: string): Promise<void>;
+    reportComment(_payload: ReportCommentPayload): Promise<void>;
+    private updateLikeState;
+    /**
+     * Clear all stored data (for testing)
+     */
+    clearAll(): void;
+    /**
+     * Get stored comments count (for testing)
+     */
+    getCommentsCount(videoId: string): number;
+    /**
+     * Get stored replies count (for testing)
+     */
+    getRepliesCount(commentId: string): number;
+}
+
 /**
  * Configuration options for MockAnalyticsAdapter
  */
@@ -950,13 +992,61 @@ interface RESTEndpointMap {
         share?: string;
     };
     /**
-     * Analytics endpoints (optional)
-     * If not provided, analytics adapter will be no-op
+     * Analytics endpoints (optional) - BATCH mode
+     * If provided, uses RESTAnalyticsAdapter with batch sending
      */
     analytics?: {
         /** POST endpoint for batch events */
         batch: string;
     };
+    /**
+     * View tracking endpoint (optional) - PER-VIDEO mode
+     * If provided, uses RESTViewTrackingAdapter with per-video tracking
+     *
+     * Priority: viewTracking > analytics (if both provided, viewTracking wins)
+     *
+     * @example
+     * ```typescript
+     * viewTracking: {
+     *   notify: '/reels/:id/notify-views',
+     * }
+     * ```
+     */
+    viewTracking?: {
+        /**
+         * POST endpoint for view notification
+         * :id will be replaced with video ID
+         */
+        notify: string;
+        /**
+         * Path param name for video ID
+         * @default 'id'
+         */
+        pathParam?: string;
+    };
+    /**
+     * Comment endpoints (optional)
+     * If not provided, comment adapter will not be created
+     * Note: postReply uses same endpoint as post, with reply_to_comment_id in body
+     */
+    comment?: {
+        /** GET /videos/:videoId/comments */
+        list: string;
+        /** GET /comments/:commentId/replies */
+        replies: string;
+        /** POST /videos/:videoId/comments (also for replies with reply_to_comment_id) */
+        post: string;
+        /** PATCH /comments/:id */
+        edit: string;
+        /** DELETE /comments/:id */
+        delete: string;
+        /** POST /comments/:id/like */
+        like: string;
+        /** DELETE /comments/:id/like */
+        unlike: string;
+        /** POST /comments/:id/report */
+        report: string;
+    };
 }
 /**
  * HTTP request configuration
@@ -1053,6 +1143,225 @@ interface FieldMapConfig {
         hasMore?: string;
     };
 }
+/**
+ * Event types for batch analytics
+ * Maps SDK internal types to API event types
+ */
+type BatchAnalyticsEventType = 'view_start' | 'view_end' | 'scroll_pass' | 'like' | 'comment' | 'share' | 'follow_creator' | 'save' | 'report';
+/**
+ * Device type for analytics context
+ */
+type BatchAnalyticsDeviceType = 'ios' | 'android' | 'web';
+/**
+ * Network type for analytics context
+ */
+type BatchAnalyticsNetworkType = 'wifi' | '4g' | '5g' | 'other';
+/**
+ * SDK internal analytics event data
+ * Passed to transform function
+ */
+interface BatchAnalyticsEventData {
+    /** SDK event type (will be mapped to API event type) */
+    sdkEventType: string;
+    /** Video ID */
+    videoId?: string;
+    /** Event timestamp */
+    timestamp: number;
+    /** User ID (from setUser) */
+    userId: string | null;
+    /** User properties (from setUser) */
+    userProperties: Record<string, unknown>;
+    /** Additional event data from SDK */
+    data?: Record<string, unknown>;
+}
+/**
+ * Context data for analytics events
+ * Provided by Host App via config
+ */
+interface BatchAnalyticsContext {
+    /** Get current session ID */
+    getSessionId: () => string | null | Promise<string | null>;
+    /** Get device type */
+    getDeviceType: () => BatchAnalyticsDeviceType;
+    /** Get network type */
+    getNetworkType: () => BatchAnalyticsNetworkType | Promise<BatchAnalyticsNetworkType>;
+    /** Get geo location (optional) */
+    getGeoLocation?: () => string | null | Promise<string | null>;
+    /** Get current video position index in feed */
+    getPositionIndex?: () => number;
+    /** Get scroll speed in ms (optional) */
+    getScrollSpeed?: () => number | null;
+}
+/**
+ * Single event in batch request body (after transform)
+ */
+type BatchAnalyticsRequestEvent = Record<string, unknown>;
+/**
+ * Full request body for batch analytics
+ */
+interface BatchAnalyticsRequestBody {
+    events: BatchAnalyticsRequestEvent[];
+}
+/**
+ * Transform function to convert SDK event to API event format
+ *
+ * @example
+ * ```typescript
+ * const transform: BatchAnalyticsEventTransformer = async (event, context) => ({
+ *   event_id: crypto.randomUUID(),
+ *   user_id: event.userId,
+ *   video_id: event.videoId,
+ *   session_id: await context.getSessionId(),
+ *   event_type: mapEventType(event.sdkEventType),
+ *   position_index: context.getPositionIndex?.() ?? 0,
+ *   impression_timestamp: new Date(event.timestamp).toISOString(),
+ *   scroll_speed_ms: context.getScrollSpeed?.() ?? null,
+ *   device_type: context.getDeviceType(),
+ *   network_type: await context.getNetworkType(),
+ *   geo_location: await context.getGeoLocation?.() ?? null,
+ *   time_of_day: new Date(event.timestamp).getHours(),
+ *   day_of_week: new Date(event.timestamp).getDay(),
+ * });
+ * ```
+ */
+type BatchAnalyticsEventTransformer = (event: BatchAnalyticsEventData, context: BatchAnalyticsContext) => BatchAnalyticsRequestEvent | Promise<BatchAnalyticsRequestEvent>;
+/**
+ * Batch analytics configuration for preset
+ *
+ * @example
+ * ```typescript
+ * const batchAnalytics: BatchAnalyticsConfig = {
+ *   batchSize: 10,
+ *   flushInterval: 30000,
+ *   context: {
+ *     getSessionId: () => sessionStorage.getItem('session_id'),
+ *     getDeviceType: () => 'web',
+ *     getNetworkType: () => navigator.connection?.effectiveType === '4g' ? '4g' : 'wifi',
+ *     getGeoLocation: () => 'Ho Chi Minh City, Vietnam',
+ *     getPositionIndex: () => currentIndex,
+ *   },
+ *   transform: async (event, ctx) => ({
+ *     event_id: crypto.randomUUID(),
+ *     user_id: event.userId,
+ *     video_id: event.videoId,
+ *     session_id: await ctx.getSessionId(),
+ *     event_type: event.sdkEventType,
+ *     // ... more fields
+ *   }),
+ * };
+ * ```
+ */
+interface BatchAnalyticsConfig {
+    /**
+     * Batch size threshold for auto-flush
+     * @default 10
+     */
+    batchSize?: number;
+    /**
+     * Flush interval in milliseconds
+     * @default 30000 (30 seconds)
+     */
+    flushInterval?: number;
+    /**
+     * Context providers for enriching events
+     * Required if using custom transform
+     */
+    context?: BatchAnalyticsContext;
+    /**
+     * Custom transform function
+     * If not provided, uses default SDK format
+     */
+    transform?: BatchAnalyticsEventTransformer;
+    /**
+     * Map SDK event types to API event types
+     * Used by default transform if no custom transform provided
+     *
+     * @example
+     * ```typescript
+     * eventTypeMap: {
+     *   'video_view': 'view_start',
+     *   'video_complete': 'view_end',
+     *   'scroll': 'scroll_pass',
+     *   'like': 'like',
+     *   'follow': 'follow_creator',
+     * }
+     * ```
+     */
+    eventTypeMap?: Record<string, BatchAnalyticsEventType>;
+    /**
+     * Use sendBeacon API for flushing events
+     *
+     * sendBeacon is more reliable for page unload events but shows as "ping" in Network tab.
+     * Set to false to always use HTTP POST (easier for debugging).
+     *
+     * @default true
+     */
+    useSendBeacon?: boolean;
+}
+/**
+ * View event data passed to transformer
+ */
+interface ViewEventData {
+    /** Video/Reel ID */
+    videoId: string;
+    /** Current playback time in seconds */
+    currentTime: number;
+    /** Total video duration in seconds */
+    duration: number;
+    /** Internal event type (for SDK logic) */
+    internalEventType: 'play' | 'heartbeat' | 'complete' | 'leave';
+    /** Watch time so far (for completion events) */
+    watchTime?: number;
+    /** Loop count (for completion events) */
+    loopCount?: number;
+    /** Timestamp */
+    timestamp: number;
+}
+/**
+ * Request body after transformation
+ * Allows custom field names via fieldMap
+ */
+type ViewEventRequestBody = Record<string, unknown>;
+/**
+ * Transform function to convert SDK data to API request body
+ */
+type ViewEventTransformer = (data: ViewEventData) => ViewEventRequestBody;
+/**
+ * View tracking configuration for preset
+ */
+interface ViewTrackingConfig {
+    /**
+     * Value for view_event field
+     * @default 'seek'
+     */
+    viewEventValue?: string;
+    /**
+     * Heartbeat interval in milliseconds
+     * @default 10000 (10 seconds)
+     */
+    heartbeatInterval?: number;
+    /**
+     * Minimum watch time (seconds) before sending first event
+     * @default 0
+     */
+    minWatchTime?: number;
+    /**
+     * Track when user scrolls away from video
+     * @default true
+     */
+    trackLeave?: boolean;
+    /**
+     * Custom request body transformer
+     */
+    transform?: ViewEventTransformer;
+    /**
+     * Field mapping for default transformer
+     */
+    fieldMap?: {
+        currentTime?: string;
+        viewEvent?: string;
+    };
+}
 /**
  * REST Preset Adapter configuration
  */
@@ -1079,6 +1388,35 @@ interface RESTPresetConfig {
      * Request configuration (optional)
      */
     request?: RESTRequestConfig;
+    /**
+     * View tracking configuration (optional)
+     * Only used if endpoints.viewTracking is configured
+     */
+    viewTracking?: ViewTrackingConfig;
+    /**
+     * Batch analytics configuration (optional)
+     * Only used if endpoints.analytics is configured
+     *
+     * @example
+     * ```typescript
+     * batchAnalytics: {
+     *   batchSize: 10,
+     *   flushInterval: 30000,
+     *   context: {
+     *     getSessionId: () => sessionStorage.getItem('session_id'),
+     *     getDeviceType: () => 'web',
+     *     getNetworkType: () => 'wifi',
+     *   },
+     *   transform: (event, ctx) => ({
+     *     event_id: crypto.randomUUID(),
+     *     user_id: event.userId,
+     *     video_id: event.videoId,
+     *     // ... custom format
+     *   }),
+     * }
+     * ```
+     */
+    batchAnalytics?: BatchAnalyticsConfig;
     /**
      * Logger adapter for error/warning logging
      * If not provided, uses console in dev, silent in prod
@@ -1092,6 +1430,8 @@ interface PresetAdapters {
     dataSource: IDataSource;
     interaction: IInteraction;
     analytics: IAnalytics;
+    /** Comment adapter (only if comment endpoints are configured) */
+    comment?: ICommentAdapter;
 }
 /**
  * HTTP request options (internal)
@@ -1557,6 +1897,8 @@ interface FullPresetAdapters {
     videoLoader: IVideoLoader;
     /** Poster preloader (Image) */
     posterLoader: IPosterLoader;
+    /** Comment adapter (REST API, only if comment endpoints configured) */
+    comment?: ICommentAdapter;
     /** Logger (passed through) */
     logger?: ILogger;
 }
@@ -1649,6 +1991,10 @@ declare class HttpClient {
     private readonly config;
     private readonly retryConfig;
     private readonly requestConfig;
+    /**
+     * Get base URL (for sendBeacon which needs full URL)
+     */
+    getBaseUrl(): string;
     private isRefreshing;
     private refreshPromise;
     constructor(config: HttpClientConfig);
@@ -1714,6 +2060,127 @@ declare class HttpClient {
     private sleep;
 }
 
+/**
+ * CircuitBreaker - Prevents cascade failures
+ *
+ * State transitions:
+ * CLOSED → (failures >= threshold) → OPEN
+ * OPEN → (cooldown passes) → HALF_OPEN
+ * HALF_OPEN → (success) → CLOSED
+ * HALF_OPEN → (failure) → OPEN
+ *
+ * @packageDocumentation
+ */
+/**
+ * Circuit breaker states
+ */
+type CircuitState = 'closed' | 'open' | 'half-open';
+/**
+ * Circuit breaker configuration
+ */
+interface CircuitBreakerConfig {
+    /** Number of failures before opening (default: 5) */
+    failureThreshold?: number;
+    /** Time window for failure counting in ms (default: 30000) */
+    failureWindow?: number;
+    /** Cool-down period before half-open in ms (default: 30000) */
+    cooldownPeriod?: number;
+    /** Number of successes in half-open to close (default: 1) */
+    successThreshold?: number;
+    /** Name for logging */
+    name?: string;
+}
+/**
+ * Circuit breaker events
+ */
+interface CircuitBreakerEvents {
+    stateChange: (state: CircuitState, previousState: CircuitState) => void;
+    failure: (error: Error, failureCount: number) => void;
+    success: () => void;
+    rejected: () => void;
+}
+/**
+ * Error thrown when circuit is open
+ */
+declare class CircuitOpenError extends Error {
+    constructor(message?: string);
+}
+/**
+ * CircuitBreaker - Prevents cascade failures
+ *
+ * @example
+ * ```typescript
+ * const breaker = new CircuitBreaker({ failureThreshold: 5 });
+ *
+ * async function fetchData() {
+ *   return breaker.execute(async () => {
+ *     const response = await fetch('/api/data');
+ *     return response.json();
+ *   });
+ * }
+ * ```
+ */
+declare class CircuitBreaker {
+    private state;
+    private failures;
+    private lastFailureTime;
+    private halfOpenSuccesses;
+    private config;
+    private listeners;
+    constructor(config?: CircuitBreakerConfig);
+    /**
+     * Get current circuit state
+     */
+    getState(): CircuitState;
+    /**
+     * Check if circuit allows requests
+     */
+    isAllowed(): boolean;
+    /**
+     * Execute a function through the circuit breaker
+     */
+    execute<T>(fn: () => Promise<T>): Promise<T>;
+    /**
+     * Record a successful call
+     */
+    recordSuccess(): void;
+    /**
+     * Record a failed call
+     */
+    recordFailure(error: Error): void;
+    /**
+     * Manually reset the circuit breaker
+     */
+    reset(): void;
+    /**
+     * Subscribe to events
+     */
+    on<K extends keyof CircuitBreakerEvents>(event: K, listener: CircuitBreakerEvents[K]): () => void;
+    /**
+     * Get failure count
+     */
+    getFailureCount(): number;
+    /**
+     * Get config
+     */
+    getConfig(): Required<CircuitBreakerConfig>;
+    private updateState;
+    private transitionTo;
+    private emit;
+}
+/**
+ * Get or create a circuit breaker by name
+ */
+declare function getCircuitBreaker(name?: string, config?: CircuitBreakerConfig): CircuitBreaker;
+/**
+ * Reset all circuit breakers
+ */
+declare function resetAllCircuitBreakers(): void;
+/**
+ * Get global circuit breaker (default)
+ */
+declare function getGlobalCircuitBreaker(): CircuitBreaker;
+
 /**
  * Default Transforms - Auto-transform API responses to SDK format
  *
@@ -1882,6 +2349,34 @@ declare class RESTInteractionAdapter implements IInteraction {
  * - Events queued internally
  * - Flush conditions: queue > 10, video change, visibility change
  * - Uses sendBeacon for reliability when available
+ *
+ * Supports custom transform for flexible API formats:
+ * - Default: SDK format { events: [...] }
+ * - Custom: Any format via transform function
+ *
+ * @example
+ * ```typescript
+ * // With custom transform for specific API format
+ * const adapter = new RESTAnalyticsAdapter({
+ *   httpClient,
+ *   endpoints: { batch: '/api/v1/events/track-batch' },
+ *   config: {
+ *     context: {
+ *       getSessionId: () => sessionStorage.getItem('session_id'),
+ *       getDeviceType: () => 'web',
+ *       getNetworkType: () => 'wifi',
+ *     },
+ *     transform: async (event, ctx) => ({
+ *       event_id: crypto.randomUUID(),
+ *       user_id: event.userId,
+ *       video_id: event.videoId,
+ *       session_id: await ctx.getSessionId(),
+ *       event_type: event.sdkEventType,
+ *       // ... more fields
+ *     }),
+ *   },
+ * });
+ * ```
  */
 
 /**
@@ -1890,22 +2385,35 @@ declare class RESTInteractionAdapter implements IInteraction {
 interface RESTAnalyticsAdapterConfig {
     httpClient: HttpClient;
     endpoints: NonNullable<RESTEndpointMap['analytics']>;
+    /** Batch analytics config with transform and context */
+    config?: BatchAnalyticsConfig;
+    /** @deprecated Use config.batchSize instead */
     batchSize?: number;
+    /** @deprecated Use config.flushInterval instead */
     flushInterval?: number;
     logger?: ILogger;
 }
 /**
  * REST Analytics Adapter
+ *
+ * Supports two modes:
+ * 1. Default mode: Uses SDK format { events: [...] }
+ * 2. Custom mode: Uses transform function for custom API format
  */
 declare class RESTAnalyticsAdapter implements IAnalytics {
     private readonly httpClient;
     private readonly endpoint;
     private readonly batchSize;
     private readonly logger?;
+    private readonly transform?;
+    private readonly context;
+    private readonly eventTypeMap;
+    private readonly useSendBeacon;
     private queue;
     private flushTimer;
     private userId;
     private userProperties;
+    private viewedVideos;
     constructor(config: RESTAnalyticsAdapterConfig);
     /**
      * Track an analytics event
@@ -1917,9 +2425,23 @@ declare class RESTAnalyticsAdapter implements IAnalytics {
      */
     flush(): Promise<void>;
     /**
-     * Track video view duration (heartbeat)
+     * Build request body from events
+     * Uses custom transform if provided, otherwise SDK default format
+     */
+    private buildRequestBody;
+    /**
+     * Track video view duration
+     *
+     * Note: PlayerEngine calls this every second (heartbeat), but for batch analytics
+     * we only need ONE view_start per video. This method deduplicates by videoId.
+     *
+     * If you need heartbeat tracking, use RESTViewTrackingAdapter instead.
      */
     trackViewDuration(videoId: string, duration: number, totalDuration: number): void;
+    /**
+     * Clear viewed videos cache (useful for testing or session reset)
+     */
+    clearViewedVideos(): void;
     /**
      * Track video completion
      */
@@ -1938,12 +2460,23 @@ declare class RESTAnalyticsAdapter implements IAnalytics {
     destroy(): void;
     /**
      * Try to send via sendBeacon (for reliability on page unload)
+     * Note: sendBeacon shows as "ping" type in Network tab, not "POST"
+     *
+     * Set useSendBeacon: false in config to always use HTTP POST
      */
     private trySendBeacon;
     /**
      * Build full URL for sendBeacon
      */
     private buildFullUrl;
+    /**
+     * Get mapped API event type from SDK event type
+     */
+    getApiEventType(sdkEventType: string): BatchAnalyticsEventType;
+    /**
+     * Get current context (for debugging/testing)
+     */
+    getContext(): BatchAnalyticsContext;
 }
 /**
  * Create a no-op analytics adapter
@@ -1951,4 +2484,221 @@ declare class RESTAnalyticsAdapter implements IAnalytics {
  */
 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 };
+/**
+ * REST View Tracking Adapter - Per-video view tracking via REST API
+ *
+ * Implements IAnalytics interface with throttled, fire-and-forget tracking.
+ * Uses shared HttpClient from preset (auth, retry, timeout).
+ *
+ * @example
+ * ```typescript
+ * // Created automatically by createRESTAdapters when viewTracking is configured
+ * const adapters = createRESTAdapters({
+ *   baseUrl: 'https://api.myapp.com/v1',
+ *   auth: { ... },
+ *   endpoints: {
+ *     feed: { ... },
+ *     interaction: { ... },
+ *     viewTracking: {
+ *       notify: '/reels/:id/notify-views',
+ *     },
+ *   },
+ * });
+ * ```
+ */
+
+/**
+ * REST View Tracking Adapter configuration
+ */
+interface RESTViewTrackingAdapterConfig {
+    httpClient: HttpClient;
+    endpoint: NonNullable<RESTEndpointMap['viewTracking']>;
+    config?: ViewTrackingConfig;
+    logger?: ILogger;
+}
+/**
+ * RESTViewTrackingAdapter - Per-video view tracking via REST API
+ *
+ * Uses shared HttpClient (inherits auth, retry, timeout from preset).
+ * Implements throttled, fire-and-forget tracking.
+ */
+declare class RESTViewTrackingAdapter implements IAnalytics {
+    private readonly httpClient;
+    private readonly endpoint;
+    private readonly transform;
+    private readonly viewEventValue;
+    private readonly heartbeatInterval;
+    private readonly minWatchTime;
+    private readonly trackLeaveEnabled;
+    private readonly logger?;
+    private lastTrackTime;
+    private lastEventType;
+    private _userId;
+    private _userProperties;
+    /** Get current user ID */
+    get userId(): string | null;
+    /** Get current user properties */
+    get userProperties(): Record<string, unknown>;
+    constructor(config: RESTViewTrackingAdapterConfig);
+    /**
+     * Track generic event
+     * Delegates video events to specific handlers
+     */
+    track(event: AnalyticsEvent): void;
+    /**
+     * Flush - No-op since we send events immediately (fire-and-forget)
+     */
+    flush(): Promise<void>;
+    /**
+     * Track view duration (heartbeat)
+     * Called periodically during video playback
+     */
+    trackViewDuration(videoId: string, duration: number, totalDuration: number): void;
+    /**
+     * Track video completion
+     * Called when video ends or loops
+     */
+    trackCompletion(videoId: string, watchTime: number, loopCount: number): void;
+    /**
+     * Set user context
+     */
+    setUser(userId: string | null, properties?: Record<string, unknown>): void;
+    /**
+     * Get queue size (always 0 - no batching)
+     */
+    getQueueSize(): number;
+    /**
+     * Track when user leaves video
+     * Called when user scrolls to another video
+     */
+    trackLeaveVideo(videoId: string, currentTime: number, duration: number): void;
+    /**
+     * Clear tracking state for a video
+     * Call when video is removed from viewport
+     */
+    clearVideoState(videoId: string): void;
+    /**
+     * Clear all tracking state
+     */
+    reset(): void;
+    /**
+     * Send view event to API (fire-and-forget)
+     */
+    private sendViewEvent;
+}
+
+/**
+ * REST Comment Adapter - ICommentAdapter implementation for REST APIs
+ *
+ * Implements all comment operations:
+ * - getComments / getReplies
+ * - postComment / postReply
+ * - editComment / deleteComment
+ * - likeComment / unlikeComment
+ * - reportComment
+ */
+
+/**
+ * Comment endpoints configuration (required, not optional)
+ */
+interface CommentEndpointsConfig {
+    /** GET /videos/:videoId/comments */
+    list: string;
+    /** GET /comments/:commentId/replies */
+    replies: string;
+    /** POST /videos/:videoId/comments */
+    post: string;
+    /** PATCH /comments/:id */
+    edit: string;
+    /** DELETE /comments/:id */
+    delete: string;
+    /** POST /comments/:id/like */
+    like: string;
+    /** DELETE /comments/:id/like */
+    unlike: string;
+    /** POST /comments/:id/report */
+    report: string;
+}
+/**
+ * REST Comment Adapter configuration
+ */
+interface RESTCommentAdapterConfig {
+    httpClient: HttpClient;
+    endpoints: CommentEndpointsConfig;
+    transformers?: CommentTransformers;
+    logger?: ILogger;
+}
+/**
+ * REST Comment Adapter
+ */
+declare class RESTCommentAdapter implements ICommentAdapter {
+    private readonly httpClient;
+    private readonly endpoints;
+    private readonly transformers?;
+    private readonly logger?;
+    constructor(config: RESTCommentAdapterConfig);
+    /**
+     * Get comments for a video
+     */
+    getComments(videoId: string, cursor?: string | null, limit?: number): Promise<CommentListResponse>;
+    /**
+     * Get replies for a comment
+     */
+    getReplies(commentId: string, cursor?: string | null, limit?: number): Promise<ReplyListResponse>;
+    /**
+     * Post a new comment
+     */
+    postComment(payload: PostCommentPayload): Promise<CommentItem>;
+    /**
+     * Post a reply to a comment
+     * Uses same endpoint as postComment but with reply_to_comment_id
+     */
+    postReply(payload: PostReplyPayload): Promise<ReplyItem>;
+    /**
+     * Edit a comment or reply
+     */
+    editComment(payload: EditCommentPayload): Promise<CommentItem | ReplyItem>;
+    /**
+     * Delete a comment or reply
+     * DELETE /reels/:id/comments/:commentId
+     */
+    deleteComment(payload: DeleteCommentPayload): Promise<void>;
+    /**
+     * Like a comment or reply
+     */
+    likeComment(id: string): Promise<void>;
+    /**
+     * Unlike a comment or reply
+     */
+    unlikeComment(id: string): Promise<void>;
+    /**
+     * Report a comment or reply
+     */
+    reportComment(payload: ReportCommentPayload): Promise<void>;
+    /**
+     * Transform API response to CommentListResponse
+     */
+    private transformCommentListResponse;
+    /**
+     * Transform API response to ReplyListResponse
+     */
+    private transformReplyListResponse;
+    /**
+     * Transform API response to CommentItem
+     */
+    private transformComment;
+    /**
+     * Transform API response to ReplyItem
+     */
+    private transformReply;
+    /**
+     * Extract author from various API formats
+     */
+    private extractAuthor;
+    /**
+     * Unwrap nested response data
+     */
+    private unwrapResponse;
+}
+
+export { type AuthConfig, type AuthError, type BatchAnalyticsConfig, type BatchAnalyticsContext, type BatchAnalyticsDeviceType, type BatchAnalyticsEventData, type BatchAnalyticsEventTransformer, type BatchAnalyticsEventType, type BatchAnalyticsNetworkType, type BatchAnalyticsRequestBody, type BatchAnalyticsRequestEvent, type BrowserAdaptersConfig, BrowserPosterLoader, BrowserVideoLoader, type BrowserVideoLoaderConfig, CircuitBreaker, type CircuitBreakerConfig, type CircuitBreakerEvents, CircuitOpenError, type CircuitState, DEFAULT_REQUEST_CONFIG, DEFAULT_RETRY_CONFIG, type FieldMapConfig, type FullPresetAdapters, HttpClient, HttpError, LocalSessionStorageAdapter, LocalStorageAdapter, type LocalStorageConfig, MockAnalyticsAdapter, type MockAnalyticsAdapterOptions, MockCommentAdapter, 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, type RESTAnalyticsAdapterConfig, RESTCommentAdapter, type RESTCommentAdapterConfig, RESTDataAdapter, type RESTEndpointMap, RESTInteractionAdapter, type RESTPresetConfig, type RESTRequestConfig, RESTViewTrackingAdapter, type RESTViewTrackingAdapterConfig, type ResolvedTransforms, type RetryConfig, type TransformConfig, type ViewEventData, type ViewEventRequestBody, type ViewEventTransformer, type ViewTrackingConfig, WebNetworkAdapter, type WebNetworkConfig, createBrowserAdapters, createBrowserPosterLoader, createBrowserVideoLoader, createLocalStorageAdapter, createNoOpAnalyticsAdapter, createRESTAdapters, createSessionStorageAdapter, createTransforms, createWebNetworkAdapter, defaultFeedResponseTransform, defaultVideoItemTransform, getCircuitBreaker, getGlobalCircuitBreaker, resetAllCircuitBreakers };