@redseat/api 0.2.8 → 0.3.5

package/client.md

@@ -458,13 +458,15 @@ client.medias$.subscribe(event => {
 });
 ```
 
-#### `mediasProgress$: Observable<SSEMediasProgressEvent>`
+#### `uploadProgress$: Observable<SSEUploadProgressEvent>`
 
-Emits media processing progress updates.
+Emits upload progress updates including download, transfer, and analysis stages.
 
 ```typescript
-client.mediasProgress$.subscribe(event => {
-    console.log(`Media ${event.mediaId}: ${event.progress}%`);
+client.uploadProgress$.subscribe(event => {
+    const { progress } = event;
+    const percent = progress.total ? Math.round((progress.current ?? 0) / progress.total * 100) : 0;
+    console.log(`Upload ${progress.id} (${progress.type}): ${percent}% - ${progress.filename}`);
 });
 ```
 
@@ -558,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, SSEMediasProgressEvent, 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>;
@@ -33,7 +33,7 @@ export declare class RedseatClient {
     readonly library$: Observable<SSELibraryEvent>;
     readonly libraryStatus$: Observable<SSELibraryStatusEvent>;
     readonly medias$: Observable<SSEMediasEvent>;
-    readonly mediasProgress$: Observable<SSEMediasProgressEvent>;
+    readonly uploadProgress$: Observable<SSEUploadProgressEvent>;
     readonly convertProgress$: Observable<SSEConvertProgressEvent>;
     readonly episodes$: Observable<SSEEpisodesEvent>;
     readonly series$: Observable<SSESeriesEvent>;
@@ -42,8 +42,12 @@ 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
+     * Creates a typed observable for a specific SSE event type.
+     * Unwraps the nested data structure from the server (e.g., {uploadProgress: {...}} -> {...})
      */
     private createEventStream;
     constructor(options: ClientOptions);

package/dist/client.js

@@ -3,10 +3,31 @@ import { BehaviorSubject, Subject, filter, map } from 'rxjs';
 import { fetchServerToken } from './auth.js';
 export class RedseatClient {
     /**
-     * Creates a typed observable for a specific SSE event type
+     * Creates a typed observable for a specific SSE event type.
+     * Unwraps the nested data structure from the server (e.g., {uploadProgress: {...}} -> {...})
      */
     createEventStream(eventName) {
-        return this._sseEvents.pipe(filter((event) => event.event === eventName), map(event => event.data));
+        // 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) {
+                return data[wrapperKey];
+            }
+            return event.data;
+        }));
     }
     constructor(options) {
         this.sseReconnectAttempts = 0;
@@ -22,7 +43,7 @@ export class RedseatClient {
         this.library$ = this.createEventStream('library');
         this.libraryStatus$ = this.createEventStream('library-status');
         this.medias$ = this.createEventStream('medias');
-        this.mediasProgress$ = this.createEventStream('medias_progress');
+        this.uploadProgress$ = this.createEventStream('upload_progress');
         this.convertProgress$ = this.createEventStream('convert_progress');
         this.episodes$ = this.createEventStream('episodes');
         this.series$ = this.createEventStream('series');
@@ -31,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;
@@ -303,6 +327,7 @@ export class RedseatClient {
             }
             const url = this.buildSSEUrl();
             this.sseAbortController = new AbortController();
+            console.log("SSSEEEE URL", url);
             const response = await fetch(url, {
                 method: 'GET',
                 headers: {
@@ -323,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') {
@@ -366,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",
@@ -499,6 +545,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, SSEMediasProgressEvent, SSEConvertProgressEvent, SSEEpisodesEvent, SSESeriesEvent, SSEMoviesEvent, SSEPeopleEvent, SSETagsEvent, SSELibraryStatusEvent } from './sse-types.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;
@@ -77,7 +77,7 @@ export interface LibraryHttpClient {
     getFullUrl(path: string, params?: Record<string, string>): string;
     getAuthToken(): string;
     readonly medias$?: Observable<SSEMediasEvent>;
-    readonly mediasProgress$?: Observable<SSEMediasProgressEvent>;
+    readonly uploadProgress$?: Observable<SSEUploadProgressEvent>;
     readonly convertProgress$?: Observable<SSEConvertProgressEvent>;
     readonly episodes$?: Observable<SSEEpisodesEvent>;
     readonly series$?: Observable<SSESeriesEvent>;
@@ -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;
@@ -94,7 +96,7 @@ export declare class LibraryApi {
     private keyText?;
     private disposed;
     readonly medias$: Observable<SSEMediasEvent>;
-    readonly mediasProgress$: Observable<SSEMediasProgressEvent>;
+    readonly uploadProgress$: Observable<SSEUploadProgressEvent>;
     readonly convertProgress$: Observable<SSEConvertProgressEvent>;
     readonly episodes$: Observable<SSEEpisodesEvent>;
     readonly series$: Observable<SSESeriesEvent>;
@@ -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.
@@ -235,6 +239,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

@@ -9,7 +9,7 @@ export class LibraryApi {
         this.library = library;
         // Create library-filtered streams
         this.medias$ = this.createLibraryFilteredStream(client.medias$);
-        this.mediasProgress$ = this.createLibraryFilteredStream(client.mediasProgress$);
+        this.uploadProgress$ = this.createLibraryFilteredStream(client.uploadProgress$);
         this.convertProgress$ = this.createLibraryFilteredStream(client.convertProgress$);
         this.episodes$ = this.createLibraryFilteredStream(client.episodes$);
         this.series$ = this.createLibraryFilteredStream(client.series$);
@@ -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.
@@ -492,6 +494,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 } from './interfaces.js';
 export declare class ServerApi {
     private client;
     constructor(client: RedseatClient);
@@ -12,7 +12,11 @@ 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>;
 }

package/dist/server.js

@@ -30,6 +30,20 @@ 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;

package/dist/sse-types.d.ts

@@ -35,11 +35,20 @@ export interface SSEMediasEvent {
         media: IFile;
     }[];
 }
-export interface SSEMediasProgressEvent {
+export type RsProgressType = 'download' | 'transfert' | 'analysing' | 'finished' | {
+    duplicate: string;
+};
+export interface RsProgress {
+    id: string;
+    total?: number;
+    current?: number;
+    filename?: string;
+    type: RsProgressType;
+}
+export interface SSEUploadProgressEvent {
     library: string;
-    mediaId: string;
-    progress: number;
-    status?: string;
+    progress: RsProgress;
+    remainingSecondes?: number;
 }
 export interface SSEConvertProgressEvent {
     library: string;
@@ -98,11 +107,38 @@ 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;
     'medias': SSEMediasEvent;
-    'medias_progress': SSEMediasProgressEvent;
+    'upload_progress': SSEUploadProgressEvent;
     'convert_progress': SSEConvertProgressEvent;
     'episodes': SSEEpisodesEvent;
     'series': SSESeriesEvent;
@@ -111,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

@@ -98,13 +98,15 @@ libraryApi.medias$.subscribe(event => {
 });
 ```
 
-#### `mediasProgress$: Observable<SSEMediasProgressEvent>`
+#### `uploadProgress$: Observable<SSEUploadProgressEvent>`
 
-Emits media processing progress updates for this library.
+Emits upload progress updates for this library, including download, transfer, and analysis stages.
 
 ```typescript
-libraryApi.mediasProgress$.subscribe(event => {
-    console.log(`Media ${event.mediaId}: ${event.progress}%`);
+libraryApi.uploadProgress$.subscribe(event => {
+    const { progress } = event;
+    const percent = progress.total ? Math.round((progress.current ?? 0) / progress.total * 100) : 0;
+    console.log(`Upload ${progress.id} (${progress.type}): ${percent}% - ${progress.filename}`);
 });
 ```
 
@@ -188,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

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@redseat/api",
-    "version": "0.2.8",
+    "version": "0.3.5",
     "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'
 });
 ```