@redseat/api 0.0.1

package/dist/library.js

@@ -0,0 +1,589 @@
+import { deriveKey, encryptText as encryptTextUtil, decryptText as decryptTextUtil, encryptBuffer, decryptBuffer, encryptFile as encryptFileUtil, decryptFile as decryptFileUtil, decryptFileThumb, encryptFilename as encryptFilenameUtil, getRandomIV as getRandomIVUtil, } from './encryption';
+import { uint8ArrayFromBase64 } from './crypto';
+export class LibraryApi {
+    constructor(client, libraryId, library) {
+        this.client = client;
+        this.libraryId = libraryId;
+        this.library = library;
+    }
+    async setKey(passPhrase) {
+        // Derive keys
+        const key = await deriveKey(passPhrase, 'file');
+        const keyText = await deriveKey(passPhrase, 'text');
+        // If library is encrypted, verify the key by trying to decrypt a media thumb
+        if (this.library.crypt === true) {
+            try {
+                // Get one media with a thumbnail
+                const medias = await this.getMedias({ limit: 1 });
+                if (medias.length === 0) {
+                    // No medias to verify against - just store the keys
+                    this.key = key;
+                    this.keyText = keyText;
+                    return;
+                }
+                const media = medias[0];
+                if (!media.thumbsize || media.thumbsize === 0) {
+                    // No thumbnail to verify against - just store the keys
+                    this.key = key;
+                    this.keyText = keyText;
+                    return;
+                }
+                // Check if IV is available in metadata
+                if (!media.iv) {
+                    // No IV available - cannot verify key, just store the keys
+                    this.key = key;
+                    this.keyText = keyText;
+                    return;
+                }
+                // Convert IV from base64 to Uint8Array
+                const iv = uint8ArrayFromBase64(media.iv);
+                // Get the encrypted thumb (already sliced, not the full file)
+                const encryptedThumb = await this.getThumb(media.id, { type: 'arraybuffer' });
+                const thumbBuffer = encryptedThumb instanceof ArrayBuffer
+                    ? encryptedThumb
+                    : await encryptedThumb.arrayBuffer();
+                // Try to decrypt the thumb using decryptBuffer (since getThumb returns the already-sliced encrypted thumb)
+                await decryptBuffer(key, iv, thumbBuffer);
+                // If decryption succeeds, store the keys
+                this.key = key;
+                this.keyText = keyText;
+            }
+            catch (error) {
+                // Decryption failed - wrong password
+                throw new Error('Invalid encryption key. Failed to decrypt media thumbnail.');
+            }
+        }
+        else {
+            // Library is not encrypted - just store the keys
+            this.key = key;
+            this.keyText = keyText;
+        }
+        console.log('Key set', this.key, this.keyText);
+    }
+    getUrl(path) {
+        return `/libraries/${this.libraryId}${path}`;
+    }
+    async getTags() {
+        const res = await this.client.get(this.getUrl('/tags'));
+        return res.data;
+    }
+    async getPeople() {
+        const res = await this.client.get(this.getUrl('/people'));
+        return res.data;
+    }
+    async getSeries() {
+        const res = await this.client.get(this.getUrl('/series'), {
+            params: { sort: 'name', order: 'ASC' }
+        });
+        return res.data;
+    }
+    async getMovies() {
+        const res = await this.client.get(this.getUrl('/movies'));
+        return res.data;
+    }
+    async getMedias(filter) {
+        const params = {};
+        if (filter) {
+            params.filter = JSON.stringify(filter);
+        }
+        const res = await this.client.get(this.getUrl('/medias'), { params });
+        return res.data;
+    }
+    async createTag(tag) {
+        const res = await this.client.post(this.getUrl('/tags'), tag);
+        return res.data;
+    }
+    async removeTag(tagId) {
+        await this.client.delete(this.getUrl(`/tags/${tagId}`));
+    }
+    async renameTag(tagId, newName) {
+        const res = await this.client.patch(this.getUrl(`/tags/${tagId}`), { rename: newName });
+        return res.data;
+    }
+    async tagChangeParent(tagId, newParent) {
+        const res = await this.client.patch(this.getUrl(`/tags/${tagId}`), { parent: newParent });
+        return res.data;
+    }
+    async tagMerge(fromId, intoId) {
+        const res = await this.client.patch(this.getUrl(`/tags/${fromId}/merge`), { into: intoId });
+        return res.data;
+    }
+    async tagAddAlt(tagId, alt) {
+        const res = await this.client.patch(this.getUrl(`/tags/${tagId}`), { addAlts: [alt] });
+        return res.data;
+    }
+    async tagRemoveAlt(tagId, alt) {
+        const res = await this.client.patch(this.getUrl(`/tags/${tagId}`), { removeAlts: [alt] });
+        return res.data;
+    }
+    async mediaTransfer(formData) {
+        await this.client.put(this.getUrl('/medias/transfert'), formData);
+    }
+    async mediaTransferMany(medias, deleteOriginal, toLibraryId) {
+        await this.client.post(this.getUrl(`/medias/transfert/${toLibraryId}`), { ids: medias, deleteOriginal });
+    }
+    async mediaTransferSingle(mediaId, toLibraryId, formData, params) {
+        const queryParams = {};
+        if (params) {
+            for (const [key, value] of params) {
+                queryParams[key] = value;
+            }
+        }
+        await this.client.put(this.getUrl(`/medias/${mediaId}/transfert/${toLibraryId}`), formData, { params: queryParams });
+    }
+    async removeMedias(mediaIds) {
+        await this.client.delete(this.getUrl('/medias'), { data: { ids: mediaIds } });
+    }
+    async getMediaMetadata(mediaId) {
+        const res = await this.client.get(this.getUrl(`/medias/${mediaId}`));
+        return res.data;
+    }
+    async getMediaBackupMetadatas(mediaId) {
+        const res = await this.client.get(this.getUrl(`/medias/${mediaId}/backups`));
+        return res.data;
+    }
+    async clean() {
+        const res = await this.client.get(this.getUrl('/clean'));
+        return res.data;
+    }
+    async locs() {
+        const res = await this.client.get(this.getUrl('/locs'));
+        return res.data;
+    }
+    async createPerson(person) {
+        const res = await this.client.post(this.getUrl('/people'), person);
+        return res.data;
+    }
+    async removePerson(personId) {
+        await this.client.delete(this.getUrl(`/people/${personId}`));
+    }
+    async updatePerson(personId, updates) {
+        const res = await this.client.patch(this.getUrl(`/people/${personId}`), updates);
+        return res.data;
+    }
+    async createSerie(serie) {
+        const res = await this.client.post(this.getUrl('/series'), serie);
+        return res.data;
+    }
+    async createEpisode(episode) {
+        const res = await this.client.post(this.getUrl('/episodes'), episode);
+        return res.data;
+    }
+    async serieScrap(serieId, date) {
+        await this.client.post(this.getUrl(`/series/${serieId}/scrap`), { date });
+    }
+    async removeSerie(serieId) {
+        await this.client.delete(this.getUrl(`/series/${serieId}`));
+    }
+    async updateSerie(serieId, updates) {
+        const res = await this.client.patch(this.getUrl(`/series/${serieId}`), updates);
+        return res.data;
+    }
+    async getSerieImages(serieId) {
+        const res = await this.client.get(this.getUrl(`/series/${serieId}/images`));
+        return res.data;
+    }
+    async updateSeriePoster(serieId, poster, type) {
+        await this.client.post(this.getUrl(`/series/${serieId}/image?type=${type}`), poster);
+    }
+    async updateSerieImageFetch(serieId, image) {
+        await this.client.post(this.getUrl(`/series/${serieId}/image/fetch`), image);
+    }
+    async updateSeriePosterWithMediaThumb(serieId, mediaId, type) {
+        const res = await this.client.post(this.getUrl(`/series/${serieId}/${type}?media=${mediaId}`), undefined);
+        return res.data;
+    }
+    async createMovie(movie) {
+        const res = await this.client.post(this.getUrl('/movies'), movie);
+        return res.data;
+    }
+    async movieScrap(movieId, date) {
+        await this.client.post(this.getUrl(`/movies/${movieId}/scrap`), { date });
+    }
+    async removeMovie(movieId) {
+        await this.client.delete(this.getUrl(`/movies/${movieId}`));
+    }
+    async updateMovie(movieId, updates) {
+        const res = await this.client.patch(this.getUrl(`/movies/${movieId}`), updates);
+        return res.data;
+    }
+    async getMovieImages(movieId) {
+        const res = await this.client.get(this.getUrl(`/movies/${movieId}/images`));
+        return res.data;
+    }
+    async setMovieWatched(movieId, date) {
+        await this.client.post(this.getUrl(`/movies/${movieId}/watched`), { date });
+    }
+    async searchMovies(name) {
+        const res = await this.client.get(this.getUrl(`/movies/search?name=${name}`));
+        return res.data;
+    }
+    async movieRename(movieId, newName) {
+        const res = await this.client.patch(this.getUrl(`/movies/${movieId}`), { name: newName });
+        return res.data;
+    }
+    async updateMoviePoster(movieId, poster, type) {
+        await this.client.post(this.getUrl(`/movies/${movieId}/image?type=${type}`), poster);
+    }
+    async updateMovieImageFetch(movieId, image) {
+        await this.client.post(this.getUrl(`/movies/${movieId}/image/fetch`), image);
+    }
+    async addTagToMedia(mediaId, tagId) {
+        await this.client.post(this.getUrl(`/medias/${mediaId}/tags/${tagId}`), {});
+    }
+    async removeTagFromMedia(mediaId, tagId) {
+        await this.client.delete(this.getUrl(`/medias/${mediaId}/tags/${tagId}`));
+    }
+    async getCryptChallenge() {
+        const res = await this.client.get(this.getUrl('/cryptchallenge'));
+        return res.data.value;
+    }
+    async getChannels() {
+        const res = await this.client.get(this.getUrl('/channels'));
+        return res.data;
+    }
+    async personRename(personId, newName) {
+        const res = await this.client.patch(this.getUrl(`/people/${personId}`), { name: newName });
+        return res.data;
+    }
+    async personUpdate(personId, updates) {
+        const res = await this.client.patch(this.getUrl(`/people/${personId}`), updates);
+        return res.data;
+    }
+    async personAddAlt(personId, alt) {
+        const res = await this.client.patch(this.getUrl(`/people/${personId}`), { addAlts: [alt] });
+        return res.data;
+    }
+    async personRemoveAlt(personId, alt) {
+        const res = await this.client.patch(this.getUrl(`/people/${personId}`), { removeAlts: [alt] });
+        return res.data;
+    }
+    async personAddSocial(personId, social) {
+        const res = await this.client.patch(this.getUrl(`/people/${personId}`), { addSocials: [social] });
+        return res.data;
+    }
+    async personRemoveSocial(personId, social) {
+        const res = await this.client.patch(this.getUrl(`/people/${personId}`), { removeSocials: [social] });
+        return res.data;
+    }
+    async serieRename(serieId, newName) {
+        const res = await this.client.patch(this.getUrl(`/series/${serieId}`), { name: newName });
+        return res.data;
+    }
+    async serieAddAlt(serieId, alt) {
+        const res = await this.client.patch(this.getUrl(`/series/${serieId}`), { addAlts: [alt] });
+        return res.data;
+    }
+    async serieRemoveAlt(serieId, alt) {
+        const res = await this.client.patch(this.getUrl(`/series/${serieId}`), { removeAlts: [alt] });
+        return res.data;
+    }
+    async updatePersonPortrait(personId, portrait) {
+        await this.client.post(this.getUrl(`/people/${personId}/image?size=thumb&type=poster`), portrait);
+    }
+    async searchSeries(name) {
+        const res = await this.client.get(this.getUrl(`/series/search?name=${name}`));
+        return res.data;
+    }
+    async setEpisodeWatched(serieId, season, number, date) {
+        await this.client.post(this.getUrl(`/series/${serieId}/seasons/${season}/episodes/${number}/watched`), { date });
+    }
+    async getUnassignedFaces(params) {
+        const queryParams = {};
+        if (params) {
+            for (const [key, value] of params) {
+                queryParams[key] = value;
+            }
+        }
+        const res = await this.client.get(this.getUrl('/faces/unassigned'), { params: queryParams });
+        return res.data;
+    }
+    async getClusters() {
+        const res = await this.client.get(this.getUrl('/faces/clusters'));
+        return res.data;
+    }
+    async assignFaces(request) {
+        const res = await this.client.post(this.getUrl('/faces/assign'), request);
+        return res.data;
+    }
+    async createPersonFromCluster(request) {
+        const res = await this.client.post(this.getUrl('/faces/cluster/person'), request);
+        return res.data;
+    }
+    async splitCluster(request) {
+        const res = await this.client.post(this.getUrl('/faces/cluster/split'), request);
+        return res.data;
+    }
+    async unassignFace(request) {
+        const res = await this.client.post(this.getUrl('/faces/unassign'), request);
+        return res.data;
+    }
+    async deleteFace(faceId) {
+        const res = await this.client.delete(this.getUrl(`/faces/${faceId}`));
+        return res.data;
+    }
+    async getAssignedFaces(personId) {
+        const res = await this.client.get(this.getUrl(`/people/${personId}/faces`));
+        return res.data;
+    }
+    async faceClusterPerson(personId) {
+        await this.client.post(this.getUrl(`/people/${personId}/faces/cluster`), {});
+    }
+    async mergePeople(request) {
+        const res = await this.client.post(this.getUrl('/people/merge'), request);
+        return res.data;
+    }
+    async clusterFaces(personId) {
+        const res = await this.client.post(this.getUrl(`/people/${personId}/faces/cluster`), {});
+        return res.data;
+    }
+    async getMediaPureMetadata(mediaId) {
+        const res = await this.client.get(this.getUrl(`/medias/${mediaId}`));
+        return res.data;
+    }
+    async mergeMedias(request) {
+        const res = await this.client.post(this.getUrl('/medias/merge'), request);
+        return res.data;
+    }
+    async mediaUpdateMany(update, ids) {
+        const res = await this.client.patch(this.getUrl('/medias'), { update, ids });
+        return res.data;
+    }
+    async mediaUpdateProgress(mediaId, progress) {
+        const res = await this.client.patch(this.getUrl(`/medias/${mediaId}/progress`), { progress });
+        return res.data;
+    }
+    async mediaUpdateChannel(mediaId, update) {
+        const res = await this.client.patch(this.getUrl(`/medias/${mediaId}/channel`), update);
+        return res.data;
+    }
+    async refreshMedia(mediaId) {
+        const res = await this.client.get(this.getUrl(`/medias/${mediaId}/metadata/refresh`));
+        return res.data;
+    }
+    async aiTagMedia(mediaId) {
+        const res = await this.client.get(this.getUrl(`/medias/${mediaId}/predict`));
+        return res.data;
+    }
+    async mediaUpdate(mediaId, update) {
+        const res = await this.client.patch(this.getUrl(`/medias/${mediaId}`), update);
+        return res.data;
+    }
+    async splitZip(mediaId, from, to) {
+        const res = await this.client.get(this.getUrl(`/medias/${mediaId}/split`), { params: { from, to } });
+        return res.data;
+    }
+    async deleteFromZip(mediaId, pages) {
+        const res = await this.client.get(this.getUrl(`/medias/${mediaId}/split`), { params: { exclude: pages.join(','), replace: 'true' } });
+        return res.data;
+    }
+    async updateMediaThumb(mediaId, thumb) {
+        await this.client.post(this.getUrl(`/medias/${mediaId}/image`), thumb);
+    }
+    async getMediaShares(mediaId) {
+        const res = await this.client.get(this.getUrl(`/medias/${mediaId}/shares`));
+        return res.data;
+    }
+    async shareMediaToProvider(mediaId, provider, formData) {
+        if (formData) {
+            const res = await this.client.post(this.getUrl(`/medias/${mediaId}/share/${provider}`), formData);
+            return res.data;
+        }
+        else {
+            const res = await this.client.get(this.getUrl(`/medias/${mediaId}/share/${provider}`));
+            return res.data;
+        }
+    }
+    async expandUrl(parsedUrl) {
+        const res = await this.client.post(this.getUrl('/plugins/url/expand'), parsedUrl);
+        return res.data;
+    }
+    async parseUrl(url) {
+        const res = await this.client.get(this.getUrl('/plugins/url/parse'), { params: { url } });
+        return res.data;
+    }
+    async listVideoConvertPlugins() {
+        const res = await this.client.get(this.getUrl('/plugins/videoconvert'));
+        return res.data;
+    }
+    async getMedia(mediaId, options) {
+        const type = options?.type ?? 'stream';
+        const res = await this.client.get(this.getUrl(`/medias/${mediaId}`), { responseType: type });
+        return res.data;
+    }
+    async getThumb(mediaId, options) {
+        const type = options?.type ?? 'stream';
+        const res = await this.client.get(this.getUrl(`/medias/${mediaId}/image?size=thumb`), { responseType: type });
+        return res.data;
+    }
+    async getWatermarks() {
+        const res = await this.client.get(this.getUrl('/watermarks'));
+        return res.data;
+    }
+    async getWatermark(watermark, options) {
+        const watermarkName = watermark || 'default';
+        const type = options?.type ?? 'blob';
+        const res = await this.client.get(this.getUrl(`/watermarks/${watermarkName}`), { responseType: type });
+        return res.data;
+    }
+    // Encryption methods
+    /**
+     * Encrypt a text string using a passphrase
+     * Returns format: `${base64ToBase64Url(IV)}.${base64ToBase64Url(encryptedData)}`
+     */
+    async encryptText(passPhrase, text) {
+        const key = await deriveKey(passPhrase, 'text');
+        return await encryptTextUtil(key, text);
+    }
+    /**
+     * Decrypt a text string using a passphrase
+     * Expects format: `${base64ToBase64Url(IV)}.${base64ToBase64Url(encryptedData)}`
+     */
+    async decryptText(passPhrase, encryptedText) {
+        const key = await deriveKey(passPhrase, 'text');
+        return await decryptTextUtil(key, encryptedText);
+    }
+    /**
+     * Encrypt a media file buffer using a passphrase
+     */
+    async encryptMedia(passPhrase, buffer, iv) {
+        const key = await deriveKey(passPhrase, 'file');
+        const usedIv = iv || getRandomIVUtil();
+        return await encryptBuffer(key, usedIv, buffer);
+    }
+    /**
+     * Decrypt a media file buffer using a passphrase
+     */
+    async decryptMedia(passPhrase, buffer, iv) {
+        const key = await deriveKey(passPhrase, 'file');
+        return await decryptBuffer(key, iv, buffer);
+    }
+    /**
+     * Encrypt a complete file with thumbnail and metadata
+     */
+    async encryptFile(passPhrase, options) {
+        const key = await deriveKey(passPhrase, 'file');
+        return await encryptFileUtil(key, options);
+    }
+    /**
+     * Decrypt a file buffer (extracts and decrypts file data from encrypted file structure)
+     */
+    async decryptFile(passPhrase, buffer) {
+        const key = await deriveKey(passPhrase, 'file');
+        return await decryptFileUtil(key, buffer);
+    }
+    /**
+     * Decrypt a file thumbnail (extracts and decrypts thumbnail from encrypted file structure)
+     */
+    async decryptMediaThumb(passPhrase, buffer) {
+        const key = await deriveKey(passPhrase, 'file');
+        return await decryptFileThumb(key, buffer);
+    }
+    /**
+     * Encrypt a filename using a passphrase
+     * Returns base64url encoded encrypted filename
+     */
+    async encryptFilename(passPhrase, filename, iv) {
+        const key = await deriveKey(passPhrase, 'file');
+        return await encryptFilenameUtil(key, filename, iv);
+    }
+    /**
+     * Generate a random 16-byte IV (Initialization Vector)
+     */
+    getRandomIV() {
+        return getRandomIVUtil();
+    }
+    /**
+     * Upload media file to the server
+     * @param data - The file data as ArrayBuffer or Uint8Array (clients must convert streams/buffers before calling)
+     * @param options - Upload options including thumbnail, metadata, mime types, and progress callback
+     * @returns Promise resolving to array of created IFile objects (IV will be in IFile.iv for encrypted files)
+     */
+    async uploadMedia(data, options) {
+        // Validate: thumbnails can only be specified for encrypted libraries
+        if (options.thumb && this.library.crypt !== true) {
+            throw new Error('Thumbnails can only be specified for encrypted libraries.');
+        }
+        // Check library configuration
+        if (this.library.crypt === true) {
+            if (!this.key) {
+                throw new Error('Encryption key not set. Call setKey() first.');
+            }
+        }
+        // Normalize inputs to ArrayBuffer
+        let dataBuffer;
+        if (data instanceof Uint8Array) {
+            // Create a new ArrayBuffer and copy the data
+            dataBuffer = data.slice().buffer;
+        }
+        else {
+            // Create a new Uint8Array view and get its buffer to ensure it's a proper ArrayBuffer
+            const view = new Uint8Array(data);
+            dataBuffer = view.buffer.slice(view.byteOffset, view.byteOffset + view.byteLength);
+        }
+        let fileBlob;
+        let metadata = { ...options.metadata };
+        let filename;
+        if (this.library.crypt === true && this.key) {
+            if (!this.keyText) {
+                throw new Error('Text encryption key not set. Call setKey() first.');
+            }
+            // Encryption required - use encryptFile function
+            // Normalize thumb buffer
+            let thumbBuffer;
+            if (options.thumb) {
+                if (options.thumb instanceof Uint8Array) {
+                    thumbBuffer = options.thumb.slice().buffer;
+                }
+                else {
+                    const view = new Uint8Array(options.thumb);
+                    thumbBuffer = view.buffer.slice(view.byteOffset, view.byteOffset + view.byteLength);
+                }
+            }
+            else {
+                thumbBuffer = new ArrayBuffer(0);
+            }
+            const thumbMime = options.thumbMime || 'image/jpeg';
+            const originalFilename = options.metadata.name || 'file';
+            // Use the existing encryptFile function
+            const encrypted = await encryptFileUtil(this.key, {
+                filename: originalFilename, // This will be replaced with text-encrypted filename
+                buffer: dataBuffer,
+                thumb: thumbBuffer,
+                thumbMime: thumbMime,
+                mime: options.fileMime
+            });
+            fileBlob = new Blob([encrypted.blob], { type: options.fileMime });
+            // Encrypt filename using text encryption format (<iv>.<encryptedtext>)
+            const encryptedFilename = await encryptTextUtil(this.keyText, originalFilename);
+            // Update metadata with IV and encrypted filename
+            metadata.iv = encrypted.ivb64;
+            metadata.name = encryptedFilename; // Use text-encrypted filename
+            metadata.thumbsize = encrypted.thumbsize;
+            // Use encrypted filename for FormData
+            filename = encryptedFilename;
+        }
+        else {
+            // No encryption - use original filename
+            filename = options.metadata.name || 'file';
+            fileBlob = new Blob([dataBuffer], { type: options.fileMime });
+        }
+        // Create FormData
+        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
+        const config = {};
+        if (options.progressCallback) {
+            config.onUploadProgress = (progressEvent) => {
+                if (progressEvent.total) {
+                    options.progressCallback(progressEvent.loaded, progressEvent.total);
+                }
+            };
+        }
+        const res = await this.client.post(this.getUrl('/medias'), formData, config);
+        return res.data;
+    }
+}

package/dist/server.d.ts

@@ -0,0 +1,13 @@
+import { RedseatClient } from './client';
+import { ILibrary } from './interfaces';
+export declare class ServerApi {
+    private client;
+    constructor(client: RedseatClient);
+    getLibraries(): Promise<ILibrary[]>;
+    getMe(): Promise<any>;
+    addLibrary(library: Partial<ILibrary>): Promise<ILibrary>;
+    getSetting(key: string): Promise<string>;
+    getPlugins(): Promise<any[]>;
+    getCredentials(): Promise<any[]>;
+    addLibraryCredential(credential: any): Promise<ILibrary>;
+}

package/dist/server.js

@@ -0,0 +1,33 @@
+export class ServerApi {
+    constructor(client) {
+        this.client = client;
+    }
+    async getLibraries() {
+        const res = await this.client.get('/libraries');
+        return res.data;
+    }
+    async getMe() {
+        const res = await this.client.get('/users/me');
+        return res.data;
+    }
+    async addLibrary(library) {
+        const res = await this.client.post('/libraries', library);
+        return res.data;
+    }
+    async getSetting(key) {
+        const res = await this.client.get(`/settings/${key}`);
+        return res.data.value;
+    }
+    async getPlugins() {
+        const res = await this.client.get('/plugins');
+        return res.data;
+    }
+    async getCredentials() {
+        const res = await this.client.get('/credentials');
+        return res.data;
+    }
+    async addLibraryCredential(credential) {
+        const res = await this.client.post('/libraries/credential', credential);
+        return res.data;
+    }
+}

package/dist/upload.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Helper functions for upload blob formatting
+ */
+/**
+ * Convert string to ArrayBuffer
+ * @param str - The string to convert
+ * @param size - Optional size for the buffer (defaults to str.length * 2)
+ * @returns ArrayBuffer containing the string as UTF-16
+ */
+export declare function str2ab(str: string, size?: number): ArrayBuffer;
+/**
+ * Convert number to 4-byte big-endian ArrayBuffer
+ * @param num - The number to convert
+ * @returns ArrayBuffer containing the number as 4-byte big-endian
+ */
+export declare function toBytesInt32(num: number): ArrayBuffer;

package/dist/upload.js

@@ -0,0 +1,28 @@
+/**
+ * Helper functions for upload blob formatting
+ */
+/**
+ * Convert string to ArrayBuffer
+ * @param str - The string to convert
+ * @param size - Optional size for the buffer (defaults to str.length * 2)
+ * @returns ArrayBuffer containing the string as UTF-16
+ */
+export function str2ab(str, size) {
+    const buf = new ArrayBuffer(size ?? str.length * 2); // 2 bytes for each char
+    const bufView = new Uint16Array(buf);
+    for (let i = 0, strLen = str.length; i < strLen; i++) {
+        bufView[i] = str.charCodeAt(i);
+    }
+    return buf;
+}
+/**
+ * Convert number to 4-byte big-endian ArrayBuffer
+ * @param num - The number to convert
+ * @returns ArrayBuffer containing the number as 4-byte big-endian
+ */
+export function toBytesInt32(num) {
+    const arr = new ArrayBuffer(4); // an Int32 takes 4 bytes
+    const view = new DataView(arr);
+    view.setUint32(0, num, false); // byteOffset = 0; littleEndian = false (big-endian)
+    return arr;
+}