@harmoni-org/sdk 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,712 @@
+import { AxiosRequestConfig, AxiosResponse } from 'axios';
+
+interface HttpClientConfig {
+    baseURL: string;
+    timeout?: number;
+    headers?: Record<string, string>;
+    withCredentials?: boolean;
+    retryConfig?: RetryConfig;
+}
+interface RetryConfig {
+    maxRetries?: number;
+    retryDelay?: number;
+    retryableStatuses?: number[];
+}
+interface RequestInterceptor {
+    onFulfilled?: (config: AxiosRequestConfig) => AxiosRequestConfig | Promise<AxiosRequestConfig>;
+    onRejected?: (error: unknown) => void | Promise<void>;
+}
+interface ResponseInterceptor {
+    onFulfilled?: (response: AxiosResponse) => AxiosResponse | Promise<AxiosResponse>;
+    onRejected?: (error: unknown) => unknown;
+}
+interface RequestConfig extends AxiosRequestConfig {
+    skipAuth?: boolean;
+    skipRetry?: boolean;
+    _retry?: boolean;
+    _retryCount?: number;
+}
+
+declare class HttpClient {
+    private config;
+    private client;
+    private authToken;
+    private refreshTokenFn?;
+    private retryCount;
+    constructor(config: HttpClientConfig);
+    private setupInterceptors;
+    private shouldRetry;
+    private retryRequest;
+    private getRequestId;
+    private sleep;
+    private handleError;
+    setAuthToken(token: string | null): void;
+    getAuthToken(): string | null;
+    setRefreshTokenFunction(fn: () => Promise<string>): void;
+    addRequestInterceptor(interceptor: RequestInterceptor): number;
+    addResponseInterceptor(interceptor: ResponseInterceptor): number;
+    removeRequestInterceptor(id: number): void;
+    removeResponseInterceptor(id: number): void;
+    get<T>(url: string, config?: RequestConfig): Promise<T>;
+    post<T>(url: string, data?: unknown, config?: RequestConfig): Promise<T>;
+    put<T>(url: string, data?: unknown, config?: RequestConfig): Promise<T>;
+    patch<T>(url: string, data?: unknown, config?: RequestConfig): Promise<T>;
+    delete<T>(url: string, config?: RequestConfig): Promise<T>;
+}
+
+declare const USER_ACTIONS: {
+    readonly PLAY: "PLAY";
+    readonly PAUSE: "PAUSE";
+    readonly SEEK: "SEEK";
+    readonly FILE_UPDATE: "FILE_UPDATE";
+    readonly STOP: "STOP";
+    readonly VOLUME_UPDATE: "VOLUME_UPDATE";
+    readonly ENTER_FULLSCREEN: "ENTER_FULLSCREEN";
+    readonly EXIT_FULLSCREEN: "EXIT_FULLSCREEN";
+    readonly SPEED_UPDATE: "SPEED_UPDATE";
+    readonly AUDIO_DELAY_UPDATE: "AUDIO_DELAY_UPDATE";
+    readonly SUBTITLE_DELAY_UPDATE: "SUBTITLE_DELAY_UPDATE";
+    readonly ASPECT_RATIO_UPDATE: "ASPECT_RATIO_UPDATE";
+    readonly TOGGLE_REPEAT: "TOGGLE_REPEAT";
+    readonly TOGGLE_LOOP: "TOGGLE_LOOP";
+    readonly VIDEO_EFFECT_UPDATE: "VIDEO_EFFECT_UPDATE";
+    readonly AUDIO_FILTER_UPDATE: "AUDIO_FILTER_UPDATE";
+    readonly TOGGLE_RANDOM: "TOGGLE_RANDOM";
+    readonly API_VERSION_UPDATE: "API_VERSION_UPDATE";
+    readonly PLAYLIST_UPDATE: "PLAYLIST_UPDATE";
+    readonly TITLE_OR_CHAPTER_UPDATE: "TITLE_OR_CHAPTER_UPDATE";
+    readonly NO_CHANGE: "NO_CHANGE";
+};
+type UserActionType = (typeof USER_ACTIONS)[keyof typeof USER_ACTIONS];
+
+interface SyncState {
+    time: number;
+    isPlaying: boolean;
+    lastUpdated: number;
+    syncErrorMargin: number;
+}
+interface RoomInfo {
+    name: string;
+    description?: string;
+    ownerId: string;
+    isPrivate: boolean;
+    status: string;
+    createdAt: number;
+    lastActivity: number;
+    roomType: string;
+}
+interface RoomMember {
+    userId: string;
+    username: string;
+    clientId: string;
+    active: boolean;
+    role: string;
+    typing: boolean;
+    lastActivity: number;
+}
+interface FileInfo {
+    fileId: string;
+    userId: string;
+    name: string;
+    fullTime: number;
+    hash: string;
+}
+interface ChatMessage {
+    messageId: string;
+    userId: string;
+    username: string;
+    content: string;
+    timestamp: string;
+    systemMessage?: boolean;
+    replyTo?: string;
+    edited?: boolean;
+    deleted?: boolean;
+}
+interface Room {
+    roomId: string;
+    roomInfo: RoomInfo;
+    syncState: SyncState;
+    members: RoomMember[];
+    files: FileInfo[];
+    chat: ChatMessage[];
+}
+interface RoomUpdate {
+    roomId: string;
+    roomUpdates: Partial<Room>;
+    metadata: {
+        action: string;
+        userId: string;
+        username?: string;
+    };
+}
+declare const SyncActions: {
+    readonly PLAY: "play";
+    readonly PAUSE: "pause";
+    readonly SEEK: "seek";
+};
+type SyncAction = (typeof SyncActions)[keyof typeof SyncActions];
+
+interface JoinRoomPayload {
+    roomId?: string;
+    roomName?: string;
+    password?: string;
+}
+interface SyncUpdatePayload {
+    roomId: string;
+    action: SyncAction;
+    value?: number;
+}
+interface UpdateFileInfoPayload {
+    roomId: string;
+    fileInfo: {
+        fileId: string;
+        name: string;
+        fullTime: number;
+        hash: string;
+    };
+}
+interface ChatSendPayload {
+    roomId: string;
+    text: string;
+    tempMessageId?: string;
+}
+declare const WatchTogetherErrorCodes: {
+    readonly ROOM_NOT_FOUND: "ROOM_NOT_FOUND";
+    readonly UNAUTHORIZED: "UNAUTHORIZED";
+    readonly ROOM_FULL: "ROOM_FULL";
+    readonly INVALID_PASSWORD: "INVALID_PASSWORD";
+    readonly NOT_IN_ROOM: "NOT_IN_ROOM";
+    readonly PERMISSION_DENIED: "PERMISSION_DENIED";
+    readonly CONNECTION_ERROR: "CONNECTION_ERROR";
+    readonly ALREADY_IN_ROOM: "ALREADY_IN_ROOM";
+};
+declare const WatchTogetherConstants: {
+    readonly NAMESPACE: "/watch-together";
+    readonly SYNC_CHECK_INTERVAL_MS: 30000;
+    readonly SYNC_TOLERANCE_SECONDS: 1;
+    readonly MAX_RECONNECT_ATTEMPTS: 5;
+    readonly RECONNECT_DELAY_MS: 2000;
+};
+declare const WatchTogetherIDs: {
+    JOIN_ROOM_INPUT: string;
+    JOIN_AND_INVITE_SECTION: string;
+    JOIN_BUTTON: string;
+    START_BUTTON: string;
+    LEAVE_BUTTON: string;
+    JOINED_ROOM_SECTION: string;
+    ACTION_SECTION: string;
+    CREATE_ROOM_BUTTON: string;
+};
+declare const SECTION_NAMES: {
+    JOIN_AND_INVITE: string;
+    JOINED_ROOM: string;
+};
+declare const WatchTogetherMessages: {
+    START_SUCCESS: string;
+    JOIN_SUCCESS: string;
+    LEAVE_SUCCESS: string;
+    INVALID_ARGS: string;
+    CONNECTION_SUCCESS: string;
+    DISCONNECTED: string;
+};
+
+interface IPlayerState {
+    isPlaying: boolean;
+    currentTime: number;
+    loop: boolean;
+    repeat: boolean;
+    title: string;
+    chapter: string;
+    filename: string;
+    duration: number;
+    filepath: string;
+}
+interface VideoEffects {
+    contrast: number;
+    gamma: number;
+    hue: number;
+    brightness: number;
+    saturation: number;
+}
+interface ExtendedPlayerState extends IPlayerState {
+    volume: number;
+    fullscreen: boolean;
+    rate: number;
+    audiodelay: number;
+    subtitledelay: number;
+    aspectratio: string | null;
+    videoeffects: VideoEffects;
+    audiofilters: Record<string, unknown>;
+    random: boolean;
+}
+
+interface UserAction {
+    event: UserActionType;
+    value?: {
+        isPlaying?: boolean;
+        currentTime?: number;
+        filename?: string | null;
+        loop?: boolean;
+        repeat?: boolean;
+        title?: string;
+        chapter?: string;
+        [key: string]: unknown;
+    };
+}
+interface VideoPlayerController {
+    start(onReady?: () => void): Promise<void>;
+    quit(): Promise<void>;
+    play(): Promise<void>;
+    pause(): Promise<void>;
+    stop(): Promise<void>;
+    seek(timeInSeconds: number): Promise<void>;
+    loadMedia(source: string): Promise<void>;
+    getStatus(): Promise<IPlayerState>;
+    checkPlayerRunning(): Promise<boolean>;
+    observeStatusChange(onChange: (events: UserAction[], source: 'app' | 'user') => void, onStop: () => void, intervalMs?: number): void;
+    displayMessage?(message: string, durationSeconds?: number): Promise<void>;
+}
+declare const PlayerConstants: {
+    readonly DEFAULT_POLLING_INTERVAL_MS: 2000;
+    readonly SEEK_THRESHOLD_SECONDS: 0.5;
+    readonly COMMAND_STACK_TIMEOUT_MS: 3000;
+    readonly MIN_INTERVAL_MS: 100;
+};
+
+interface PaginationParams {
+    page?: number;
+    limit?: number;
+    offset?: number;
+}
+interface PaginatedResponse<T> {
+    data: T[];
+    total: number;
+    page: number;
+    limit: number;
+    hasMore: boolean;
+}
+interface SortParams {
+    sortBy?: string;
+    sortOrder?: 'asc' | 'desc';
+}
+interface FilterParams {
+    [key: string]: string | number | boolean | undefined;
+}
+interface ApiResponse<T> {
+    data: T;
+    meta?: {
+        timestamp: string;
+    };
+    error?: {
+        code: string;
+        message: string;
+    };
+}
+interface BaseUser {
+    id: string;
+    username: string;
+    email: string;
+}
+interface User extends BaseUser {
+    token: string;
+    refreshToken: string;
+}
+interface LoginResponse {
+    user: Omit<User, 'token' | 'refreshToken'>;
+    accessToken: string;
+    refreshToken: string;
+}
+interface RegisterResponse {
+    user: Omit<User, 'token' | 'refreshToken'>;
+    accessToken: string;
+    refreshToken: string;
+}
+interface VerifyTokenResponse {
+    user: BaseUser & {
+        createdAt: string;
+    };
+}
+interface RefreshTokenResponse {
+    accessToken: string;
+}
+interface LoginCredentials {
+    emailOrUsername: string;
+    password: string;
+}
+interface RegisterData {
+    username: string;
+    password: string;
+    email?: string;
+}
+type ValidationStatus = 'idle' | 'checking' | 'taken' | 'available' | 'error';
+
+declare class AuthModule {
+    private http;
+    constructor(http: HttpClient);
+    login(credentials: LoginCredentials): Promise<User>;
+    register(data: RegisterData): Promise<User>;
+    verifyToken(): Promise<VerifyTokenResponse>;
+    refreshAccessToken(): Promise<string>;
+    isEmailUnique(email: string): Promise<boolean>;
+    isUsernameUnique(username: string): Promise<boolean>;
+    logout(): Promise<void>;
+    requestPasswordReset(email: string): Promise<void>;
+    resetPassword(token: string, newPassword: string): Promise<void>;
+    changePassword(currentPassword: string, newPassword: string): Promise<void>;
+    verifyEmail(token: string): Promise<void>;
+    resendVerificationEmail(email: string): Promise<void>;
+}
+
+interface UpdateUserData {
+    username?: string;
+    email?: string;
+}
+interface UserProfile extends BaseUser {
+    bio?: string;
+    avatar?: string;
+    phone?: string;
+    createdAt?: string;
+    updatedAt?: string;
+}
+declare class UserModule {
+    private http;
+    constructor(http: HttpClient);
+    getById(userId: string): Promise<UserProfile>;
+    getCurrentUser(): Promise<UserProfile>;
+    updateProfile(data: UpdateUserData): Promise<UserProfile>;
+    deleteAccount(): Promise<void>;
+    list(params?: PaginationParams & FilterParams): Promise<PaginatedResponse<BaseUser>>;
+    search(query: string, params?: PaginationParams): Promise<PaginatedResponse<BaseUser>>;
+    uploadAvatar(file: File | Blob, fileName?: string): Promise<{
+        url: string;
+    }>;
+    deleteAvatar(): Promise<void>;
+}
+
+type EventCallback<T> = (data: T) => void;
+interface WatchTogetherConfig {
+    baseURL: string;
+    namespace?: string;
+    autoConnect?: boolean;
+    persistentConnection?: boolean;
+}
+interface ConnectionStatus {
+    connected: boolean;
+    connecting: boolean;
+    authenticated: boolean;
+    inRoom: boolean;
+    roomId: string | null;
+    error: string | null;
+}
+declare class WatchTogetherModule {
+    private http;
+    private config;
+    private socket;
+    private currentRoom;
+    private syncInterval;
+    private eventListeners;
+    private connectionStatus;
+    private shouldStayConnected;
+    constructor(http: HttpClient, config: WatchTogetherConfig);
+    private initializePersistentConnection;
+    connect(): Promise<void>;
+    disconnect(): void;
+    enablePersistentConnection(): void;
+    disablePersistentConnection(): void;
+    createRoom(options?: {
+        roomName?: string;
+    }): Promise<Room>;
+    joinRoom(options: JoinRoomPayload): Promise<Room>;
+    leaveRoom(): void;
+    play(): void;
+    pause(): void;
+    seek(timeInSeconds: number): void;
+    requestSync(): void;
+    updateFileInfo(fileInfo: Omit<FileInfo, 'userId'>): void;
+    sendMessage(text: string): Promise<void>;
+    getChatHistory(): ChatMessage[];
+    getCurrentRoom(): Room | null;
+    isConnected(): boolean;
+    isInRoom(): boolean;
+    getConnectionStatus(): ConnectionStatus;
+    isOnline(): boolean;
+    onRoomState(callback: EventCallback<Room>): () => void;
+    onRoomUpdate(callback: EventCallback<RoomUpdate>): () => void;
+    onSyncState(callback: EventCallback<SyncState>): () => void;
+    onChatMessage(callback: EventCallback<ChatMessage>): () => void;
+    onSystemMessage(callback: EventCallback<ChatMessage>): () => void;
+    onChatHistory(callback: EventCallback<ChatMessage[]>): () => void;
+    onError(callback: EventCallback<{
+        code: string;
+        message: string;
+    }>): () => void;
+    onConnect(callback: EventCallback<void>): () => void;
+    onDisconnect(callback: EventCallback<string>): () => void;
+    onConnectionStatusChange(callback: EventCallback<ConnectionStatus>): () => void;
+    onOnlineStatusChange(callback: EventCallback<boolean>): () => void;
+    private setupSocketListeners;
+    private refreshTokenAndReconnect;
+    updateAuthToken(token: string): void;
+    private updateConnectionStatus;
+    private updateSyncState;
+    private startSyncCheck;
+    private stopSyncCheck;
+    private ensureConnected;
+    private ensureInRoom;
+    private addEventListener;
+    private emit;
+}
+
+declare class WatchTogetherError extends Error {
+    readonly code: string;
+    readonly details?: Record<string, unknown> | undefined;
+    readonly isWatchTogetherError = true;
+    constructor(message: string, code: string, details?: Record<string, unknown> | undefined);
+    toJSON(): {
+        name: string;
+        message: string;
+        code: string;
+        details?: Record<string, unknown>;
+    };
+    static isWatchTogetherError(error: unknown): error is WatchTogetherError;
+}
+
+interface HarmoniSDKConfig extends HttpClientConfig {
+    autoRefreshToken?: boolean;
+    watchTogetherNamespace?: string;
+    persistentConnection?: boolean;
+}
+declare class HarmoniSDK {
+    private httpClient;
+    readonly auth: AuthModule;
+    readonly user: UserModule;
+    readonly watchTogether: WatchTogetherModule;
+    constructor(config: HarmoniSDKConfig);
+    private setupAutoRefresh;
+    setAuthToken(token: string | null): void;
+    getAuthToken(): string | null;
+    private storeAccessToken;
+    getHttpClient(): HttpClient;
+}
+
+interface ApiErrorResponse {
+    message: string;
+    code?: string;
+    status?: number;
+    details?: unknown;
+}
+declare class ApiError extends Error {
+    readonly status: number;
+    readonly code?: string;
+    readonly details?: unknown;
+    readonly isApiError = true;
+    constructor(message: string, status: number, code?: string, details?: unknown);
+    toJSON(): ApiErrorResponse;
+    static isApiError(error: unknown): error is ApiError;
+}
+declare class NetworkError extends ApiError {
+    constructor(message?: string);
+}
+declare class TimeoutError extends ApiError {
+    constructor(message?: string);
+}
+declare class UnauthorizedError extends ApiError {
+    constructor(message?: string);
+}
+declare class ForbiddenError extends ApiError {
+    constructor(message?: string);
+}
+declare class NotFoundError extends ApiError {
+    constructor(message?: string);
+}
+declare class ValidationError extends ApiError {
+    constructor(message?: string, details?: unknown);
+}
+
+declare function capitalize(str: string): string;
+declare function titleCase(str: string): string;
+declare function camelToSnake(str: string): string;
+declare function snakeToCamel(str: string): string;
+declare function truncate(str: string, length: number, suffix?: string): string;
+declare function isValidEmail(email: string): boolean;
+declare function randomString(length: number): string;
+declare function slugify(str: string): string;
+
+declare const string_camelToSnake: typeof camelToSnake;
+declare const string_capitalize: typeof capitalize;
+declare const string_isValidEmail: typeof isValidEmail;
+declare const string_randomString: typeof randomString;
+declare const string_slugify: typeof slugify;
+declare const string_snakeToCamel: typeof snakeToCamel;
+declare const string_titleCase: typeof titleCase;
+declare const string_truncate: typeof truncate;
+declare namespace string {
+  export { string_camelToSnake as camelToSnake, string_capitalize as capitalize, string_isValidEmail as isValidEmail, string_randomString as randomString, string_slugify as slugify, string_snakeToCamel as snakeToCamel, string_titleCase as titleCase, string_truncate as truncate };
+}
+
+declare function toISOString(date: Date | string | number): string;
+declare function isValidDate(date: unknown): boolean;
+declare function timeAgo(date: Date | string | number): string;
+declare function addDays(date: Date, days: number): Date;
+declare function addHours(date: Date, hours: number): Date;
+declare function formatDate(date: Date | string | number, format?: string): string;
+declare function isToday(date: Date | string | number): boolean;
+declare function isPast(date: Date | string | number): boolean;
+declare function isFuture(date: Date | string | number): boolean;
+
+declare const date_addDays: typeof addDays;
+declare const date_addHours: typeof addHours;
+declare const date_formatDate: typeof formatDate;
+declare const date_isFuture: typeof isFuture;
+declare const date_isPast: typeof isPast;
+declare const date_isToday: typeof isToday;
+declare const date_isValidDate: typeof isValidDate;
+declare const date_timeAgo: typeof timeAgo;
+declare const date_toISOString: typeof toISOString;
+declare namespace date {
+  export { date_addDays as addDays, date_addHours as addHours, date_formatDate as formatDate, date_isFuture as isFuture, date_isPast as isPast, date_isToday as isToday, date_isValidDate as isValidDate, date_timeAgo as timeAgo, date_toISOString as toISOString };
+}
+
+declare function deepClone<T>(obj: T): T;
+declare function deepMerge<T extends Record<string, unknown>>(target: T, source: Partial<T>): T;
+declare function isObject(value: unknown): value is Record<string, unknown>;
+declare function pick<T extends Record<string, unknown>, K extends keyof T>(obj: T, keys: K[]): Pick<T, K>;
+declare function omit<T extends Record<string, unknown>, K extends keyof T>(obj: T, keys: K[]): Omit<T, K>;
+declare function isEmpty(obj: unknown): boolean;
+declare function getNestedValue<T>(obj: unknown, path: string): T | undefined;
+declare function setNestedValue(obj: Record<string, unknown>, path: string, value: unknown): void;
+
+declare const object_deepClone: typeof deepClone;
+declare const object_deepMerge: typeof deepMerge;
+declare const object_getNestedValue: typeof getNestedValue;
+declare const object_isEmpty: typeof isEmpty;
+declare const object_isObject: typeof isObject;
+declare const object_omit: typeof omit;
+declare const object_pick: typeof pick;
+declare const object_setNestedValue: typeof setNestedValue;
+declare namespace object {
+  export { object_deepClone as deepClone, object_deepMerge as deepMerge, object_getNestedValue as getNestedValue, object_isEmpty as isEmpty, object_isObject as isObject, object_omit as omit, object_pick as pick, object_setNestedValue as setNestedValue };
+}
+
+declare function validateEmail(email: string): {
+    valid: boolean;
+    message?: string;
+};
+declare function validatePassword(password: string, options?: {
+    minLength?: number;
+    requireUppercase?: boolean;
+    requireLowercase?: boolean;
+    requireNumbers?: boolean;
+    requireSpecialChars?: boolean;
+}): {
+    valid: boolean;
+    message?: string;
+};
+declare function validateUrl(url: string): {
+    valid: boolean;
+    message?: string;
+};
+declare function validatePhone(phone: string): {
+    valid: boolean;
+    message?: string;
+};
+declare function required(value: unknown, fieldName?: string): {
+    valid: boolean;
+    message?: string;
+};
+declare function minLength(value: string, min: number, fieldName?: string): {
+    valid: boolean;
+    message?: string;
+};
+declare function maxLength(value: string, max: number, fieldName?: string): {
+    valid: boolean;
+    message?: string;
+};
+
+declare const validation_maxLength: typeof maxLength;
+declare const validation_minLength: typeof minLength;
+declare const validation_required: typeof required;
+declare const validation_validateEmail: typeof validateEmail;
+declare const validation_validatePassword: typeof validatePassword;
+declare const validation_validatePhone: typeof validatePhone;
+declare const validation_validateUrl: typeof validateUrl;
+declare namespace validation {
+  export { validation_maxLength as maxLength, validation_minLength as minLength, validation_required as required, validation_validateEmail as validateEmail, validation_validatePassword as validatePassword, validation_validatePhone as validatePhone, validation_validateUrl as validateUrl };
+}
+
+declare class Storage {
+    private storage;
+    private memoryStorage;
+    constructor(type?: 'local' | 'session');
+    set<T>(key: string, value: T): void;
+    get<T>(key: string): T | null;
+    remove(key: string): void;
+    clear(): void;
+    has(key: string): boolean;
+    keys(): string[];
+    isAvailable(): boolean;
+}
+declare const localStorage: Storage;
+declare const sessionStorage: Storage;
+
+declare class PlayerStatusMonitor {
+    private player;
+    private onStateChange;
+    private onStop;
+    private pollingIntervalMs;
+    private lastKnownState;
+    private lastCheckTime;
+    private pollingTimer;
+    private isRunning;
+    constructor(player: VideoPlayerController, onStateChange: (actions: UserAction[], source: 'app' | 'user') => void, onStop: () => void, pollingIntervalMs?: number);
+    start(): void;
+    stop(): void;
+    getIsRunning(): boolean;
+    getLastKnownState(): IPlayerState | null;
+    updateLastKnownState(state: IPlayerState): void;
+    private checkStatus;
+    protected determineActionSource(_actions: UserAction[]): 'app' | 'user';
+}
+
+declare class HTML5VideoController implements VideoPlayerController {
+    private videoElementId;
+    private video;
+    private statusMonitor;
+    constructor(videoElementId: string);
+    start(onReady?: () => void): Promise<void>;
+    play(): Promise<void>;
+    pause(): Promise<void>;
+    stop(): Promise<void>;
+    seek(timeInSeconds: number): Promise<void>;
+    loadMedia(source: string): Promise<void>;
+    getStatus(): Promise<IPlayerState>;
+    checkPlayerRunning(): Promise<boolean>;
+    quit(): Promise<void>;
+    observeStatusChange(onChange: (events: UserAction[], source: 'app' | 'user') => void, onStop: () => void, intervalMs?: number): void;
+    displayMessage(message: string, durationSeconds?: number): Promise<void>;
+    getVideoElement(): HTMLVideoElement | null;
+}
+
+declare class SyncedPlayer {
+    private player;
+    private watchTogether;
+    private options;
+    private commandStack;
+    private currentUserId;
+    private unsubscribers;
+    constructor(player: VideoPlayerController, watchTogether: WatchTogetherModule, options: {
+        getCurrentUserId: () => string | null;
+        onPlayerStopped?: () => void;
+    });
+    private setupListeners;
+    private handleRemoteSyncUpdate;
+    private handleLocalPlayerChange;
+    private popMatchingCommand;
+    private eventToAction;
+    destroy(): void;
+}
+
+declare function identifyUserActions(oldState: IPlayerState | null, newState: IPlayerState | null, intervalMs: number): UserAction[];
+declare function normalizePlayerState(state: Partial<IPlayerState>): IPlayerState;
+
+export { ApiError, type ApiErrorResponse, type ApiResponse, AuthModule, type BaseUser, type ChatMessage, type ChatSendPayload, type ConnectionStatus, type ExtendedPlayerState, type FileInfo, type FilterParams, ForbiddenError, HTML5VideoController, HarmoniSDK, type HarmoniSDKConfig, HttpClient, type HttpClientConfig, type IPlayerState, type JoinRoomPayload, type LoginCredentials, type LoginResponse, NetworkError, NotFoundError, type PaginatedResponse, type PaginationParams, PlayerConstants, PlayerStatusMonitor, type RefreshTokenResponse, type RegisterData, type RegisterResponse, type RequestConfig, type RequestInterceptor, type ResponseInterceptor, type RetryConfig, type Room, type RoomInfo, type RoomMember, type RoomUpdate, SECTION_NAMES, type SortParams, Storage, type SyncAction, SyncActions, type SyncState, type SyncUpdatePayload, SyncedPlayer, TimeoutError, USER_ACTIONS, UnauthorizedError, type UpdateFileInfoPayload, type UpdateUserData, type User, type UserAction, type UserActionType, UserModule, type UserProfile, ValidationError, type ValidationStatus, type VerifyTokenResponse, type VideoEffects, type VideoPlayerController, type WatchTogetherConfig, WatchTogetherConstants, WatchTogetherError, WatchTogetherErrorCodes, WatchTogetherIDs, WatchTogetherMessages, WatchTogetherModule, date as dateUtils, HarmoniSDK as default, identifyUserActions, localStorage, normalizePlayerState, object as objectUtils, sessionStorage, string as stringUtils, validation as validationUtils };