@francofantomius/jellyfin 0.1.0 → 0.4.0

package/dist/index.d.cts

@@ -187,6 +187,15 @@ interface BaseItemDto {
     BackdropImageTags?: string[];
     MediaSources?: MediaSourceInfo[];
     HasLyrics?: boolean;
+    /**
+     * Trickplay thumbnail metadata dictionary (Jellyfin 10.9+).
+     * Keyed by MediaSourceId -> Width string -> TrickplayInfoDto.
+     */
+    Trickplay?: Record<string, Record<string, TrickplayInfoDto>> | null;
+    /**
+     * Chapter markers associated with the media item.
+     */
+    Chapters?: ChapterInfoDto[];
     /**
      * Unique relational playlist entry ID (Jellyfin 12+).
      * Distinguishes duplicate tracks inside the same playlist.
@@ -255,7 +264,17 @@ interface GetSongsOptions {
 interface SearchOptions {
     limit?: number;
     startIndex?: number;
-    includeItemTypes?: string;
+    parentId?: string;
+    includeItemTypes?: string | string[];
+    mediaTypes?: string | string[];
+    genres?: string[];
+    years?: number[];
+    isFavorite?: boolean;
+    sortBy?: string;
+    sortOrder?: 'Ascending' | 'Descending';
+    fields?: string;
+    recursive?: boolean;
+    userId?: string;
 }
 interface CreatePlaylistDto {
     Name: string;
@@ -279,12 +298,14 @@ interface UpdatePlaylistOptions {
     name?: string;
 }
 interface AudioStreamOptions {
+    static?: boolean;
     maxStreamingBitrate?: string | number;
     quality?: AudioQualityPresetKey | AudioQualityOption | number | string;
     startTimeTicks?: number;
     container?: string;
     transcodingContainer?: string;
     audioCodec?: string;
+    deviceId?: string;
     /**
      * Whether to include the api_key token in the URL query parameters.
      * Defaults to true for HTML5 <audio> tag compatibility.
@@ -298,6 +319,7 @@ interface AudioHlsStreamOptions {
     startTimeTicks?: number;
     audioCodec?: string;
     segmentLength?: number;
+    deviceId?: string;
     /**
      * Whether to include the api_key token in the URL query parameters.
      * Defaults to true for legacy compatibility.
@@ -435,6 +457,7 @@ interface VideoStreamOptions {
     container?: string;
     transcodingContainer?: string;
     transcodingProtocol?: string;
+    deviceId?: string;
     useQueryToken?: boolean;
 }
 interface VideoHlsStreamOptions {
@@ -446,14 +469,15 @@ interface VideoHlsStreamOptions {
     maxWidth?: number;
     maxHeight?: number;
     maxFramerate?: number;
-    segmentLength?: number;
-    minSegments?: number;
     audioStreamIndex?: number;
     subtitleStreamIndex?: number;
     subtitleMethod?: 'Embed' | 'Encode' | 'Hls' | 'External';
+    startTimeTicks?: number;
+    segmentLength?: number;
+    minSegments?: number;
     transcodingContainer?: 'ts' | 'fmp4' | string;
     transcodingProtocol?: 'hls';
-    startTimeTicks?: number;
+    deviceId?: string;
     useQueryToken?: boolean;
 }
 interface SubtitleTrackInfo {
@@ -491,6 +515,322 @@ interface DownloadItemOptions {
     index?: number;
     quality?: VideoQualityPresetKey | VideoQualityOption | number | string;
 }
+interface GetResumeItemsOptions {
+    userId?: string;
+    limit?: number;
+    startIndex?: number;
+    parentId?: string;
+    mediaTypes?: string[];
+    enableImages?: boolean;
+    enableUserData?: boolean;
+    imageTypeLimit?: number;
+    enableImageTypes?: string[];
+    fields?: string;
+}
+interface GetNextUpOptions {
+    userId?: string;
+    parentId?: string;
+    seriesId?: string;
+    limit?: number;
+    startIndex?: number;
+    fields?: string;
+    enableImages?: boolean;
+    enableUserData?: boolean;
+    enableTotalRecordCount?: boolean;
+    imageTypeLimit?: number;
+    enableImageTypes?: string[];
+    disableFirstEpisode?: boolean;
+    nextUpDateCutoff?: string;
+}
+interface GetLatestMediaOptions {
+    userId?: string;
+    parentId?: string;
+    limit?: number;
+    fields?: string;
+    includeItemTypes?: string[];
+    isPlayed?: boolean;
+    enableImages?: boolean;
+    imageTypeLimit?: number;
+    enableImageTypes?: string[];
+    groupItems?: boolean;
+}
+interface StopActiveEncodingOptions {
+    playSessionId: string;
+    deviceId?: string;
+}
+type WebSocketMessageType = 'KeepAlive' | 'ForceKeepAlive' | 'LibraryChanged' | 'UserDataChanged' | 'Sessions' | 'Play' | 'Playstate' | 'GeneralCommand' | 'ActivityLogEntry' | 'ScheduledTasksInfo' | 'ScheduledTasksInfoStop' | 'SessionsStart' | 'SessionsStop' | (string & {});
+interface WebSocketInboundMessage<T = unknown> {
+    MessageType: WebSocketMessageType;
+    MessageId?: string;
+    Data?: T;
+}
+interface LibraryChangedData {
+    FoldersAddedTo?: string[];
+    FoldersRemovedFrom?: string[];
+    ItemsAdded?: string[];
+    ItemsUpdated?: string[];
+    ItemsRemoved?: string[];
+    CollectionFolders?: string[];
+    EmptyFolders?: string[];
+}
+interface UserDataChangedData {
+    UserId: string;
+    UserDataList: UserItemDataDto[];
+}
+interface WebSocketModuleOptions {
+    url?: string;
+    autoReconnect?: boolean;
+    reconnectIntervalMs?: number;
+    maxReconnectAttempts?: number;
+    keepAliveIntervalMs?: number;
+    webSocketFactory?: (url: string) => any;
+}
+interface SessionPlayState {
+    PositionTicks?: number;
+    CanSeek?: boolean;
+    IsPaused?: boolean;
+    IsMuted?: boolean;
+    VolumeLevel?: number;
+    AudioStreamIndex?: number;
+    SubtitleStreamIndex?: number;
+    MediaSourceId?: string;
+    PlayMethod?: string;
+    RepeatMode?: string;
+    PlaylistItemId?: string;
+}
+interface SessionInfoDto {
+    Id: string;
+    UserId?: string;
+    UserName?: string;
+    Client?: string;
+    LastActivityDate?: string;
+    LastPlaybackCheckIn?: string;
+    DeviceName?: string;
+    DeviceType?: string;
+    NowPlayingItem?: BaseItemDto;
+    NowViewingItem?: BaseItemDto;
+    DeviceId?: string;
+    ApplicationVersion?: string;
+    IsActive?: boolean;
+    SupportsMediaControl?: boolean;
+    SupportsRemoteControl?: boolean;
+    PlayableMediaTypes?: string[];
+    SupportedCommands?: string[];
+    TranscodingInfo?: Record<string, unknown>;
+    PlayState?: SessionPlayState;
+    AdditionalUsers?: Array<{
+        UserId: string;
+        UserName: string;
+    }>;
+    Capabilities?: Record<string, unknown>;
+}
+interface GetSessionsOptions {
+    controllableByUserId?: string;
+    deviceId?: string;
+    activeWithinSeconds?: number;
+}
+type PlayCommandType = 'PlayNow' | 'PlayNext' | 'PlayLast';
+interface RemotePlayOptions {
+    playCommand?: PlayCommandType;
+    startPositionTicks?: number;
+    mediaSourceId?: string;
+    audioStreamIndex?: number;
+    subtitleStreamIndex?: number;
+    startIndex?: number;
+}
+type PlaystateCommand = 'PlayPause' | 'Pause' | 'Unpause' | 'Stop' | 'Seek' | 'NextTrack' | 'PreviousTrack';
+type GeneralCommandType = 'MoveUp' | 'MoveDown' | 'MoveLeft' | 'MoveRight' | 'PageUp' | 'PageDown' | 'PreviousLetter' | 'NextLetter' | 'ToggleOsd' | 'ToggleContextMenu' | 'Select' | 'Back' | 'TakeScreenshot' | 'SendKey' | 'SendString' | 'GoHome' | 'GoToSettings' | 'VolumeUp' | 'VolumeDown' | 'Mute' | 'Unmute' | 'ToggleMute' | 'SetVolume' | 'SetAudioStreamIndex' | 'SetSubtitleStreamIndex' | 'DisplayContent' | 'DisplayMessage' | (string & {});
+interface GeneralCommandDto {
+    Name: GeneralCommandType;
+    Arguments?: Record<string, string>;
+}
+interface SessionMessageOptions {
+    header?: string;
+    text: string;
+    timeoutMs?: number;
+}
+interface QuickConnectResult {
+    Code: string;
+    Secret: string;
+    AuthenticationToken?: string;
+}
+interface QuickConnectState {
+    Authenticated: boolean;
+    Secret: string;
+    Code?: string;
+    AuthenticationToken?: string;
+    UserId?: string;
+    DateAdded?: string;
+}
+interface QuickConnectPollOptions {
+    intervalMs?: number;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}
+/**
+ * Metadata describing generated trickplay tiles for scrubbing previews (Jellyfin 10.9+).
+ */
+interface TrickplayInfoDto {
+    Width: number;
+    Height: number;
+    TileWidth: number;
+    TileHeight: number;
+    ThumbnailCount: number;
+    Interval: number;
+    Bandwidth: number;
+}
+interface TrickplayStreamOptions {
+    mediaSourceId?: string;
+    useQueryToken?: boolean;
+}
+interface TrickplayManifestTile {
+    index: number;
+    durationMs: number;
+    url: string;
+}
+interface TrickplayManifestInfo {
+    width: number;
+    rawM3u8: string;
+    tiles: TrickplayManifestTile[];
+}
+interface ThumbnailLookupOptions {
+    item?: BaseItemDto;
+    trickplayInfo?: TrickplayInfoDto;
+    timestampMs?: number;
+    timestampTicks?: number;
+    width?: number;
+    mediaSourceId?: string;
+    useQueryToken?: boolean;
+}
+interface ThumbnailLookupResult {
+    tileIndex: number;
+    imageUrl: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    thumbnailIndex: number;
+}
+/**
+ * Chapter marker within a media item.
+ */
+interface ChapterInfoDto {
+    StartPositionTicks: number;
+    Name?: string;
+    ImageTag?: string;
+    ImagePath?: string;
+    ImageDateModified?: string;
+    MarkerType?: 'IntroStart' | 'IntroEnd' | 'CreditsStart' | 'CreditsEnd' | (string & {});
+}
+interface ChapterImageOptions {
+    maxWidth?: number;
+    maxHeight?: number;
+    width?: number;
+    height?: number;
+    quality?: number;
+    format?: 'jpg' | 'png' | 'webp';
+    tag?: string;
+    fillWidth?: number;
+    fillHeight?: number;
+    useQueryToken?: boolean;
+}
+type MediaSegmentType = 'Intro' | 'Outro' | 'Preview' | 'Recap' | 'Commercial' | (string & {});
+interface MediaSegmentDto {
+    Id: string;
+    ItemId: string;
+    Type: MediaSegmentType;
+    StartTicks: number;
+    EndTicks: number;
+}
+interface GetMediaSegmentsOptions {
+    includeSegmentTypes?: MediaSegmentType[];
+}
+interface MarkerRange {
+    startTicks: number;
+    endTicks: number;
+    startMs: number;
+    endMs: number;
+}
+interface IntroCreditsMarkers {
+    intro?: MarkerRange;
+    credits?: MarkerRange;
+    segments: MediaSegmentDto[];
+}
+interface GetGenresOptions {
+    parentId?: string;
+    startIndex?: number;
+    limit?: number;
+    searchTerm?: string;
+    sortBy?: string;
+    sortOrder?: 'Ascending' | 'Descending';
+    enableImages?: boolean;
+    imageTypeLimit?: number;
+    enableImageTypes?: string[];
+    userId?: string;
+}
+interface GetStudiosOptions {
+    parentId?: string;
+    startIndex?: number;
+    limit?: number;
+    searchTerm?: string;
+    sortBy?: string;
+    sortOrder?: 'Ascending' | 'Descending';
+    enableImages?: boolean;
+    imageTypeLimit?: number;
+    enableImageTypes?: string[];
+    userId?: string;
+}
+interface GetCollectionsOptions {
+    parentId?: string;
+    startIndex?: number;
+    limit?: number;
+    searchTerm?: string;
+    sortBy?: string;
+    sortOrder?: 'Ascending' | 'Descending';
+    enableImages?: boolean;
+    imageTypeLimit?: number;
+    enableImageTypes?: string[];
+    userId?: string;
+}
+interface GetCollectionItemsOptions {
+    userId?: string;
+    startIndex?: number;
+    limit?: number;
+    fields?: string;
+    sortBy?: string;
+    sortOrder?: 'Ascending' | 'Descending';
+}
+interface CreateCollectionOptions {
+    name: string;
+    ids?: string[];
+    parentId?: string;
+    isFolder?: boolean;
+}
+interface DisplayPreferencesDto {
+    Id?: string;
+    ViewType?: string;
+    SortBy?: string;
+    IndexBy?: string;
+    RememberIndexing?: boolean;
+    PrimaryImageHeight?: number;
+    PrimaryImageWidth?: number;
+    CustomPrefs?: Record<string, string>;
+    ScrollDirection?: 'Horizontal' | 'Vertical' | (string & {});
+    ShowBackdrop?: boolean;
+    RememberSorting?: boolean;
+    SortOrder?: 'Ascending' | 'Descending' | (string & {});
+    ShowSidebar?: boolean;
+    Client?: string;
+    [key: string]: unknown;
+}
+interface GetDisplayPreferencesOptions {
+    userId?: string;
+    client?: string;
+}
+interface UpdateDisplayPreferencesOptions {
+    userId?: string;
+    client?: string;
+}
 
 interface RequestOptions {
     method?: string;
@@ -746,8 +1086,11 @@ declare class PlaybackModule {
     reportProgress(itemId: string, positionTicks?: number, isPaused?: boolean): Promise<void>;
     /**
      * Report that playback has stopped for an item.
+     * Optionally teardown active transcoding session if playSessionId is provided.
      */
-    reportStopped(itemId: string, positionTicks?: number): Promise<void>;
+    reportStopped(itemId: string, positionTicks?: number, options?: {
+        playSessionId?: string;
+    }): Promise<void>;
 }
 
 declare class MediaModule {
@@ -966,6 +1309,494 @@ declare class OfflineStorageManager {
     formatBytes(bytes: number): string;
 }
 
+declare class ResumeModule {
+    private http;
+    private getUserId;
+    constructor(http: HttpTransport, getUserId: () => string);
+    private resolveUserId;
+    /**
+     * Fetch items currently in-progress for the user via /UserItems/Resume.
+     */
+    getResumeItems(options?: GetResumeItemsOptions): Promise<ItemsResponse>;
+    /**
+     * Convenience alias for getResumeItems.
+     */
+    getItems(options?: GetResumeItemsOptions): Promise<ItemsResponse>;
+}
+
+declare class NextUpModule {
+    private http;
+    private getUserId;
+    constructor(http: HttpTransport, getUserId: () => string);
+    private resolveUserId;
+    /**
+     * Fetch the next unplayed episodes for followed series via /Shows/NextUp.
+     */
+    getNextUp(options?: GetNextUpOptions): Promise<ItemsResponse>;
+    /**
+     * Convenience alias for getNextUp.
+     */
+    getEpisodes(options?: GetNextUpOptions): Promise<ItemsResponse>;
+}
+
+declare class LatestModule {
+    private http;
+    private getUserId;
+    constructor(http: HttpTransport, getUserId: () => string);
+    private resolveUserId;
+    /**
+     * Fetch recently added media items for the user via /Users/{userId}/Items/Latest.
+     */
+    getLatest(options?: GetLatestMediaOptions): Promise<BaseItemDto[]>;
+    /**
+     * Convenience helper to fetch recently added movies.
+     */
+    getLatestMovies(options?: Omit<GetLatestMediaOptions, 'includeItemTypes'>): Promise<BaseItemDto[]>;
+    /**
+     * Convenience helper to fetch recently added TV episodes.
+     */
+    getLatestEpisodes(options?: Omit<GetLatestMediaOptions, 'includeItemTypes'>): Promise<BaseItemDto[]>;
+    /**
+     * Convenience helper to fetch recently added music albums.
+     */
+    getLatestAlbums(options?: Omit<GetLatestMediaOptions, 'includeItemTypes'>): Promise<BaseItemDto[]>;
+}
+
+declare class TranscodeModule {
+    private http;
+    private getDeviceId;
+    constructor(http: HttpTransport, getDeviceId: () => string);
+    /**
+     * Explicitly stop an active server transcoding session via DELETE /Videos/ActiveEncodings.
+     * This terminates lingering FFmpeg processes on the Jellyfin server.
+     *
+     * @param playSessionId The unique playback session ID.
+     * @param deviceId The client device ID (defaults to configured client device ID).
+     */
+    stopActiveEncoding(playSessionId: string, deviceId?: string): Promise<void>;
+    /**
+     * Convenience alias for stopActiveEncoding.
+     */
+    stop(playSessionId: string, deviceId?: string): Promise<void>;
+}
+
+declare const COMMON_SEARCH_FIELDS = "PrimaryImageAspectRatio,PrimaryImageTag,ImageTags,BackdropImageTags,AlbumPrimaryImageTag,AlbumId,AudioInfo,MediaSources,Chapters,HasLyrics,Overview,Genres,Studios,ProductionYear,OfficialRating,CommunityRating,CriticRating,PremiereDate,RunTimeTicks,IndexNumber,ParentIndexNumber,SeriesName,SeriesId,SeasonId,SeasonName,UserData";
+declare class SearchModule {
+    private http;
+    private getUserId;
+    constructor(http: HttpTransport, getUserId: () => string);
+    private resolveUserId;
+    /**
+     * Universal search across Jellyfin items with comprehensive filters.
+     */
+    search(query: string, options?: SearchOptions): Promise<ItemsResponse>;
+    /**
+     * Search specifically within a specific library or parent folder.
+     */
+    searchInLibrary(parentId: string, query: string, options?: Omit<SearchOptions, 'parentId'>): Promise<ItemsResponse>;
+    /**
+     * Convenience helper to search audio tracks / songs.
+     */
+    searchSongs(query: string, options?: Omit<SearchOptions, 'includeItemTypes'>): Promise<ItemsResponse>;
+    /**
+     * Convenience helper to search music albums.
+     */
+    searchAlbums(query: string, options?: Omit<SearchOptions, 'includeItemTypes'>): Promise<ItemsResponse>;
+    /**
+     * Convenience helper to search music artists.
+     */
+    searchArtists(query: string, options?: Omit<SearchOptions, 'includeItemTypes'>): Promise<ItemsResponse>;
+    /**
+     * Convenience helper to search movies.
+     */
+    searchMovies(query: string, options?: Omit<SearchOptions, 'includeItemTypes'>): Promise<ItemsResponse>;
+    /**
+     * Convenience helper to search TV series.
+     */
+    searchSeries(query: string, options?: Omit<SearchOptions, 'includeItemTypes'>): Promise<ItemsResponse>;
+    /**
+     * Convenience helper to search TV episodes.
+     */
+    searchEpisodes(query: string, options?: Omit<SearchOptions, 'includeItemTypes'>): Promise<ItemsResponse>;
+}
+
+type WebSocketEventListener = (...args: any[]) => void;
+declare class WebSocketModule {
+    private http;
+    private getDeviceId;
+    private ws;
+    private keepAliveTimer;
+    private reconnectTimer;
+    private listeners;
+    private reconnectAttempts;
+    private explicitlyClosed;
+    private options;
+    constructor(http: HttpTransport, getDeviceId: () => string);
+    /**
+     * Check whether the WebSocket is currently open and connected.
+     */
+    get isConnected(): boolean;
+    /**
+     * Build the Jellyfin WebSocket URL from current serverUrl, accessToken, and deviceId.
+     */
+    getWebSocketUrl(): string;
+    /**
+     * Connect to the Jellyfin WebSocket endpoint.
+     */
+    connect(options?: WebSocketModuleOptions): void;
+    /**
+     * Disconnect the WebSocket and prevent automatic reconnection.
+     */
+    disconnect(): void;
+    /**
+     * Send a raw string or JSON message through the open WebSocket.
+     */
+    send(message: string | Record<string, unknown>): void;
+    /**
+     * Send a KeepAlive message to the Jellyfin server.
+     */
+    sendKeepAlive(): void;
+    /**
+     * Subscribe to real-time session updates from the server.
+     */
+    startSessionsSubscription(intervalMs?: number): void;
+    /**
+     * Stop receiving real-time session updates.
+     */
+    stopSessionsSubscription(): void;
+    /**
+     * Subscribe to scheduled tasks updates from the server.
+     */
+    startScheduledTasksSubscription(intervalMs?: number): void;
+    /**
+     * Stop scheduled tasks updates.
+     */
+    stopScheduledTasksSubscription(): void;
+    /**
+     * Subscribe to server activity log updates.
+     */
+    startActivityLogSubscription(intervalMs?: number): void;
+    /**
+     * Stop server activity log updates.
+     */
+    stopActivityLogSubscription(): void;
+    on(event: 'open', listener: () => void): () => void;
+    on(event: 'close', listener: (code?: number, reason?: string) => void): () => void;
+    on(event: 'error', listener: (error: unknown) => void): () => void;
+    on(event: 'message', listener: (msg: WebSocketInboundMessage) => void): () => void;
+    on(event: 'libraryChanged', listener: (data: LibraryChangedData) => void): () => void;
+    on(event: 'userDataChanged', listener: (data: UserDataChangedData) => void): () => void;
+    on(event: 'sessions', listener: (data: SessionInfoDto[]) => void): () => void;
+    on(event: string, listener: WebSocketEventListener): () => void;
+    off(event: string, listener: WebSocketEventListener): void;
+    emit(event: string, ...args: unknown[]): void;
+    private setupSocketEvents;
+    private startKeepAlive;
+    private stopKeepAlive;
+    private scheduleReconnect;
+    private cleanup;
+}
+
+declare class SessionsModule {
+    private http;
+    private getUserId;
+    constructor(http: HttpTransport, getUserId: () => string);
+    /**
+     * Query active client sessions across the Jellyfin server via GET /Sessions.
+     */
+    getSessions(options?: GetSessionsOptions): Promise<SessionInfoDto[]>;
+    /**
+     * Instruct a remote session to start playback of specified items via POST /Sessions/{sessionId}/Playing.
+     *
+     * @param sessionId The target session ID.
+     * @param itemIds Single item ID or array of item IDs to play.
+     * @param options Additional playback parameters (command type, start ticks, etc.).
+     */
+    play(sessionId: string, itemIds: string | string[], options?: RemotePlayOptions): Promise<void>;
+    /**
+     * Send a playback control command to a remote session via POST /Sessions/{sessionId}/Playing/{command}.
+     */
+    sendPlaystateCommand(sessionId: string, command: PlaystateCommand, params?: Record<string, unknown>): Promise<void>;
+    /**
+     * Toggle play / pause on a remote session.
+     */
+    playPause(sessionId: string): Promise<void>;
+    /**
+     * Pause playback on a remote session.
+     */
+    pause(sessionId: string): Promise<void>;
+    /**
+     * Resume playback on a remote session.
+     */
+    unpause(sessionId: string): Promise<void>;
+    /**
+     * Stop playback on a remote session.
+     */
+    stop(sessionId: string): Promise<void>;
+    /**
+     * Seek to a specific tick position on a remote session.
+     *
+     * @param sessionId Target session ID.
+     * @param positionTicks Position in ticks (1 tick = 10,000 milliseconds = 100 nanoseconds).
+     */
+    seek(sessionId: string, positionTicks: number): Promise<void>;
+    /**
+     * Skip to the next track on a remote session.
+     */
+    nextTrack(sessionId: string): Promise<void>;
+    /**
+     * Skip to the previous track on a remote session.
+     */
+    previousTrack(sessionId: string): Promise<void>;
+    /**
+     * Send a general command to a remote session via POST /Sessions/{sessionId}/Command.
+     */
+    sendGeneralCommand(sessionId: string, command: GeneralCommandDto): Promise<void>;
+    /**
+     * Set volume level on a remote session (0-100).
+     */
+    setVolume(sessionId: string, volume: number): Promise<void>;
+    /**
+     * Mute audio on a remote session.
+     */
+    mute(sessionId: string): Promise<void>;
+    /**
+     * Unmute audio on a remote session.
+     */
+    unmute(sessionId: string): Promise<void>;
+    /**
+     * Toggle mute on a remote session.
+     */
+    toggleMute(sessionId: string): Promise<void>;
+    /**
+     * Switch the audio stream index on a remote session.
+     */
+    setAudioStreamIndex(sessionId: string, index: number): Promise<void>;
+    /**
+     * Switch the subtitle stream index on a remote session.
+     */
+    setSubtitleStreamIndex(sessionId: string, index: number): Promise<void>;
+    /**
+     * Display an on-screen dialog message modal on a remote session via POST /Sessions/{sessionId}/Message.
+     */
+    sendMessage(sessionId: string, options: SessionMessageOptions | string): Promise<void>;
+    /**
+     * Instruct a remote session to navigate and view an item or page via POST /Sessions/{sessionId}/Viewing.
+     */
+    viewItem(sessionId: string, itemType: string, itemId: string, itemName: string): Promise<void>;
+}
+
+declare class QuickConnectModule {
+    private http;
+    constructor(http: HttpTransport);
+    /**
+     * Check whether Quick Connect is enabled on the connected Jellyfin server.
+     */
+    isEnabled(): Promise<boolean>;
+    /**
+     * Initiate a Quick Connect authentication session.
+     * Typically called by a client device (e.g. Smart TV or CLI) to generate a user-facing pairing code.
+     */
+    initiate(): Promise<QuickConnectResult>;
+    /**
+     * Check the current authorization status of an initiated Quick Connect secret.
+     *
+     * @param secret The secret token returned from initiate().
+     */
+    check(secret: string): Promise<QuickConnectState>;
+    /**
+     * Authorize a Quick Connect pairing code from an authenticated session.
+     * Typically called on a mobile app or browser where the user is already logged in.
+     *
+     * @param code The pairing code shown on the target device.
+     * @param userId Optional specific user ID to authenticate as (defaults to the currently authenticated user).
+     */
+    authorize(code: string, userId?: string): Promise<boolean>;
+    /**
+     * Repeatedly poll until the user authorizes the Quick Connect request or a timeout occurs.
+     *
+     * @param secret The secret token returned from initiate().
+     * @param options Polling configuration (intervalMs, timeoutMs, signal).
+     */
+    poll(secret: string, options?: QuickConnectPollOptions): Promise<QuickConnectState>;
+}
+
+declare class TrickplayModule {
+    private http;
+    constructor(http: HttpTransport);
+    /**
+     * Generates the HLS playlist URL for trickplay scrubbing image tiles.
+     * E.g. /Videos/{itemId}/Trickplay/{width}/tiles.m3u8
+     */
+    getTilesHlsUrl(itemId: string, width: number, options?: TrickplayStreamOptions): string;
+    /**
+     * Generates the URL for a specific trickplay thumbnail tile image sheet.
+     * E.g. /Videos/{itemId}/Trickplay/{width}/{index}.jpg
+     */
+    getTileImageUrl(itemId: string, width: number, index: number, options?: TrickplayStreamOptions): string;
+    /**
+     * Fetches and parses the HLS trickplay manifest (tiles.m3u8) for the given item and resolution.
+     */
+    getTrickplayManifest(itemId: string, width: number, options?: {
+        mediaSourceId?: string;
+        useQueryToken?: boolean;
+    }): Promise<TrickplayManifestInfo>;
+    /**
+     * Helper to parse #EXTINF and tile file names from a tiles.m3u8 playlist.
+     */
+    private parseTilesM3u8;
+    /**
+     * Extracts the available trickplay thumbnail widths from a BaseItemDto's Trickplay metadata.
+     */
+    getAvailableResolutions(item: BaseItemDto, mediaSourceId?: string): number[];
+    /**
+     * Retrieves the TrickplayInfoDto metadata for a specified item and optional width.
+     */
+    getTrickplayInfo(item: BaseItemDto, width?: number, mediaSourceId?: string): TrickplayInfoDto | null;
+    /**
+     * Calculates the exact tile sheet index, image URL, and sprite coordinates (x, y, width, height)
+     * for a given playback timestamp to render scrubbing thumbnails in a player or seekbar UI.
+     */
+    getThumbnailForTimestamp(options: ThumbnailLookupOptions): ThumbnailLookupResult | null;
+}
+
+declare class ChaptersModule {
+    private http;
+    private getUserId?;
+    constructor(http: HttpTransport, getUserId?: () => string);
+    /**
+     * Synchronously extracts chapter markers from an already fetched BaseItemDto.
+     */
+    extractChapters(item: BaseItemDto): ChapterInfoDto[];
+    /**
+     * Fetches the chapter markers for an item from the server.
+     */
+    getChapters(itemId: string): Promise<ChapterInfoDto[]>;
+    /**
+     * Generates the URL for a chapter preview thumbnail image.
+     * E.g. /Items/{itemId}/Images/Chapter/{chapterIndex}
+     */
+    getChapterImageUrl(itemId: string, chapterIndex: number, options?: ChapterImageOptions): string;
+    /**
+     * Retrieves media segments (Intro, Outro, Recap, Commercials) for an item via Jellyfin 10.10+ /MediaSegments.
+     */
+    getMediaSegments(itemId: string, options?: GetMediaSegmentsOptions): Promise<MediaSegmentDto[]>;
+    /**
+     * Resolves intro and end credits markers for an item, combining /MediaSegments API
+     * and chapter marker heuristics (MarkerType or naming like 'Intro', 'Opening', 'Credits', 'Ending').
+     */
+    getIntroCredits(itemOrChaptersOrId: BaseItemDto | ChapterInfoDto[] | string, mediaSegments?: MediaSegmentDto[]): Promise<IntroCreditsMarkers>;
+    /**
+     * Checks whether the current playback position falls within an intro or credits range.
+     */
+    findCurrentSegment(positionTicks: number, markersOrSegments: IntroCreditsMarkers | MediaSegmentDto[]): {
+        type: string;
+        startTicks: number;
+        endTicks: number;
+    } | null;
+    /**
+     * Returns the timestamp ticks to skip to if the current position is within a skippable segment,
+     * or null if not currently within any skippable range.
+     */
+    getSkipPosition(positionTicks: number, markersOrSegments: IntroCreditsMarkers | MediaSegmentDto[]): number | null;
+}
+
+declare class GenresModule {
+    private http;
+    private getUserId;
+    constructor(http: HttpTransport, getUserId: () => string);
+    private resolveUserId;
+    /**
+     * Retrieves video/movie genres from the server via GET /Genres.
+     */
+    getGenres(options?: GetGenresOptions): Promise<ItemsResponse>;
+    /**
+     * Retrieves a single genre by name via GET /Genres/{genreName}.
+     */
+    getGenre(genreName: string, options?: {
+        userId?: string;
+    }): Promise<BaseItemDto>;
+    /**
+     * Retrieves music genres from the server via GET /MusicGenres.
+     */
+    getMusicGenres(options?: GetGenresOptions): Promise<ItemsResponse>;
+    /**
+     * Retrieves a single music genre by name via GET /MusicGenres/{genreName}.
+     */
+    getMusicGenre(genreName: string, options?: {
+        userId?: string;
+    }): Promise<BaseItemDto>;
+    /**
+     * Retrieves studios/production companies from the server via GET /Studios.
+     */
+    getStudios(options?: GetStudiosOptions): Promise<ItemsResponse>;
+    /**
+     * Retrieves a single studio by name via GET /Studios/{studioName}.
+     */
+    getStudio(studioName: string, options?: {
+        userId?: string;
+    }): Promise<BaseItemDto>;
+}
+
+declare class CollectionsModule {
+    private http;
+    private getUserId;
+    constructor(http: HttpTransport, getUserId: () => string);
+    private resolveUserId;
+    /**
+     * Retrieves user BoxSet / Collections via GET /Collections.
+     */
+    getCollections(options?: GetCollectionsOptions): Promise<ItemsResponse>;
+    /**
+     * Retrieves the items belonging to a collection / BoxSet.
+     */
+    getCollectionItems(collectionId: string, options?: GetCollectionItemsOptions): Promise<ItemsResponse>;
+    /**
+     * Creates a new BoxSet / Collection via POST /Collections.
+     */
+    createCollection(options: CreateCollectionOptions): Promise<{
+        Id: string;
+    }>;
+    /**
+     * Adds items to an existing BoxSet / Collection via POST /Collections/{collectionId}/Items.
+     */
+    addToCollection(collectionId: string, itemIds: string | string[]): Promise<void>;
+    /**
+     * Removes items from an existing BoxSet / Collection via DELETE /Collections/{collectionId}/Items.
+     */
+    removeFromCollection(collectionId: string, itemIds: string | string[]): Promise<void>;
+}
+
+declare class DisplayPreferencesModule {
+    private http;
+    private getUserId;
+    private defaultClient;
+    constructor(http: HttpTransport, getUserId: () => string, defaultClient?: string);
+    private resolveUserId;
+    /**
+     * Retrieves the user's display preferences for a specific folder or view.
+     * GET /DisplayPreferences/{displayPreferencesId}
+     */
+    getDisplayPreferences(displayPreferencesId: string, options?: GetDisplayPreferencesOptions): Promise<DisplayPreferencesDto>;
+    /**
+     * Updates display preferences for a specific folder or view.
+     * POST /DisplayPreferences/{displayPreferencesId}
+     */
+    updateDisplayPreferences(displayPreferencesId: string, preferences: DisplayPreferencesDto, options?: UpdateDisplayPreferencesOptions): Promise<void>;
+    /**
+     * Sets a custom client-specific key-value pair in CustomPrefs.
+     */
+    setCustomPreference(displayPreferencesId: string, key: string, value: string, options?: UpdateDisplayPreferencesOptions): Promise<DisplayPreferencesDto>;
+    /**
+     * Updates sort field and order preferences for a view.
+     */
+    setSortPreferences(displayPreferencesId: string, sortBy: string, sortOrder: 'Ascending' | 'Descending', options?: UpdateDisplayPreferencesOptions): Promise<DisplayPreferencesDto>;
+    /**
+     * Sets the view presentation layout type (e.g. 'Poster', 'Thumb', 'Banner', 'List').
+     */
+    setViewType(displayPreferencesId: string, viewType: string, options?: UpdateDisplayPreferencesOptions): Promise<DisplayPreferencesDto>;
+}
+
 interface CacheRecord<T = unknown> {
     key: string;
     data: T;
@@ -1007,12 +1838,25 @@ declare class JellyfinClient {
     readonly auth: AuthModule;
     readonly system: SystemModule;
     readonly library: LibraryModule;
+    readonly search: SearchModule;
     readonly playlists: PlaylistsModule;
     readonly playback: PlaybackModule;
     readonly media: MediaModule;
     readonly lyrics: LyricsModule;
     readonly favorites: FavoritesModule;
     readonly offline: OfflineStorageManager;
+    readonly resume: ResumeModule;
+    readonly nextUp: NextUpModule;
+    readonly latest: LatestModule;
+    readonly transcode: TranscodeModule;
+    readonly websocket: WebSocketModule;
+    readonly sessions: SessionsModule;
+    readonly quickConnect: QuickConnectModule;
+    readonly trickplay: TrickplayModule;
+    readonly chapters: ChaptersModule;
+    readonly genres: GenresModule;
+    readonly collections: CollectionsModule;
+    readonly displayPreferences: DisplayPreferencesModule;
     private http;
     private storage;
     private cache;
@@ -1089,4 +1933,4 @@ declare class JellyfinAuthError extends JellyfinApiError {
     constructor(message?: string, status?: number, endpoint?: string);
 }
 
-export { AUDIO_QUALITY_PRESETS, type ArtworkUrlOptions, type AudioHlsStreamOptions, type AudioQualityOption, type AudioQualityPresetKey, type AudioStreamOptions, AuthModule, type AuthenticationResult, type BaseItemDto, type CacheAdapter, type CacheRecord, type ClientCapabilities, type ClientEventListener, type ClientEventType, type ClientInfo, type CreatePlaylistDto, type CreatePlaylistOptions, type DownloadItemOptions, type DownloadProgress, type DownloadRecord, type DownloadUrlOptions, FavoritesModule, type GetAlbumsOptions, type GetArtistsOptions, type GetEpisodesOptions, type GetMoviesOptions, type GetSeasonsOptions, type GetSeriesOptions, type GetSongsOptions, type GetVideosOptions, HttpTransport, IndexedDBCacheAdapter, type ItemsResponse, JellyfinApiError, JellyfinAuthError, JellyfinClient, type JellyfinClientOptions, JellyfinError, LibraryModule, LocalStorageAdapter, type LyricLine, type LyricsDto, LyricsModule, MediaModule, type MediaSourceInfo, type MediaStreamInfo, MemoryCacheAdapter, MemoryStorage, OfflineStorageManager, type PlaybackInfoOptions, type PlaybackInfoResponse, PlaybackModule, PlaylistsModule, type PublicSystemInfo, type RequestOptions, type SearchOptions, type StorageAdapter, type SubtitleTrackInfo, type SubtitleUrlOptions, type SystemInfo, SystemModule, type UpdatePlaylistOptions, type UserDto, type UserItemDataDto, VIDEO_QUALITY_PRESETS, type VideoHlsStreamOptions, type VideoQualityOption, type VideoQualityPresetKey, type VideoStreamOptions, buildAuthHeader, cleanUrl, fetchWithCache, formatBitrate, generateDeviceId, getAudioQualityList, getDefaultStorage, getVideoQualityList, isV12OrHigher, isVersionAtLeast, parseSemVer, resolveAudioQuality, resolveVideoQuality };
+export { AUDIO_QUALITY_PRESETS, type ArtworkUrlOptions, type AudioHlsStreamOptions, type AudioQualityOption, type AudioQualityPresetKey, type AudioStreamOptions, AuthModule, type AuthenticationResult, type BaseItemDto, COMMON_SEARCH_FIELDS, type CacheAdapter, type CacheRecord, type ChapterImageOptions, type ChapterInfoDto, ChaptersModule, type ClientCapabilities, type ClientEventListener, type ClientEventType, type ClientInfo, CollectionsModule, type CreateCollectionOptions, type CreatePlaylistDto, type CreatePlaylistOptions, type DisplayPreferencesDto, DisplayPreferencesModule, type DownloadItemOptions, type DownloadProgress, type DownloadRecord, type DownloadUrlOptions, FavoritesModule, type GeneralCommandDto, type GeneralCommandType, GenresModule, type GetAlbumsOptions, type GetArtistsOptions, type GetCollectionItemsOptions, type GetCollectionsOptions, type GetDisplayPreferencesOptions, type GetEpisodesOptions, type GetGenresOptions, type GetLatestMediaOptions, type GetMediaSegmentsOptions, type GetMoviesOptions, type GetNextUpOptions, type GetResumeItemsOptions, type GetSeasonsOptions, type GetSeriesOptions, type GetSessionsOptions, type GetSongsOptions, type GetStudiosOptions, type GetVideosOptions, HttpTransport, IndexedDBCacheAdapter, type IntroCreditsMarkers, type ItemsResponse, JellyfinApiError, JellyfinAuthError, JellyfinClient, type JellyfinClientOptions, JellyfinError, LatestModule, type LibraryChangedData, LibraryModule, LocalStorageAdapter, type LyricLine, type LyricsDto, LyricsModule, type MarkerRange, MediaModule, type MediaSegmentDto, type MediaSegmentType, type MediaSourceInfo, type MediaStreamInfo, MemoryCacheAdapter, MemoryStorage, NextUpModule, OfflineStorageManager, type PlayCommandType, type PlaybackInfoOptions, type PlaybackInfoResponse, PlaybackModule, PlaylistsModule, type PlaystateCommand, type PublicSystemInfo, QuickConnectModule, type QuickConnectPollOptions, type QuickConnectResult, type QuickConnectState, type RemotePlayOptions, type RequestOptions, ResumeModule, SearchModule, type SearchOptions, type SessionInfoDto, type SessionMessageOptions, type SessionPlayState, SessionsModule, type StopActiveEncodingOptions, type StorageAdapter, type SubtitleTrackInfo, type SubtitleUrlOptions, type SystemInfo, SystemModule, type ThumbnailLookupOptions, type ThumbnailLookupResult, TranscodeModule, type TrickplayInfoDto, type TrickplayManifestInfo, type TrickplayManifestTile, TrickplayModule, type TrickplayStreamOptions, type UpdateDisplayPreferencesOptions, type UpdatePlaylistOptions, type UserDataChangedData, type UserDto, type UserItemDataDto, VIDEO_QUALITY_PRESETS, type VideoHlsStreamOptions, type VideoQualityOption, type VideoQualityPresetKey, type VideoStreamOptions, type WebSocketEventListener, type WebSocketInboundMessage, type WebSocketMessageType, WebSocketModule, type WebSocketModuleOptions, buildAuthHeader, cleanUrl, fetchWithCache, formatBitrate, generateDeviceId, getAudioQualityList, getDefaultStorage, getVideoQualityList, isV12OrHigher, isVersionAtLeast, parseSemVer, resolveAudioQuality, resolveVideoQuality };