@xhub-short/adapters 0.1.0-beta.9 → 1.0.0-beta.19

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-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';
+import { IDataSource, ContentItem, FeedResponse, VideoItem, IPlaylistDataSource, PlaylistData, PlaylistCollectionResponse, ILogger, LogLevel, LogEntry, IStorage, ISessionStorage, SessionSnapshot, IInteraction, Comment, ICommentAdapter, MockCommentAdapterConfig, CommentListResponse, ReplyListResponse, PostCommentPayload, CommentItem, PostReplyPayload, ReplyItem, EditCommentPayload, DeleteCommentPayload, ReportCommentPayload, IAnalytics, AnalyticsEvent, INetworkAdapter, NetworkType, NetworkQuality, IPosterLoader, IVideoLoader, VideoSource, PreloadConfig, PreloadResult, PreloadStatus, ReportReason, CommentTransformers } from '@xhub-short/contracts';
 
 /**
  * MockDataAdapter - Development/Testing Data Source
@@ -13,16 +13,20 @@ import { IDataSource, VideoItem, FeedResponse, ILogger, LogLevel, LogEntry, ISto
  * ```
  */
 declare class MockDataAdapter implements IDataSource {
-    private readonly videos;
+    private readonly items;
     private readonly pageSize;
     private readonly delay;
     constructor(options?: MockDataAdapterOptions);
     /**
-     * Fetch a page of mock videos
+     * Fetch a page of mock items
      */
-    fetchFeed(cursor?: string): Promise<FeedResponse>;
+    fetchFeed(cursor?: string): Promise<FeedResponse<ContentItem>>;
+    /**
+     * Get a single content item by ID
+     */
+    getContentDetail(id: string): Promise<ContentItem>;
     /**
-     * Get a single video by ID
+     * @deprecated Use getContentDetail instead
      */
     getVideoDetail(id: string): Promise<VideoItem>;
     /**
@@ -38,14 +42,29 @@ declare class MockDataAdapter implements IDataSource {
  * Configuration options for MockDataAdapter
  */
 interface MockDataAdapterOptions {
-    /** Custom mock video data */
-    videos?: VideoItem[];
+    /** Custom mock content data */
+    items?: ContentItem[];
+    /** @deprecated Use items instead */
+    videos?: ContentItem[];
     /** Number of items per page (default: 3) */
     pageSize?: number;
     /** Simulated network delay in ms (default: 300) */
     delay?: number;
 }
 
+/**
+ * MockPlaylistAdapter - Development/Testing Playlist Data Source
+ */
+declare class MockPlaylistAdapter implements IPlaylistDataSource {
+    private readonly delay;
+    constructor(options?: {
+        delay?: number;
+    });
+    fetchPlaylist(id: string): Promise<PlaylistData>;
+    fetchPlaylistCollection(cursor?: string): Promise<PlaylistCollectionResponse>;
+    private simulateDelay;
+}
+
 /**
  * Configuration options for MockLoggerAdapter
  */
@@ -446,9 +465,9 @@ declare class MockInteractionAdapter implements IInteraction {
     /**
      * Report a video
      *
-     * @param _videoId - ID of the video to report
-     * @param _reason - Report reason code
-     * @param _description - Optional additional description
+     * @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>;
     /**
@@ -972,6 +991,22 @@ interface RESTEndpointMap {
          */
         detail: string;
     };
+    /**
+     * Playlist-related endpoints
+     */
+    playlist?: {
+        /**
+         * GET endpoint for playlist collection (listing)
+         * Example: '/playlists'
+         */
+        list: string;
+        /**
+         * GET endpoint for playlist detail
+         * :id will be replaced with playlist ID
+         * Example: '/playlists/:id'
+         */
+        detail: string;
+    };
     /**
      * Interaction endpoints
      */
@@ -990,6 +1025,12 @@ interface RESTEndpointMap {
         deleteComment: string;
         /** POST /videos/:id/share (optional) */
         share?: string;
+        /** POST /content/:id/report (optional) */
+        report?: string;
+        /** GET /report-reasons (optional) */
+        reportReasons?: string;
+        /** POST /content/:id/not-interested (optional) */
+        notInterested?: string;
     };
     /**
      * Analytics endpoints (optional) - BATCH mode
@@ -1100,14 +1141,26 @@ interface RetryConfig {
      */
     exponentialBackoff?: boolean;
 }
+/**
+ * Report reason from API
+ */
+interface ReportReasonItem {
+    id: string;
+    label: string;
+    description?: string;
+}
 /**
  * Response transform configuration
  */
 interface TransformConfig {
     /**
-     * Transform single video item from API response
+     * Transform single content item from API response
      * If not provided, uses default transform
      */
+    contentItem?: (apiResponse: unknown) => ContentItem;
+    /**
+     * @deprecated Use contentItem instead. Will be removed in v3.0
+     */
     videoItem?: (apiResponse: unknown) => VideoItem;
     /**
      * Transform feed response from API
@@ -1118,6 +1171,51 @@ interface TransformConfig {
         nextCursor: string | null;
         hasMore: boolean;
     };
+    /**
+     * Transform playlist response from API
+     * If not provided, uses default transform
+     */
+    playlist?: (apiResponse: unknown) => PlaylistData;
+    /**
+     * Transform playlist collection response from API
+     * If not provided, uses default transform
+     */
+    playlistCollection?: (apiResponse: unknown) => PlaylistCollectionResponse;
+    /**
+     * Transform report reasons response from API
+     * If not provided, uses default transform
+     *
+     * @example
+     * ```ts
+     * reportReasons: (response) => {
+     *   const data = response.data?.reasons || [];
+     *   return data.map(item => ({
+     *     id: item.id,
+     *     label: item.title,
+     *     description: item.description,
+     *   }));
+     * }
+     * ```
+     */
+    reportReasons?: (apiResponse: unknown) => ReportReasonItem[];
+    /**
+     * Transform report request body before sending to API
+     * If not provided, uses default format: { reason, description }
+     *
+     * @example
+     * ```ts
+     * reportBody: ({ contentId, reasonId, description }) => ({
+     *   video_id: contentId,
+     *   reason_id: reasonId,
+     *   description: description || '',
+     * })
+     * ```
+     */
+    reportBody?: (input: {
+        contentId: string;
+        reasonId: string;
+        description?: string;
+    }) => Record<string, unknown>;
     /**
      * Field mapping for default transforms
      * Used when API field names differ from defaults
@@ -1134,6 +1232,11 @@ interface FieldMapConfig {
      * Example: { 'author.name': 'creator.display_name' }
      */
     video?: Record<string, string>;
+    /**
+     * Article field mapping
+     * Example: { 'author.name': 'creator.display_name' }
+     */
+    article?: Record<string, string>;
     /**
      * FeedResponse field mapping
      */
@@ -1143,6 +1246,161 @@ 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
  */
@@ -1238,6 +1496,30 @@ interface RESTPresetConfig {
      * 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
@@ -1251,6 +1533,8 @@ interface PresetAdapters {
     dataSource: IDataSource;
     interaction: IInteraction;
     analytics: IAnalytics;
+    /** Playlist adapter (optional) */
+    playlist?: IPlaylistDataSource;
     /** Comment adapter (only if comment endpoints are configured) */
     comment?: ICommentAdapter;
 }
@@ -1520,6 +1804,13 @@ declare class LocalStorageAdapter implements IStorage {
      * Clear all SDK-namespaced keys
      */
     clear(): Promise<void>;
+    /**
+     * Get a value from localStorage synchronously
+     *
+     * Used for zero-flash cache hydration during React render phase.
+     * localStorage is inherently synchronous, so this bypasses the async wrapper.
+     */
+    getSync<T>(key: string): T | null;
     /**
      * Get all SDK-namespaced keys
      */
@@ -1718,6 +2009,8 @@ interface FullPresetAdapters {
     videoLoader: IVideoLoader;
     /** Poster preloader (Image) */
     posterLoader: IPosterLoader;
+    /** Playlist adapter (REST API, optional) */
+    playlist?: IPlaylistDataSource;
     /** Comment adapter (REST API, only if comment endpoints configured) */
     comment?: ICommentAdapter;
     /** Logger (passed through) */
@@ -1812,6 +2105,14 @@ declare class HttpClient {
     private readonly config;
     private readonly retryConfig;
     private readonly requestConfig;
+    /**
+     * Get base URL (for sendBeacon which needs full URL)
+     */
+    getBaseUrl(): string;
+    /**
+     * Check if access token is available
+     */
+    hasAccessToken(): Promise<boolean>;
     private isRefreshing;
     private refreshPromise;
     constructor(config: HttpClientConfig);
@@ -1905,12 +2206,17 @@ declare function defaultFeedResponseTransform(apiResponse: unknown, fieldMap?: F
  * Create transforms with custom overrides
  */
 interface ResolvedTransforms {
+    /** Map raw API item to ContentItem (Video or Article) */
+    contentItem: (data: unknown) => ContentItem;
+    /** @deprecated Use contentItem instead */
     videoItem: (data: unknown) => VideoItem;
     feedResponse: (data: unknown) => {
         items: unknown[];
         nextCursor: string | null;
         hasMore: boolean;
     };
+    playlist: (data: unknown) => PlaylistData;
+    playlistCollection: (data: unknown) => PlaylistCollectionResponse;
 }
 declare function createTransforms(config?: TransformConfig, logger?: ILogger): ResolvedTransforms;
 
@@ -1918,8 +2224,8 @@ declare function createTransforms(config?: TransformConfig, logger?: ILogger): R
  * REST Data Adapter - IDataSource implementation for REST APIs
  *
  * Implements:
- * - fetchFeed: GET /videos with pagination
- * - getVideoDetail: GET /videos/:id
+ * - fetchFeed: GET /items with pagination
+ * - getContentDetail: GET /items/:id
  * - prefetch: Optional prefetch support
  */
 
@@ -1948,11 +2254,15 @@ declare class RESTDataAdapter implements IDataSource {
      */
     fetchFeed(cursor?: string): Promise<FeedResponse>;
     /**
-     * Get video detail by ID
+     * Get content detail by ID
+     */
+    getContentDetail(id: string): Promise<ContentItem>;
+    /**
+     * @deprecated Use getContentDetail instead
      */
     getVideoDetail(id: string): Promise<VideoItem>;
     /**
-     * Optional: Prefetch videos
+     * Optional: Prefetch content
      * This is a no-op by default, can be overridden if API supports batch fetch
      */
     prefetch(ids: string[]): Promise<void>;
@@ -1961,9 +2271,9 @@ declare class RESTDataAdapter implements IDataSource {
      */
     private unwrapResponse;
     /**
-     * Create fallback video item when transform fails
+     * Create fallback content item when transform fails
      */
-    private createFallbackVideoItem;
+    private createFallbackItem;
 }
 
 /**
@@ -1976,6 +2286,14 @@ declare class RESTDataAdapter implements IDataSource {
  * - share (optional)
  */
 
+/**
+ * Report body input from SDK
+ */
+interface ReportBodyInput {
+    contentId: string;
+    reasonId: string;
+    description?: string;
+}
 /**
  * REST Interaction Adapter configuration
  */
@@ -1983,6 +2301,10 @@ interface RESTInteractionAdapterConfig {
     httpClient: HttpClient;
     endpoints: RESTEndpointMap['interaction'];
     logger?: ILogger;
+    /** Custom transform for report reasons response */
+    transformReportReasons?: (apiResponse: unknown) => ReportReasonItem[];
+    /** Custom transform for report request body */
+    transformReportBody?: (input: ReportBodyInput) => Record<string, unknown>;
 }
 /**
  * REST Interaction Adapter
@@ -1991,6 +2313,8 @@ declare class RESTInteractionAdapter implements IInteraction {
     private readonly httpClient;
     private readonly endpoints;
     private readonly logger?;
+    private readonly customTransformReportReasons?;
+    private readonly customTransformReportBody?;
     constructor(config: RESTInteractionAdapterConfig);
     /**
      * Like a video
@@ -2028,6 +2352,38 @@ declare class RESTInteractionAdapter implements IInteraction {
      * Share a video (optional tracking)
      */
     share(videoId: string, platform?: string): Promise<void>;
+    /**
+     * Report content (video or image post)
+     *
+     * @param contentId - ID of the content to report
+     * @param reason - Report reason code/ID
+     * @param description - Optional additional description
+     */
+    report(contentId: string, reason: string, description?: string): Promise<void>;
+    /**
+     * Get available report reasons
+     *
+     * @returns Array of report reasons, or empty array if not configured
+     */
+    getReportReasons(): Promise<ReportReason[]>;
+    /**
+     * Mark content as "not interested"
+     *
+     * Used for recommendation algorithm feedback.
+     * Content should be hidden from feed after this action.
+     *
+     * @param contentId - ID of the content (video or image post)
+     */
+    notInterested(contentId: string): Promise<void>;
+    /**
+     * Default transform for API report reasons response to ReportReason[]
+     *
+     * Expected format: [{ id, label, description }]
+     * Or wrapped: { data: [{ id, label, description }] }
+     *
+     * For custom API formats, use `transforms.reportReasons` in preset config.
+     */
+    private transformReportReasons;
     /**
      * Transform API comment response to Comment type
      */
@@ -2045,6 +2401,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
+ *     }),
+ *   },
+ * });
+ * ```
  */
 
 /**
@@ -2053,22 +2437,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
@@ -2080,9 +2477,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
      */
@@ -2101,12 +2512,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
@@ -2114,6 +2536,109 @@ declare class RESTAnalyticsAdapter implements IAnalytics {
  */
 declare function createNoOpAnalyticsAdapter(): IAnalytics;
 
+/**
+ * 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
  *
@@ -2228,4 +2753,4 @@ declare class RESTCommentAdapter implements ICommentAdapter {
     private unwrapResponse;
 }
 
-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, 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, RESTCommentAdapter, type RESTCommentAdapterConfig, 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 };
+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, 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, MockPlaylistAdapter, 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 };