@redseat/api 0.3.14 → 0.4.2

package/dist/library.d.ts

@@ -1,61 +1,8 @@
 import { Observable } from 'rxjs';
 import type { AxiosResponse } from 'axios';
-import { IFile, ITag, IPerson, ISerie, IMovie, MediaRequest, IEpisode, ExternalImage, IBackupFile, ILibrary, SerieInMedia, DeletedQuery, RsDeleted, MovieSort, RsSort, SqlOrder, RsRequest, DetectedFaceResult, UnassignFaceResponse, RsGroupDownload, IViewProgress, IWatched, IRsRequestProcessing } from './interfaces.js';
-import { SSEMediasEvent, SSEUploadProgressEvent, SSEConvertProgressEvent, SSEEpisodesEvent, SSESeriesEvent, SSEMoviesEvent, SSEPeopleEvent, SSETagsEvent, SSELibraryStatusEvent, SSEMediaRatingEvent, SSEMediaProgressEvent, SSERequestProcessingEvent } from './sse-types.js';
+import { IFile, ITag, IPerson, ISerie, IMovie, IBook, MediaRequest, IEpisode, ExternalImage, IBackupFile, ILibrary, DeletedQuery, RsDeleted, MovieSort, BookSort, RsSort, SqlOrder, RsRequest, DetectedFaceResult, UnassignFaceResponse, RsGroupDownload, IViewProgress, IWatched, IRsRequestProcessing, BookSearchStreamResult, MovieSearchStreamResult, SerieSearchStreamResult, BookSearchResult, MovieSearchResult, SerieSearchResult, ItemWithRelations, SearchStreamCallbacks, MediaForUpdate, IChannelUpdate } from './interfaces.js';
+import { SSEMediasEvent, SSEUploadProgressEvent, SSEConvertProgressEvent, SSEEpisodesEvent, SSESeriesEvent, SSEMoviesEvent, SSEBooksEvent, SSEPeopleEvent, SSETagsEvent, SSELibraryStatusEvent, SSEMediaRatingEvent, SSEMediaProgressEvent, SSERequestProcessingEvent } from './sse-types.js';
 import { EncryptFileOptions, EncryptedFile } from './encryption.js';
-export interface MediaForUpdate {
-    name?: string;
-    description?: string;
-    mimetype?: string;
-    size?: number;
-    md5?: string;
-    modified?: number;
-    created?: number;
-    width?: number;
-    height?: number;
-    orientation?: number;
-    color_space?: string;
-    icc?: string;
-    mp?: number;
-    vcodecs?: string[];
-    acodecs?: string[];
-    fps?: number;
-    bitrate?: number;
-    focal?: number;
-    iso?: number;
-    model?: string;
-    sspeed?: string;
-    f_number?: number;
-    duration?: number;
-    progress?: number;
-    addTags?: {
-        id: string;
-        conf?: number;
-    }[];
-    removeTags?: string[];
-    tagsLookup?: string[];
-    addSeries?: SerieInMedia[];
-    removeSeries?: SerieInMedia[];
-    addPeople?: {
-        id: string;
-        conf?: number;
-    }[];
-    removePeople?: string[];
-    peopleLookup?: string[];
-    long?: number;
-    lat?: number;
-    gps?: string;
-    origin?: any;
-    originUrl?: string;
-    movie?: string;
-    lang?: string;
-    rating?: number;
-    thumbsize?: number;
-    iv?: string;
-    uploader?: string;
-    uploadkey?: string;
-    uploadId?: string;
-}
 export interface LibraryHttpClient {
     get<T = unknown>(url: string, config?: any): Promise<{
         data: T;
@@ -83,6 +30,7 @@ export interface LibraryHttpClient {
     readonly episodes$?: Observable<SSEEpisodesEvent>;
     readonly series$?: Observable<SSESeriesEvent>;
     readonly movies$?: Observable<SSEMoviesEvent>;
+    readonly books$?: Observable<SSEBooksEvent>;
     readonly people$?: Observable<SSEPeopleEvent>;
     readonly tags$?: Observable<SSETagsEvent>;
     readonly libraryStatus$?: Observable<SSELibraryStatusEvent>;
@@ -90,6 +38,12 @@ export interface LibraryHttpClient {
     readonly mediaProgress$?: Observable<SSEMediaProgressEvent>;
     readonly requestProcessing$?: Observable<SSERequestProcessingEvent>;
 }
+export interface UploadMediaMultipartOptions {
+    file: Blob;
+    info?: MediaForUpdate;
+    filename?: string;
+    progressCallback?: (loaded: number, total: number) => void;
+}
 export declare class LibraryApi {
     private client;
     private libraryId;
@@ -103,6 +57,7 @@ export declare class LibraryApi {
     readonly episodes$: Observable<SSEEpisodesEvent>;
     readonly series$: Observable<SSESeriesEvent>;
     readonly movies$: Observable<SSEMoviesEvent>;
+    readonly books$: Observable<SSEBooksEvent>;
     readonly people$: Observable<SSEPeopleEvent>;
     readonly tags$: Observable<SSETagsEvent>;
     readonly libraryStatus$: Observable<SSELibraryStatusEvent>;
@@ -122,6 +77,7 @@ export declare class LibraryApi {
     dispose(): void;
     setKey(passPhrase: string): Promise<void>;
     private getUrl;
+    private openSearchStream;
     getTags(query?: {
         name?: string;
         parent?: string;
@@ -152,6 +108,7 @@ export declare class LibraryApi {
         }[];
         limit?: number;
     }): Promise<IEpisode[]>;
+    getSerieBooks(serieId: string): Promise<IBook[]>;
     getMovies(query?: {
         after?: number;
         inDigital?: boolean;
@@ -200,10 +157,32 @@ export declare class LibraryApi {
     getMovieWatched(movieId: string): Promise<IWatched>;
     getMovieProgress(movieId: string): Promise<IViewProgress>;
     setMovieProgress(movieId: string, progress: number): Promise<void>;
-    searchMovies(name: string): Promise<IMovie[]>;
+    searchMovies(name: string): Promise<MovieSearchResult[]>;
+    searchMoviesStream(name: string, callbacks: SearchStreamCallbacks<MovieSearchStreamResult>): () => void;
     movieRename(movieId: string, newName: string): Promise<IMovie>;
     updateMoviePoster(movieId: string, poster: FormData, type: string): Promise<void>;
     updateMovieImageFetch(movieId: string, image: ExternalImage): Promise<void>;
+    getBooks(query?: {
+        after?: number;
+        sort?: BookSort;
+    }): Promise<ItemWithRelations<IBook>[]>;
+    getBook(bookId: string): Promise<ItemWithRelations<IBook>>;
+    getBookMedias(bookId: string): Promise<IFile[]>;
+    searchBookMedias(bookId: string, q?: string): Promise<RsGroupDownload[]>;
+    addSearchedBookMedia(bookId: string, request: RsRequest): Promise<IFile>;
+    createBook(book: Partial<IBook>, options?: {
+        upsertTags?: boolean;
+        upsertPeople?: boolean;
+        upsertSerie?: boolean;
+    }): Promise<IBook>;
+    removeBook(bookId: string): Promise<void>;
+    updateBook(bookId: string, updates: Partial<IBook>): Promise<IBook>;
+    searchBooks(name: string): Promise<BookSearchResult[]>;
+    searchBooksStream(name: string, callbacks: SearchStreamCallbacks<BookSearchStreamResult>): () => void;
+    bookRename(bookId: string, newName: string): Promise<IBook>;
+    getBookImages(bookId: string): Promise<ExternalImage[]>;
+    updateBookPoster(bookId: string, poster: FormData): Promise<void>;
+    updateBookImageFetch(bookId: string, image: ExternalImage): Promise<void>;
     addTagToMedia(mediaId: string, tagId: string): Promise<void>;
     removeTagFromMedia(mediaId: string, tagId: string): Promise<void>;
     getCryptChallenge(): Promise<string>;
@@ -218,7 +197,8 @@ export declare class LibraryApi {
     serieAddAlt(serieId: string, alt: string): Promise<ISerie>;
     serieRemoveAlt(serieId: string, alt: string): Promise<ISerie>;
     updatePersonPortrait(personId: string, portrait: FormData): Promise<void>;
-    searchSeries(name: string): Promise<ISerie[]>;
+    searchSeries(name: string): Promise<SerieSearchResult[]>;
+    searchSeriesStream(name: string, callbacks: SearchStreamCallbacks<SerieSearchStreamResult>): () => void;
     setEpisodeWatched(serieId: string, season: number, number: number, date: number): Promise<void>;
     getEpisodeWatched(serieId: string, season: number, episode: number): Promise<IWatched>;
     getEpisodeProgress(serieId: string, season: number, episode: number): Promise<IViewProgress>;
@@ -228,9 +208,25 @@ export declare class LibraryApi {
      * @param serieId - The series identifier
      * @param season - The season number
      * @param episode - The episode number
-     * @returns Array of available media requests that can be used to download/stream the episode
+     * @param q - Optional search query to filter results
+     * @returns Array of grouped download requests. Use `.flatMap(g => g.requests)` to get a flat list of RsRequest items.
      */
-    searchEpisodeMedias(serieId: string, season: number, episode: number): Promise<RsRequest[]>;
+    searchEpisodeMedias(serieId: string, season: number, episode: number, q?: string): Promise<RsGroupDownload[]>;
+    /**
+     * Searches for available media sources for an entire season.
+     * @param serieId - The series identifier
+     * @param season - The season number
+     * @param q - Optional search query to filter results
+     * @returns Array of grouped download requests. Use `.flatMap(g => g.requests)` to get a flat list of RsRequest items.
+     */
+    searchSeasonMedias(serieId: string, season: number, q?: string): Promise<RsGroupDownload[]>;
+    /**
+     * Searches for available media sources for a movie.
+     * @param movieId - The movie identifier
+     * @param q - Optional search query to filter results
+     * @returns Array of grouped download requests. Use `.flatMap(g => g.requests)` to get a flat list of RsRequest items.
+     */
+    searchMovieMedias(movieId: string, q?: string): Promise<RsGroupDownload[]>;
     /**
      * Adds a searched episode media to the database for download/storage.
      * @param serieId - The series identifier
@@ -240,6 +236,27 @@ export declare class LibraryApi {
      * @returns The created media file entry
      */
     addSearchedEpisodeMedia(serieId: string, season: number, episode: number, request: RsRequest): Promise<IFile>;
+    /**
+     * Adds a searched movie media to the database for download/storage.
+     * @param movieId - The movie identifier
+     * @param request - The media request to add (typically from searchMovieMedias results)
+     * @returns The created media file entry
+     */
+    addSearchedMovieMedia(movieId: string, request: RsRequest): Promise<IFile>;
+    /**
+     * Gets the media files attached to a specific episode.
+     * @param serieId - The series identifier
+     * @param season - The season number
+     * @param episode - The episode number
+     * @returns Array of media files for the episode
+     */
+    getEpisodeMedias(serieId: string, season: number, episode: number): Promise<IFile[]>;
+    /**
+     * Gets the media files attached to a specific movie.
+     * @param movieId - The movie identifier
+     * @returns Array of media files for the movie
+     */
+    getMovieMedias(movieId: string): Promise<IFile[]>;
     /**
      * Checks if a request can be made permanent (saved for later use).
      * Tests the availability of the URL and returns a permanent version if valid.
@@ -341,14 +358,14 @@ export declare class LibraryApi {
     mergePeople(request: any): Promise<any>;
     clusterFaces(personId: string): Promise<any>;
     mergeMedias(request: any): Promise<IFile>;
-    mediaUpdateMany(update: any, ids: string[]): Promise<IFile[]>;
+    mediaUpdateMany(update: MediaForUpdate, ids: string[]): Promise<IFile[]>;
     mediaUpdateProgress(mediaId: string, progress: number): Promise<{
         progress: number;
     }>;
-    mediaUpdateChannel(mediaId: string, update: any): Promise<IFile[]>;
+    mediaUpdateChannel(mediaId: string, update: IChannelUpdate): Promise<IFile[]>;
     refreshMedia(mediaId: string): Promise<IFile[]>;
     aiTagMedia(mediaId: string): Promise<IFile[]>;
-    mediaUpdate(mediaId: string, update: any): Promise<IFile[]>;
+    mediaUpdate(mediaId: string, update: MediaForUpdate): Promise<IFile[]>;
     splitZip(mediaId: string, from: number, to: number): Promise<IFile>;
     deleteFromZip(mediaId: string, pages: number[]): Promise<IFile>;
     updateMediaThumb(mediaId: string, thumb: FormData): Promise<void>;
@@ -415,11 +432,16 @@ export declare class LibraryApi {
      */
     uploadMedia(data: ArrayBuffer | Uint8Array, options: {
         thumb?: ArrayBuffer | Uint8Array;
-        metadata: Omit<MediaForUpdate, 'id'>;
+        metadata: MediaForUpdate;
         fileMime: string;
         thumbMime?: string;
         progressCallback?: (loaded: number, total: number) => void;
     }): Promise<IFile>;
+    /**
+     * Upload media using raw multipart form data.
+     * `info` is optional and will be serialized as the `info` multipart field when provided.
+     */
+    uploadMediaMultipart(options: UploadMediaMultipartOptions): Promise<unknown>;
     /**
      * Upload a group of media files from URLs
      * @param download - The group download request containing requests array

package/dist/library.js

@@ -14,6 +14,7 @@ export class LibraryApi {
         this.episodes$ = this.createLibraryFilteredStream(client.episodes$);
         this.series$ = this.createLibraryFilteredStream(client.series$);
         this.movies$ = this.createLibraryFilteredStream(client.movies$);
+        this.books$ = this.createLibraryFilteredStream(client.books$);
         this.people$ = this.createLibraryFilteredStream(client.people$);
         this.tags$ = this.createLibraryFilteredStream(client.tags$);
         this.libraryStatus$ = this.createLibraryFilteredStream(client.libraryStatus$);
@@ -95,6 +96,50 @@ export class LibraryApi {
     getUrl(path) {
         return `/libraries/${this.libraryId}${path}`;
     }
+    openSearchStream(path, params, callbacks) {
+        const EventSourceCtor = globalThis.EventSource;
+        if (!EventSourceCtor) {
+            callbacks.onError?.(new Error('EventSource is not available in this runtime.'));
+            return () => undefined;
+        }
+        const url = this.client.getFullUrl(path, {
+            ...params,
+            token: this.client.getAuthToken()
+        });
+        const source = new EventSourceCtor(url);
+        let closed = false;
+        const close = () => {
+            if (closed) {
+                return;
+            }
+            closed = true;
+            source.removeEventListener('results', onResults);
+            source.removeEventListener('finished', onFinished);
+            source.onerror = null;
+            source.close();
+        };
+        const onResults = (event) => {
+            try {
+                const payload = JSON.parse(event.data);
+                callbacks.onResults?.(payload);
+            }
+            catch (error) {
+                callbacks.onError?.(error);
+                close();
+            }
+        };
+        const onFinished = () => {
+            callbacks.onFinished?.();
+            close();
+        };
+        source.addEventListener('results', onResults);
+        source.addEventListener('finished', onFinished);
+        source.onerror = (error) => {
+            callbacks.onError?.(error);
+            close();
+        };
+        return close;
+    }
     async getTags(query) {
         const params = {};
         if (query) {
@@ -181,6 +226,10 @@ export class LibraryApi {
         const res = await this.client.get(this.getUrl('/series/episodes'), { params });
         return res.data;
     }
+    async getSerieBooks(serieId) {
+        const res = await this.client.get(this.getUrl(`/series/${serieId}/books`));
+        return res.data;
+    }
     async getMovies(query) {
         const params = {};
         if (query) {
@@ -335,7 +384,7 @@ export class LibraryApi {
         return res.data;
     }
     async getSerieImages(serieId) {
-        const res = await this.client.get(this.getUrl(`/series/${serieId}/images`));
+        const res = await this.client.get(this.getUrl(`/series/${serieId}/image/search`));
         return res.data;
     }
     async updateSeriePoster(serieId, poster, type) {
@@ -363,7 +412,7 @@ export class LibraryApi {
         return res.data;
     }
     async getMovieImages(movieId) {
-        const res = await this.client.get(this.getUrl(`/movies/${movieId}/images`));
+        const res = await this.client.get(this.getUrl(`/movies/${movieId}/image/search`));
         return res.data;
     }
     async setMovieWatched(movieId, date) {
@@ -384,6 +433,9 @@ export class LibraryApi {
         const res = await this.client.get(this.getUrl(`/movies/search?name=${name}`));
         return res.data;
     }
+    searchMoviesStream(name, callbacks) {
+        return this.openSearchStream(this.getUrl('/movies/searchstream'), { name }, callbacks);
+    }
     async movieRename(movieId, newName) {
         const res = await this.client.patch(this.getUrl(`/movies/${movieId}`), {
             name: newName
@@ -396,6 +448,78 @@ export class LibraryApi {
     async updateMovieImageFetch(movieId, image) {
         await this.client.post(this.getUrl(`/movies/${movieId}/image/fetch`), image);
     }
+    // ==================== Books ====================
+    async getBooks(query) {
+        const params = {};
+        if (query) {
+            if (query.after !== undefined) {
+                params.after = query.after;
+            }
+            if (query.sort !== undefined) {
+                params.sort = query.sort;
+            }
+        }
+        const res = await this.client.get(this.getUrl('/books'), { params });
+        return res.data;
+    }
+    async getBook(bookId) {
+        const res = await this.client.get(this.getUrl(`/books/${bookId}`));
+        return res.data;
+    }
+    async getBookMedias(bookId) {
+        const res = await this.client.get(this.getUrl(`/books/${bookId}/medias`));
+        return res.data;
+    }
+    async searchBookMedias(bookId, q) {
+        const res = await this.client.get(this.getUrl(`/books/${bookId}/search`), q ? { params: { q } } : undefined);
+        return res.data;
+    }
+    async addSearchedBookMedia(bookId, request) {
+        const res = await this.client.post(this.getUrl(`/books/${bookId}/search`), request);
+        return res.data;
+    }
+    async createBook(book, options) {
+        const params = new URLSearchParams();
+        if (options?.upsertTags)
+            params.set('upsertTags', 'true');
+        if (options?.upsertPeople)
+            params.set('upsertPeople', 'true');
+        if (options?.upsertSerie)
+            params.set('upsertSerie', 'true');
+        const query = params.toString();
+        const res = await this.client.post(this.getUrl(`/books${query ? `?${query}` : ''}`), book);
+        return res.data;
+    }
+    async removeBook(bookId) {
+        await this.client.delete(this.getUrl(`/books/${bookId}`));
+    }
+    async updateBook(bookId, updates) {
+        const res = await this.client.patch(this.getUrl(`/books/${bookId}`), updates);
+        return res.data;
+    }
+    async searchBooks(name) {
+        const res = await this.client.get(this.getUrl(`/books/search?name=${name}`));
+        return res.data;
+    }
+    searchBooksStream(name, callbacks) {
+        return this.openSearchStream(this.getUrl('/books/searchstream'), { name }, callbacks);
+    }
+    async bookRename(bookId, newName) {
+        const res = await this.client.patch(this.getUrl(`/books/${bookId}`), {
+            name: newName
+        });
+        return res.data;
+    }
+    async getBookImages(bookId) {
+        const res = await this.client.get(this.getUrl(`/books/${bookId}/image/search`));
+        return res.data;
+    }
+    async updateBookPoster(bookId, poster) {
+        await this.client.post(this.getUrl(`/books/${bookId}/image`), poster);
+    }
+    async updateBookImageFetch(bookId, image) {
+        await this.client.post(this.getUrl(`/books/${bookId}/image/fetch`), image);
+    }
     async addTagToMedia(mediaId, tagId) {
         await this.client.post(this.getUrl(`/medias/${mediaId}/tags/${tagId}`), {});
     }
@@ -469,6 +593,9 @@ export class LibraryApi {
         const res = await this.client.get(this.getUrl(`/series/search?name=${name}`));
         return res.data;
     }
+    searchSeriesStream(name, callbacks) {
+        return this.openSearchStream(this.getUrl('/series/searchstream'), { name }, callbacks);
+    }
     async setEpisodeWatched(serieId, season, number, date) {
         await this.client.post(this.getUrl(`/series/${serieId}/seasons/${season}/episodes/${number}/watched`), { date });
     }
@@ -488,10 +615,32 @@ export class LibraryApi {
      * @param serieId - The series identifier
      * @param season - The season number
      * @param episode - The episode number
-     * @returns Array of available media requests that can be used to download/stream the episode
+     * @param q - Optional search query to filter results
+     * @returns Array of grouped download requests. Use `.flatMap(g => g.requests)` to get a flat list of RsRequest items.
+     */
+    async searchEpisodeMedias(serieId, season, episode, q) {
+        const res = await this.client.get(this.getUrl(`/series/${serieId}/seasons/${season}/episodes/${episode}/search`), q ? { params: { q } } : undefined);
+        return res.data;
+    }
+    /**
+     * Searches for available media sources for an entire season.
+     * @param serieId - The series identifier
+     * @param season - The season number
+     * @param q - Optional search query to filter results
+     * @returns Array of grouped download requests. Use `.flatMap(g => g.requests)` to get a flat list of RsRequest items.
+     */
+    async searchSeasonMedias(serieId, season, q) {
+        const res = await this.client.get(this.getUrl(`/series/${serieId}/seasons/${season}/search`), q ? { params: { q } } : undefined);
+        return res.data;
+    }
+    /**
+     * Searches for available media sources for a movie.
+     * @param movieId - The movie identifier
+     * @param q - Optional search query to filter results
+     * @returns Array of grouped download requests. Use `.flatMap(g => g.requests)` to get a flat list of RsRequest items.
      */
-    async searchEpisodeMedias(serieId, season, episode) {
-        const res = await this.client.get(this.getUrl(`/series/${serieId}/seasons/${season}/episodes/${episode}/search`));
+    async searchMovieMedias(movieId, q) {
+        const res = await this.client.get(this.getUrl(`/movies/${movieId}/search`), q ? { params: { q } } : undefined);
         return res.data;
     }
     /**
@@ -506,6 +655,36 @@ export class LibraryApi {
         const res = await this.client.post(this.getUrl(`/series/${serieId}/seasons/${season}/episodes/${episode}/search`), request);
         return res.data;
     }
+    /**
+     * Adds a searched movie media to the database for download/storage.
+     * @param movieId - The movie identifier
+     * @param request - The media request to add (typically from searchMovieMedias results)
+     * @returns The created media file entry
+     */
+    async addSearchedMovieMedia(movieId, request) {
+        const res = await this.client.post(this.getUrl(`/movies/${movieId}/search`), request);
+        return res.data;
+    }
+    /**
+     * Gets the media files attached to a specific episode.
+     * @param serieId - The series identifier
+     * @param season - The season number
+     * @param episode - The episode number
+     * @returns Array of media files for the episode
+     */
+    async getEpisodeMedias(serieId, season, episode) {
+        const res = await this.client.get(this.getUrl(`/series/${serieId}/seasons/${season}/episodes/${episode}/medias`));
+        return res.data;
+    }
+    /**
+     * Gets the media files attached to a specific movie.
+     * @param movieId - The movie identifier
+     * @returns Array of media files for the movie
+     */
+    async getMovieMedias(movieId) {
+        const res = await this.client.get(this.getUrl(`/movies/${movieId}/medias`));
+        return res.data;
+    }
     /**
      * Checks if a request can be made permanent (saved for later use).
      * Tests the availability of the URL and returns a permanent version if valid.
@@ -922,13 +1101,28 @@ export class LibraryApi {
             filename = options.metadata.name || 'file';
             fileBlob = new Blob([dataBuffer], { type: options.fileMime });
         }
-        // Create FormData
+        return (await this.uploadMediaMultipart({
+            file: fileBlob,
+            filename,
+            info: { ...metadata, size: fileBlob.size },
+            progressCallback: options.progressCallback
+        }));
+    }
+    /**
+     * Upload media using raw multipart form data.
+     * `info` is optional and will be serialized as the `info` multipart field when provided.
+     */
+    async uploadMediaMultipart(options) {
         const formData = new FormData();
-        // Info should always be first in the FormData
-        formData.append('info', JSON.stringify({ ...metadata, size: fileBlob.size }));
-        // File should always be last in the FormData
-        formData.append('file', fileBlob, filename);
-        // Send POST request with progress tracking
+        if (options.info) {
+            const infoPayload = { ...options.info };
+            if (infoPayload.size === undefined) {
+                infoPayload.size = options.file.size;
+            }
+            formData.append('info', JSON.stringify(infoPayload));
+        }
+        const filename = options.filename ?? (options.file.name ?? 'file');
+        formData.append('file', options.file, filename);
         const config = {};
         if (options.progressCallback) {
             config.onUploadProgress = (progressEvent) => {

package/dist/server.d.ts

@@ -1,8 +1,9 @@
 import { RedseatClient } from './client.js';
-import { ILibrary, IPlugin, ICredential, IWatched, IWatchedForAdd, IViewProgress, IViewProgressForAdd, HistoryQuery } from './interfaces.js';
+import { ILibrary, IPlugin, ICredential, IWatched, IWatchedForAdd, IViewProgress, IViewProgressForAdd, HistoryQuery, ServerLibraryForUpdate, LookupSearchStreamResult, SearchStreamCallbacks } from './interfaces.js';
 export declare class ServerApi {
     private client;
     constructor(client: RedseatClient);
+    private openSearchStream;
     getLibraries(): Promise<ILibrary[]>;
     ping(options?: {
         timeout?: number;
@@ -11,8 +12,10 @@ export declare class ServerApi {
         timeout?: number;
     }): Promise<any>;
     addLibrary(library: Partial<ILibrary>): Promise<ILibrary>;
-    updateLibrary(libraryId: string, library: Partial<ILibrary>): Promise<ILibrary>;
+    updateLibrary(libraryId: string, library: ServerLibraryForUpdate): Promise<ILibrary>;
+    deleteLibrary(libraryId: string, deleteMediaContent?: boolean): Promise<void>;
     getPlugins(): Promise<IPlugin[]>;
+    searchLookupStream(query: string, type: string, callbacks: SearchStreamCallbacks<LookupSearchStreamResult>): () => void;
     getCredentials(): Promise<ICredential[]>;
     saveCredential(credential: ICredential): Promise<ICredential>;
     updateCredential(credential: ICredential): Promise<ICredential>;

package/dist/server.js

@@ -2,6 +2,50 @@ export class ServerApi {
     constructor(client) {
         this.client = client;
     }
+    openSearchStream(path, params, callbacks) {
+        const EventSourceCtor = globalThis.EventSource;
+        if (!EventSourceCtor) {
+            callbacks.onError?.(new Error('EventSource is not available in this runtime.'));
+            return () => undefined;
+        }
+        const url = this.client.getFullUrl(path, {
+            ...params,
+            token: this.client.getAuthToken()
+        });
+        const source = new EventSourceCtor(url);
+        let closed = false;
+        const close = () => {
+            if (closed) {
+                return;
+            }
+            closed = true;
+            source.removeEventListener('results', onResults);
+            source.removeEventListener('finished', onFinished);
+            source.onerror = null;
+            source.close();
+        };
+        const onResults = (event) => {
+            try {
+                const payload = JSON.parse(event.data);
+                callbacks.onResults?.(payload);
+            }
+            catch (error) {
+                callbacks.onError?.(error);
+                close();
+            }
+        };
+        const onFinished = () => {
+            callbacks.onFinished?.();
+            close();
+        };
+        source.addEventListener('results', onResults);
+        source.addEventListener('finished', onFinished);
+        source.onerror = (error) => {
+            callbacks.onError?.(error);
+            close();
+        };
+        return close;
+    }
     async getLibraries() {
         const res = await this.client.get('/libraries');
         return res.data;
@@ -22,10 +66,16 @@ export class ServerApi {
         const res = await this.client.patch(`/libraries/${libraryId}`, library);
         return res.data;
     }
+    async deleteLibrary(libraryId, deleteMediaContent = false) {
+        await this.client.delete(`/libraries/${libraryId}?delete_media_content=${deleteMediaContent}`);
+    }
     async getPlugins() {
         const res = await this.client.get('/plugins');
         return res.data;
     }
+    searchLookupStream(query, type, callbacks) {
+        return this.openSearchStream('/plugins/lookup/searchstream', { q: query, type }, callbacks);
+    }
     async getCredentials() {
         const res = await this.client.get('/credentials');
         return res.data;

package/dist/sse-types.d.ts

@@ -1,4 +1,4 @@
-import { ILibrary, IFile, IEpisode, ISerie, IMovie, IPerson, ITag, IBackup, IWatched, IUnwatched, IRsRequestProcessing, VideoConvertRequest } from './interfaces.js';
+import { ILibrary, IFile, IEpisode, ISerie, IMovie, IBook, IPerson, ITag, IBackup, IWatched, IUnwatched, IRsRequestProcessing, VideoConvertRequest, type ItemWithRelations } from './interfaces.js';
 export type ElementAction = 'Added' | 'Updated' | 'Deleted';
 export type SSEConnectionState = 'disconnected' | 'connecting' | 'connected' | 'reconnecting' | 'error';
 export interface SSEConnectionOptions {
@@ -81,21 +81,28 @@ export interface SSEEpisodesEvent {
     library: string;
     episodes: {
         action: ElementAction;
-        episode: IEpisode;
+        episode: ItemWithRelations<IEpisode>;
     }[];
 }
 export interface SSESeriesEvent {
     library: string;
     series: {
         action: ElementAction;
-        serie: ISerie;
+        serie: ItemWithRelations<ISerie>;
     }[];
 }
 export interface SSEMoviesEvent {
     library: string;
     movies: {
         action: ElementAction;
-        movie: IMovie;
+        movie: ItemWithRelations<IMovie>;
+    }[];
+}
+export interface SSEBooksEvent {
+    library: string;
+    books: {
+        action: ElementAction;
+        book: ItemWithRelations<IBook>;
     }[];
 }
 export interface SSEPeopleEvent {
@@ -187,6 +194,7 @@ export interface SSEEventMap {
     'episodes': SSEEpisodesEvent;
     'series': SSESeriesEvent;
     'movies': SSEMoviesEvent;
+    'books': SSEBooksEvent;
     'people': SSEPeopleEvent;
     'tags': SSETagsEvent;
     'backups': SSEBackupsEvent;