@redseat/api 0.3.0 → 0.3.6

package/client.md

@@ -560,6 +560,60 @@ client.backupFiles$.subscribe(event => {
 });
 ```
 
+#### `mediaRating$: Observable<SSEMediaRatingEvent>`
+
+Emits when a user rates a media item.
+
+```typescript
+client.mediaRating$.subscribe(event => {
+    console.log(`User ${event.rating.userRef} rated media ${event.rating.mediaRef}: ${event.rating.rating}`);
+});
+```
+
+**Event structure:**
+- `library`: Library ID where the media is located
+- `rating.userRef`: User who rated
+- `rating.mediaRef`: Media that was rated
+- `rating.rating`: Rating value (0-5)
+- `rating.modified`: Timestamp of the rating
+
+#### `mediaProgress$: Observable<SSEMediaProgressEvent>`
+
+Emits when a user's playback progress is updated.
+
+```typescript
+client.mediaProgress$.subscribe(event => {
+    console.log(`User ${event.progress.userRef} watched ${event.progress.mediaRef} to ${event.progress.progress}ms`);
+});
+```
+
+**Event structure:**
+- `library`: Library ID where the media is located
+- `progress.userRef`: User whose progress updated
+- `progress.mediaRef`: Media being tracked
+- `progress.progress`: Current playback position in milliseconds
+- `progress.modified`: Timestamp of the update
+
+#### `playersList$: Observable<SSEPlayersListEvent>`
+
+Emits the full list of available media players for the user when it changes.
+
+```typescript
+client.playersList$.subscribe(event => {
+    console.log(`Available players for ${event.userRef}:`);
+    for (const player of event.players) {
+        console.log(`  - ${player.name} (${player.player})`);
+    }
+});
+```
+
+**Event structure:**
+- `userRef`: User ID
+- `players`: Array of available players
+  - `id`: Player socket ID (for casting)
+  - `name`: Player display name
+  - `player`: Player type identifier
+
 ### Complete SSE Example
 
 ```typescript

package/dist/client.d.ts

@@ -2,7 +2,7 @@ import { Method, AxiosRequestConfig } from 'axios';
 import { Observable } from 'rxjs';
 import { IToken } from './auth.js';
 import { IServer } from './interfaces.js';
-import { SSEConnectionState, SSEConnectionOptions, SSEConnectionError, SSELibraryEvent, SSELibraryStatusEvent, SSEMediasEvent, SSEUploadProgressEvent, SSEConvertProgressEvent, SSEEpisodesEvent, SSESeriesEvent, SSEMoviesEvent, SSEPeopleEvent, SSETagsEvent, SSEBackupsEvent, SSEBackupFilesEvent } from './sse-types.js';
+import { SSEConnectionState, SSEConnectionOptions, SSEConnectionError, SSELibraryEvent, SSELibraryStatusEvent, SSEMediasEvent, SSEUploadProgressEvent, SSEConvertProgressEvent, SSEEpisodesEvent, SSESeriesEvent, SSEMoviesEvent, SSEPeopleEvent, SSETagsEvent, SSEBackupsEvent, SSEBackupFilesEvent, SSEMediaRatingEvent, SSEMediaProgressEvent, SSEPlayersListEvent } from './sse-types.js';
 export interface ClientOptions {
     server: IServer;
     getIdToken: () => Promise<string>;
@@ -42,6 +42,9 @@ export declare class RedseatClient {
     readonly tags$: Observable<SSETagsEvent>;
     readonly backups$: Observable<SSEBackupsEvent>;
     readonly backupFiles$: Observable<SSEBackupFilesEvent>;
+    readonly mediaRating$: Observable<SSEMediaRatingEvent>;
+    readonly mediaProgress$: Observable<SSEMediaProgressEvent>;
+    readonly playersList$: Observable<SSEPlayersListEvent>;
     /**
      * Creates a typed observable for a specific SSE event type.
      * Unwraps the nested data structure from the server (e.g., {uploadProgress: {...}} -> {...})

package/dist/client.js

@@ -9,14 +9,18 @@ export class RedseatClient {
     createEventStream(eventName) {
         // Map event names to their wrapper property names (snake_case -> camelCase)
         const wrapperMap = {
+            'medias': 'medias',
             'upload_progress': 'uploadProgress',
             'convert_progress': 'convertProgress',
             'media_progress': 'mediaProgress',
+            'media_rating': 'mediaRating',
             'library-status': 'libraryStatus',
             'backups-files': 'backupsFiles',
+            'players-list': 'Players',
         };
         const wrapperKey = wrapperMap[eventName];
         return this._sseEvents.pipe(filter((event) => event.event === eventName), map(event => {
+            //console.log("EVENT", event)
             // If there's a wrapper, unwrap it; otherwise return data as-is
             const data = event.data;
             if (wrapperKey && data && typeof data === 'object' && wrapperKey in data) {
@@ -48,6 +52,9 @@ export class RedseatClient {
         this.tags$ = this.createEventStream('tags');
         this.backups$ = this.createEventStream('backups');
         this.backupFiles$ = this.createEventStream('backups-files');
+        this.mediaRating$ = this.createEventStream('media_rating');
+        this.mediaProgress$ = this.createEventStream('media_progress');
+        this.playersList$ = this.createEventStream('players-list');
         this.server = options.server;
         this.redseatUrl = options.redseatUrl;
         this.getIdToken = options.getIdToken;
@@ -341,8 +348,12 @@ export class RedseatClient {
             }
             this._sseConnectionState.next('connected');
             this.sseReconnectAttempts = 0;
-            // Process the stream
-            await this.processSSEStream(response.body);
+            // Process the stream in the background (don't await - it runs forever until disconnected)
+            this.processSSEStream(response.body).catch(err => {
+                if (err?.name !== 'AbortError') {
+                    this.handleSSEError(err);
+                }
+            });
         }
         catch (error) {
             if (error instanceof Error && error.name === 'AbortError') {
@@ -384,6 +395,7 @@ export class RedseatClient {
                 const { events, remainingBuffer } = this.parseSSEBuffer(buffer);
                 buffer = remainingBuffer;
                 for (const event of events) {
+                    //console.log("event process", JSON.stringify(event))
                     this._sseEvents.next(event);
                 }
             }

package/dist/interfaces.d.ts

@@ -414,6 +414,52 @@ export interface ClusterFacesResponse {
 export interface IChannelUpdate {
     [key: string]: any;
 }
+export declare enum PluginAuthType {
+    OAUTH = "oauth",
+    URL = "url",
+    Token = "token",
+    LoginPassword = "password"
+}
+export interface IPluginParam {
+    name: string;
+    param: Record<string, any>;
+    description?: string;
+    required?: boolean;
+}
+export interface IPlugin {
+    id: string;
+    name: string;
+    libraries: string[];
+    description: string;
+    credential: string;
+    credentialType: {
+        type: PluginAuthType;
+        url?: string;
+    };
+    params?: IPluginParam[];
+    oauthUrl?: string;
+    repo?: string;
+    publisher?: string;
+    version?: number;
+    installed: boolean;
+    capabilities?: string[];
+    local?: boolean;
+}
+export interface ICredential {
+    id?: string;
+    name: string;
+    source: string;
+    type: {
+        type: PluginAuthType;
+        url?: string;
+    };
+    login?: string;
+    password?: string;
+    settings: Record<string, any>;
+    user_ref?: string;
+    refreshtoken?: string;
+    expires?: number;
+}
 export declare enum ElementType {
     Tag = "tag",
     Person = "person",
@@ -437,6 +483,42 @@ export declare enum RsSort {
     Name = "name",
     Size = "size"
 }
+export type MediaType = 'episode' | 'movie' | 'book' | 'song' | 'media';
+export interface IWatched {
+    type: MediaType;
+    id: string;
+    userRef?: string;
+    date: number;
+    modified: number;
+}
+export interface IWatchedForAdd {
+    type: MediaType;
+    id: string;
+    date: number;
+}
+export interface IViewProgress {
+    type: MediaType;
+    id: string;
+    userRef: string;
+    progress: number;
+    parent?: string;
+    modified: number;
+}
+export interface IViewProgressForAdd {
+    type: MediaType;
+    id: string;
+    parent?: string;
+    progress: number;
+}
+export interface HistoryQuery {
+    sort?: RsSort;
+    order?: SqlOrder;
+    before?: number;
+    after?: number;
+    types?: MediaType[];
+    id?: string;
+    pageKey?: number;
+}
 export type MovieSort = 'modified' | 'added' | 'created' | 'name' | 'digitalairdate';
 export interface DeletedQuery {
     after?: number;
@@ -499,6 +581,7 @@ export interface RsRequest {
     filename?: string;
     status: RsRequestStatus;
     permanent: boolean;
+    instant?: boolean;
     jsonBody?: any;
     method: RsRequestMethod;
     referer?: string;

package/dist/interfaces.js

@@ -36,6 +36,13 @@ export var LinkType;
     LinkType["post"] = "post";
     LinkType["other"] = "other";
 })(LinkType || (LinkType = {}));
+export var PluginAuthType;
+(function (PluginAuthType) {
+    PluginAuthType["OAUTH"] = "oauth";
+    PluginAuthType["URL"] = "url";
+    PluginAuthType["Token"] = "token";
+    PluginAuthType["LoginPassword"] = "password";
+})(PluginAuthType || (PluginAuthType = {}));
 export var ElementType;
 (function (ElementType) {
     ElementType["Tag"] = "tag";

package/dist/library.d.ts

@@ -1,6 +1,6 @@
 import { Observable } from 'rxjs';
-import { IFile, ITag, IPerson, ISerie, IMovie, MediaRequest, IEpisode, ExternalImage, IBackupFile, ILibrary, SerieInMedia, DeletedQuery, RsDeleted, MovieSort, RsSort, SqlOrder, RsRequest, DetectedFaceResult, UnassignFaceResponse, RsGroupDownload } from './interfaces.js';
-import { SSEMediasEvent, SSEUploadProgressEvent, SSEConvertProgressEvent, SSEEpisodesEvent, SSESeriesEvent, SSEMoviesEvent, SSEPeopleEvent, SSETagsEvent, SSELibraryStatusEvent } from './sse-types.js';
+import { IFile, ITag, IPerson, ISerie, IMovie, MediaRequest, IEpisode, ExternalImage, IBackupFile, ILibrary, SerieInMedia, DeletedQuery, RsDeleted, MovieSort, RsSort, SqlOrder, RsRequest, DetectedFaceResult, UnassignFaceResponse, RsGroupDownload, IViewProgress, IWatched } from './interfaces.js';
+import { SSEMediasEvent, SSEUploadProgressEvent, SSEConvertProgressEvent, SSEEpisodesEvent, SSESeriesEvent, SSEMoviesEvent, SSEPeopleEvent, SSETagsEvent, SSELibraryStatusEvent, SSEMediaRatingEvent, SSEMediaProgressEvent } from './sse-types.js';
 import { EncryptFileOptions, EncryptedFile } from './encryption.js';
 export interface MediaForUpdate {
     name?: string;
@@ -85,6 +85,8 @@ export interface LibraryHttpClient {
     readonly people$?: Observable<SSEPeopleEvent>;
     readonly tags$?: Observable<SSETagsEvent>;
     readonly libraryStatus$?: Observable<SSELibraryStatusEvent>;
+    readonly mediaRating$?: Observable<SSEMediaRatingEvent>;
+    readonly mediaProgress$?: Observable<SSEMediaProgressEvent>;
 }
 export declare class LibraryApi {
     private client;
@@ -102,6 +104,8 @@ export declare class LibraryApi {
     readonly people$: Observable<SSEPeopleEvent>;
     readonly tags$: Observable<SSETagsEvent>;
     readonly libraryStatus$: Observable<SSELibraryStatusEvent>;
+    readonly mediaRating$: Observable<SSEMediaRatingEvent>;
+    readonly mediaProgress$: Observable<SSEMediaProgressEvent>;
     constructor(client: LibraryHttpClient, libraryId: string, library: ILibrary);
     /**
      * Creates a library-filtered stream from a client stream.
@@ -190,6 +194,9 @@ export declare class LibraryApi {
     updateMovie(movieId: string, updates: Partial<IMovie>): Promise<IMovie>;
     getMovieImages(movieId: string): Promise<ExternalImage[]>;
     setMovieWatched(movieId: string, date: number): Promise<void>;
+    getMovieWatched(movieId: string): Promise<IWatched>;
+    getMovieProgress(movieId: string): Promise<IViewProgress>;
+    setMovieProgress(movieId: string, progress: number): Promise<void>;
     searchMovies(name: string): Promise<IMovie[]>;
     movieRename(movieId: string, newName: string): Promise<IMovie>;
     updateMoviePoster(movieId: string, poster: FormData, type: string): Promise<void>;
@@ -210,6 +217,9 @@ export declare class LibraryApi {
     updatePersonPortrait(personId: string, portrait: FormData): Promise<void>;
     searchSeries(name: string): Promise<ISerie[]>;
     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>;
+    setEpisodeProgress(serieId: string, season: number, episode: number, progress: number): Promise<void>;
     /**
      * Searches for available media sources for a specific episode.
      * @param serieId - The series identifier
@@ -235,6 +245,14 @@ export declare class LibraryApi {
      * @throws Error if the URL is not available or cannot be made permanent
      */
     checkRequestPermanent(request: RsRequest): Promise<RsRequest>;
+    /**
+     * Checks if a request can be processed instantly (immediate availability).
+     * @param request - The request to check for instant status
+     * @returns Object with instant boolean indicating if the request can be processed immediately
+     */
+    checkRequestInstant(request: RsRequest): Promise<{
+        instant: boolean;
+    }>;
     /**
      * Get a share token for a request URL.
      * The token can be used to stream/download the resource without authentication.

package/dist/library.js

@@ -17,6 +17,8 @@ export class LibraryApi {
         this.people$ = this.createLibraryFilteredStream(client.people$);
         this.tags$ = this.createLibraryFilteredStream(client.tags$);
         this.libraryStatus$ = this.createLibraryFilteredStream(client.libraryStatus$);
+        this.mediaRating$ = this.createLibraryFilteredStream(client.mediaRating$);
+        this.mediaProgress$ = this.createLibraryFilteredStream(client.mediaProgress$);
     }
     /**
      * Creates a library-filtered stream from a client stream.
@@ -366,6 +368,17 @@ export class LibraryApi {
     async setMovieWatched(movieId, date) {
         await this.client.post(this.getUrl(`/movies/${movieId}/watched`), { date });
     }
+    async getMovieWatched(movieId) {
+        const res = await this.client.get(this.getUrl(`/movies/${movieId}/watched`));
+        return res.data;
+    }
+    async getMovieProgress(movieId) {
+        const res = await this.client.get(this.getUrl(`/movies/${movieId}/progress`));
+        return res.data;
+    }
+    async setMovieProgress(movieId, progress) {
+        await this.client.post(this.getUrl(`/movies/${movieId}/progress`), { progress });
+    }
     async searchMovies(name) {
         const res = await this.client.get(this.getUrl(`/movies/search?name=${name}`));
         return res.data;
@@ -458,6 +471,17 @@ export class LibraryApi {
     async setEpisodeWatched(serieId, season, number, date) {
         await this.client.post(this.getUrl(`/series/${serieId}/seasons/${season}/episodes/${number}/watched`), { date });
     }
+    async getEpisodeWatched(serieId, season, episode) {
+        const res = await this.client.get(this.getUrl(`/series/${serieId}/seasons/${season}/episodes/${episode}/watched`));
+        return res.data;
+    }
+    async getEpisodeProgress(serieId, season, episode) {
+        const res = await this.client.get(this.getUrl(`/series/${serieId}/seasons/${season}/episodes/${episode}/progress`));
+        return res.data;
+    }
+    async setEpisodeProgress(serieId, season, episode, progress) {
+        await this.client.post(this.getUrl(`/series/${serieId}/seasons/${season}/episodes/${episode}/progress`), { progress });
+    }
     /**
      * Searches for available media sources for a specific episode.
      * @param serieId - The series identifier
@@ -492,6 +516,15 @@ export class LibraryApi {
         const res = await this.client.post(this.getUrl('/plugins/requests/permanent'), request);
         return res.data;
     }
+    /**
+     * Checks if a request can be processed instantly (immediate availability).
+     * @param request - The request to check for instant status
+     * @returns Object with instant boolean indicating if the request can be processed immediately
+     */
+    async checkRequestInstant(request) {
+        const res = await this.client.post(this.getUrl('/plugins/requests/check-instant'), request);
+        return res.data;
+    }
     /**
      * Get a share token for a request URL.
      * The token can be used to stream/download the resource without authentication.

package/dist/server.d.ts

@@ -1,5 +1,5 @@
 import { RedseatClient } from './client.js';
-import { ILibrary } from './interfaces.js';
+import { ILibrary, IPlugin, ICredential, IWatched, IWatchedForAdd, IViewProgress, IViewProgressForAdd, HistoryQuery } from './interfaces.js';
 export declare class ServerApi {
     private client;
     constructor(client: RedseatClient);
@@ -12,7 +12,17 @@ export declare class ServerApi {
     }): Promise<any>;
     addLibrary(library: Partial<ILibrary>): Promise<ILibrary>;
     getSetting(key: string): Promise<string>;
-    getPlugins(): Promise<any[]>;
-    getCredentials(): Promise<any[]>;
+    getPlugins(): Promise<IPlugin[]>;
+    getCredentials(): Promise<ICredential[]>;
+    saveCredential(credential: ICredential): Promise<ICredential>;
+    updateCredential(credential: ICredential): Promise<ICredential>;
+    deleteCredential(id: string): Promise<void>;
+    saveOAuthCredentials(pluginId: string, params: Record<string, string>): Promise<void>;
     addLibraryCredential(credential: any): Promise<ILibrary>;
+    getHistory(query?: HistoryQuery): Promise<IWatched[]>;
+    addToHistory(watched: IWatchedForAdd): Promise<void>;
+    getProgressById(id: string): Promise<IViewProgress | null>;
+    addProgress(progress: IViewProgressForAdd): Promise<void>;
+    getAdminHistory(): Promise<IWatched[]>;
+    importHistory(watcheds: IWatchedForAdd[]): Promise<void>;
 }

package/dist/server.js

@@ -30,8 +30,62 @@ export class ServerApi {
         const res = await this.client.get('/credentials');
         return res.data;
     }
+    async saveCredential(credential) {
+        const res = await this.client.post('/credentials', credential);
+        return res.data;
+    }
+    async updateCredential(credential) {
+        const res = await this.client.patch(`/credentials/${credential.id}`, credential);
+        return res.data;
+    }
+    async deleteCredential(id) {
+        await this.client.delete(`/credentials/${id}`);
+    }
+    async saveOAuthCredentials(pluginId, params) {
+        await this.client.post(`/plugins/${pluginId}/oauthtoken`, params);
+    }
     async addLibraryCredential(credential) {
         const res = await this.client.post('/libraries/credential', credential);
         return res.data;
     }
+    // History methods
+    async getHistory(query) {
+        const params = {};
+        if (query) {
+            if (query.sort !== undefined)
+                params.sort = query.sort;
+            if (query.order !== undefined)
+                params.order = query.order;
+            if (query.before !== undefined)
+                params.before = query.before;
+            if (query.after !== undefined)
+                params.after = query.after;
+            if (query.types !== undefined && query.types.length > 0)
+                params.types = query.types;
+            if (query.id !== undefined)
+                params.id = query.id;
+            if (query.pageKey !== undefined)
+                params.pageKey = query.pageKey;
+        }
+        const res = await this.client.get('/users/me/history', { params });
+        return res.data;
+    }
+    async addToHistory(watched) {
+        await this.client.post('/users/me/history', watched);
+    }
+    async getProgressById(id) {
+        const res = await this.client.get(`/users/me/history/progress/${id}`);
+        return res.data;
+    }
+    async addProgress(progress) {
+        await this.client.post('/users/me/history/progress', progress);
+    }
+    // Admin history methods
+    async getAdminHistory() {
+        const res = await this.client.get('/users/admin/history');
+        return res.data;
+    }
+    async importHistory(watcheds) {
+        await this.client.post('/users/admin/history/import', watcheds);
+    }
 }

package/dist/sse-types.d.ts

@@ -107,6 +107,33 @@ export interface SSEBackupFilesEvent {
     status?: string;
     message?: string;
 }
+export interface SSEMediaRatingEvent {
+    library: string;
+    rating: {
+        userRef: string;
+        mediaRef: string;
+        rating: number;
+        modified: number;
+    };
+}
+export interface SSEMediaProgressEvent {
+    library: string;
+    progress: {
+        userRef: string;
+        mediaRef: string;
+        progress: number;
+        modified: number;
+    };
+}
+export interface SSEPlayerEvent {
+    id: string;
+    name: string;
+    player: string;
+}
+export interface SSEPlayersListEvent {
+    userRef: string;
+    players: SSEPlayerEvent[];
+}
 export interface SSEEventMap {
     'library': SSELibraryEvent;
     'library-status': SSELibraryStatusEvent;
@@ -120,6 +147,9 @@ export interface SSEEventMap {
     'tags': SSETagsEvent;
     'backups': SSEBackupsEvent;
     'backups-files': SSEBackupFilesEvent;
+    'media_rating': SSEMediaRatingEvent;
+    'media_progress': SSEMediaProgressEvent;
+    'players-list': SSEPlayersListEvent;
 }
 export type SSEEventName = keyof SSEEventMap;
 export interface SSEEvent<T extends SSEEventName = SSEEventName> {

package/libraries.md

@@ -190,6 +190,40 @@ libraryApi.libraryStatus$.subscribe(event => {
 });
 ```
 
+#### `mediaRating$: Observable<SSEMediaRatingEvent>`
+
+Emits when a user rates a media item in this library.
+
+```typescript
+libraryApi.mediaRating$.subscribe(event => {
+    console.log(`Rating for ${event.rating.mediaRef}: ${event.rating.rating}`);
+});
+```
+
+**Event structure:**
+- `library`: Library ID
+- `rating.userRef`: User who rated
+- `rating.mediaRef`: Media that was rated
+- `rating.rating`: Rating value (0-5)
+- `rating.modified`: Timestamp of the rating
+
+#### `mediaProgress$: Observable<SSEMediaProgressEvent>`
+
+Emits when a user's playback progress is updated for a media item in this library.
+
+```typescript
+libraryApi.mediaProgress$.subscribe(event => {
+    console.log(`Progress for ${event.progress.mediaRef}: ${event.progress.progress}ms`);
+});
+```
+
+**Event structure:**
+- `library`: Library ID
+- `progress.userRef`: User whose progress updated
+- `progress.mediaRef`: Media being tracked
+- `progress.progress`: Current playback position in milliseconds
+- `progress.modified`: Timestamp of the update
+
 ### Complete SSE Example with LibraryApi
 
 ```typescript
@@ -878,6 +912,62 @@ Marks an episode as watched.
 await libraryApi.setEpisodeWatched('serie-id', 1, 1, Date.now());
 ```
 
+### `getEpisodeWatched(serieId: string, season: number, episode: number): Promise<IWatched>`
+
+Gets the watched status for an episode.
+
+**Parameters:**
+
+- `serieId`: The ID of the series
+- `season`: Season number
+- `episode`: Episode number
+
+**Returns:** Promise resolving to an `IWatched` object containing watched date and metadata
+
+**Example:**
+
+```typescript
+const watched = await libraryApi.getEpisodeWatched('serie-id', 1, 1);
+console.log(`Watched on: ${new Date(watched.date).toLocaleDateString()}`);
+```
+
+### `getEpisodeProgress(serieId: string, season: number, episode: number): Promise<IViewProgress>`
+
+Gets the view progress for an episode.
+
+**Parameters:**
+
+- `serieId`: The ID of the series
+- `season`: Season number
+- `episode`: Episode number
+
+**Returns:** Promise resolving to an `IViewProgress` object containing progress value
+
+**Example:**
+
+```typescript
+const progress = await libraryApi.getEpisodeProgress('serie-id', 1, 1);
+console.log(`Progress: ${progress.progress}ms`);
+```
+
+### `setEpisodeProgress(serieId: string, season: number, episode: number, progress: number): Promise<void>`
+
+Sets the view progress for an episode.
+
+**Parameters:**
+
+- `serieId`: The ID of the series
+- `season`: Season number
+- `episode`: Episode number
+- `progress`: Progress value (typically in milliseconds for video playback position)
+
+**Example:**
+
+```typescript
+// Save progress at 30 minutes
+await libraryApi.setEpisodeProgress('serie-id', 1, 1, 1800000);
+```
+
 ---
 
 ## Movies
@@ -1000,6 +1090,56 @@ Marks a movie as watched.
 await libraryApi.setMovieWatched('movie-id', Date.now());
 ```
 
+### `getMovieWatched(movieId: string): Promise<IWatched>`
+
+Gets the watched status for a movie.
+
+**Parameters:**
+
+- `movieId`: The ID of the movie
+
+**Returns:** Promise resolving to an `IWatched` object containing watched date and metadata
+
+**Example:**
+
+```typescript
+const watched = await libraryApi.getMovieWatched('movie-id');
+console.log(`Watched on: ${new Date(watched.date).toLocaleDateString()}`);
+```
+
+### `getMovieProgress(movieId: string): Promise<IViewProgress>`
+
+Gets the view progress for a movie.
+
+**Parameters:**
+
+- `movieId`: The ID of the movie
+
+**Returns:** Promise resolving to an `IViewProgress` object containing progress value
+
+**Example:**
+
+```typescript
+const progress = await libraryApi.getMovieProgress('movie-id');
+console.log(`Progress: ${progress.progress}ms`);
+```
+
+### `setMovieProgress(movieId: string, progress: number): Promise<void>`
+
+Sets the view progress for a movie.
+
+**Parameters:**
+
+- `movieId`: The ID of the movie
+- `progress`: Progress value (typically in milliseconds for video playback position)
+
+**Example:**
+
+```typescript
+// Save progress at 45 minutes
+await libraryApi.setMovieProgress('movie-id', 2700000);
+```
+
 ### `searchMovies(name: string): Promise<IMovie[]>`
 
 Searches for movies by name.

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@redseat/api",
-    "version": "0.3.0",
+    "version": "0.3.6",
     "description": "TypeScript API client library for interacting with Redseat servers",
     "type": "module",
     "main": "./dist/index.js",

package/server.md

@@ -109,17 +109,98 @@ plugins.forEach(plugin => {
 });
 ```
 
-### `getCredentials(): Promise<any[]>`
+### `getCredentials(): Promise<ICredential[]>`
 
 Retrieves all available credentials configured on the server.
 
-**Returns:** Promise resolving to an array of credential objects
+**Returns:** Promise resolving to an array of `ICredential` objects
 
 **Example:**
 ```typescript
 const credentials = await serverApi.getCredentials();
 credentials.forEach(cred => {
-    console.log(`Credential: ${cred.name} (${cred.type})`);
+    console.log(`Credential: ${cred.name} (${cred.type.type})`);
+});
+```
+
+### `saveCredential(credential: ICredential): Promise<ICredential>`
+
+Creates a new credential on the server.
+
+**Parameters:**
+- `credential`: Credential object with required fields:
+  - `name`: Credential name (required)
+  - `source`: Plugin/source name (required)
+  - `type`: Authentication type object (required)
+  - `settings`: Settings record for plugin params (required)
+  - `login`: Optional login/username
+  - `password`: Optional password/token
+
+**Returns:** Promise resolving to the created `ICredential` object with generated `id`
+
+**Example:**
+```typescript
+const newCredential = await serverApi.saveCredential({
+    name: 'My API Key',
+    source: 'jackett',
+    type: { type: PluginAuthType.Token },
+    settings: { url: 'http://localhost:9117' },
+    password: 'my-api-key'
+});
+console.log(`Created credential with ID: ${newCredential.id}`);
+```
+
+### `updateCredential(credential: ICredential): Promise<ICredential>`
+
+Updates an existing credential.
+
+**Parameters:**
+- `credential`: Credential object with `id` and fields to update
+
+**Returns:** Promise resolving to the updated `ICredential` object
+
+**Example:**
+```typescript
+const updated = await serverApi.updateCredential({
+    id: 'cred-123',
+    name: 'Updated Name',
+    source: 'jackett',
+    type: { type: PluginAuthType.Token },
+    settings: { url: 'http://localhost:9117' },
+    password: 'new-api-key'
+});
+```
+
+### `deleteCredential(id: string): Promise<void>`
+
+Deletes a credential by ID.
+
+**Parameters:**
+- `id`: The credential ID to delete
+
+**Returns:** Promise resolving when deletion is complete
+
+**Example:**
+```typescript
+await serverApi.deleteCredential('cred-123');
+```
+
+### `saveOAuthCredentials(pluginId: string, params: Record<string, string>): Promise<void>`
+
+Exchanges OAuth tokens and saves credentials for a plugin.
+
+**Parameters:**
+- `pluginId`: The plugin ID to save credentials for
+- `params`: OAuth parameters including tokens and name
+
+**Returns:** Promise resolving when credentials are saved
+
+**Example:**
+```typescript
+await serverApi.saveOAuthCredentials('trakt', {
+    name: 'My Trakt Account',
+    code: 'oauth-code',
+    access_token: 'token123'
 });
 ```
 
@@ -141,6 +222,127 @@ const library = await serverApi.addLibraryCredential({
 });
 ```
 
+## History Methods
+
+These methods manage the user's watch history and progress tracking across all libraries.
+
+### `getHistory(query?: HistoryQuery): Promise<IWatched[]>`
+
+Retrieves the current user's watch history.
+
+**Parameters:**
+- `query`: Optional query object with filtering parameters:
+  - `sort`: Sort key using `RsSort` enum
+  - `order`: Sort direction using `SqlOrder` enum (`ASC` or `DESC`)
+  - `before`: Filter entries before this timestamp
+  - `after`: Filter entries after this timestamp
+  - `types`: Array of `MediaType` to filter by (`'episode'`, `'movie'`, `'book'`, `'song'`, `'media'`)
+  - `id`: Filter by specific ID
+  - `pageKey`: Pagination key
+
+**Returns:** Promise resolving to an array of `IWatched` objects
+
+**Example:**
+```typescript
+// Get all history
+const history = await serverApi.getHistory();
+
+// Get recent movie watch history
+const movieHistory = await serverApi.getHistory({
+    types: ['movie'],
+    order: SqlOrder.DESC,
+    after: Date.now() - 86400000 * 30 // Last 30 days
+});
+```
+
+### `addToHistory(watched: IWatchedForAdd): Promise<void>`
+
+Adds an entry to the user's watch history.
+
+**Parameters:**
+- `watched`: Object containing:
+  - `type`: The `MediaType` (`'episode'`, `'movie'`, `'book'`, `'song'`, `'media'`)
+  - `id`: The ID of the watched item
+  - `date`: Timestamp when it was watched
+
+**Returns:** Promise resolving when the entry is added
+
+**Example:**
+```typescript
+await serverApi.addToHistory({
+    type: 'movie',
+    id: 'movie-123',
+    date: Date.now()
+});
+```
+
+### `getProgressById(id: string): Promise<IViewProgress | null>`
+
+Gets the view progress for a specific item by ID.
+
+**Parameters:**
+- `id`: The ID of the item to get progress for
+
+**Returns:** Promise resolving to `IViewProgress` object or `null` if not found
+
+**Example:**
+```typescript
+const progress = await serverApi.getProgressById('movie-123');
+if (progress) {
+    console.log(`Progress: ${progress.progress}ms`);
+}
+```
+
+### `addProgress(progress: IViewProgressForAdd): Promise<void>`
+
+Adds or updates view progress for an item.
+
+**Parameters:**
+- `progress`: Object containing:
+  - `type`: The `MediaType`
+  - `id`: The ID of the item
+  - `progress`: Progress value (typically in milliseconds for video)
+  - `parent`: Optional parent ID (e.g., series ID for episodes)
+
+**Returns:** Promise resolving when progress is saved
+
+**Example:**
+```typescript
+await serverApi.addProgress({
+    type: 'movie',
+    id: 'movie-123',
+    progress: 3600000 // 1 hour in milliseconds
+});
+```
+
+### `getAdminHistory(): Promise<IWatched[]>`
+
+**Admin only.** Retrieves watch history for all users.
+
+**Returns:** Promise resolving to an array of `IWatched` objects
+
+**Example:**
+```typescript
+const allHistory = await serverApi.getAdminHistory();
+```
+
+### `importHistory(watcheds: IWatchedForAdd[]): Promise<void>`
+
+**Admin only.** Imports watch history entries in bulk.
+
+**Parameters:**
+- `watcheds`: Array of `IWatchedForAdd` objects to import
+
+**Returns:** Promise resolving when import is complete
+
+**Example:**
+```typescript
+await serverApi.importHistory([
+    { type: 'movie', id: 'movie-1', date: Date.now() - 86400000 },
+    { type: 'episode', id: 'episode-1', date: Date.now() }
+]);
+```
+
 ## Usage Examples
 
 ### Complete Workflow: Create Library and Get Info