@jellyfin/sdk 0.7.0

package/lib/discovery/discovery-service.d.ts

@@ -0,0 +1,41 @@
+/**
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+import { Jellyfin, RecommendedServerInfo, RecommendedServerInfoScore } from '..';
+/** Class used for discovering recommended servers. */
+export declare class DiscoveryService {
+    private jellyfin;
+    private recommendedServerDiscovery;
+    constructor(jellyfin: Jellyfin);
+    /**
+     * Finds the best server from a list of recommended servers by score.
+     * @param servers A list of recommended servers.
+     * @returns The best scoring recommended server.
+     */
+    findBestServer(servers: Array<RecommendedServerInfo>): RecommendedServerInfo | undefined;
+    /**
+     * Gets a list of address candidates url strings
+     * from a provided url address string.
+     * @param input A server url address string.
+     * @returns A list of potential server addresses.
+     */
+    getAddressCandidates(input: string): Array<string>;
+    /**
+     * Gets a list of recommended server information from a provided
+     * list of possible server addresses.
+     * @param servers A list of possible server addresses.
+     * @param minimumScore The minimum server score to include in the results.
+     * @returns A list of RecommendedServerInfo from the possible server addresses.
+     */
+    getRecommendedServers(servers: Array<string>, minimumScore?: RecommendedServerInfoScore): Promise<Array<RecommendedServerInfo>>;
+    /**
+     * Gets a list of recommended server information from the address
+     * candidates of a potential server address.
+     * @param input A potential server address.
+     * @param minimumScore The minimum server score to include in the results.
+     * @returns A list of RecommendedServerInfo from the address candidates.
+     */
+    getRecommendedServerCandidates(input: string, minimumScore?: RecommendedServerInfoScore): Promise<Array<RecommendedServerInfo>>;
+}

package/lib/discovery/discovery-service.js

@@ -0,0 +1,112 @@
+"use strict";
+/**
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiscoveryService = void 0;
+var __1 = require("..");
+var utils_1 = require("../utils");
+var recommended_server_discovery_1 = require("./recommended-server-discovery");
+/** Class used for discovering recommended servers. */
+var DiscoveryService = /** @class */ (function () {
+    function DiscoveryService(jellyfin) {
+        this.jellyfin = jellyfin;
+        this.recommendedServerDiscovery = new recommended_server_discovery_1.RecommendedServerDiscovery(this.jellyfin);
+    }
+    /**
+     * Finds the best server from a list of recommended servers by score.
+     * @param servers A list of recommended servers.
+     * @returns The best scoring recommended server.
+     */
+    DiscoveryService.prototype.findBestServer = function (servers) {
+        // First look for GREAT scores
+        var best = servers.find(function (server) { return server.score === __1.RecommendedServerInfoScore.GREAT; });
+        // If no GREAT scores, look for GOOD scores
+        if (!best) {
+            best = servers.find(function (server) { return server.score === __1.RecommendedServerInfoScore.GOOD; });
+        }
+        // If no GREAT or GOOD scores, look for OK scores
+        if (!best) {
+            best = servers.find(function (server) { return server.score === __1.RecommendedServerInfoScore.OK; });
+        }
+        // Do NOT return any BAD scores
+        return best;
+    };
+    /**
+     * Gets a list of address candidates url strings
+     * from a provided url address string.
+     * @param input A server url address string.
+     * @returns A list of potential server addresses.
+     */
+    DiscoveryService.prototype.getAddressCandidates = function (input) {
+        return (0, utils_1.getAddressCandidates)(input);
+    };
+    /**
+     * Gets a list of recommended server information from a provided
+     * list of possible server addresses.
+     * @param servers A list of possible server addresses.
+     * @param minimumScore The minimum server score to include in the results.
+     * @returns A list of RecommendedServerInfo from the possible server addresses.
+     */
+    DiscoveryService.prototype.getRecommendedServers = function (servers, minimumScore) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.recommendedServerDiscovery.discover(servers, minimumScore)];
+            });
+        });
+    };
+    /**
+     * Gets a list of recommended server information from the address
+     * candidates of a potential server address.
+     * @param input A potential server address.
+     * @param minimumScore The minimum server score to include in the results.
+     * @returns A list of RecommendedServerInfo from the address candidates.
+     */
+    DiscoveryService.prototype.getRecommendedServerCandidates = function (input, minimumScore) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.getRecommendedServers(this.getAddressCandidates(input), minimumScore)];
+            });
+        });
+    };
+    return DiscoveryService;
+}());
+exports.DiscoveryService = DiscoveryService;

package/lib/discovery/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+export * from './discovery-service';
+export * from './recommended-server-discovery';

package/lib/discovery/index.js

@@ -0,0 +1,23 @@
+"use strict";
+/**
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./discovery-service"), exports);
+__exportStar(require("./recommended-server-discovery"), exports);

package/lib/discovery/recommended-server-discovery.d.ts

@@ -0,0 +1,23 @@
+/**
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+import { Jellyfin, RecommendedServerInfo, RecommendedServerInfoScore } from '..';
+/** Class to discover and evaluate potential servers. */
+export declare class RecommendedServerDiscovery {
+    private jellyfin;
+    constructor(jellyfin: Jellyfin);
+    /**
+     * Fetches the RecommendedServerInfo for a single server address.
+     * @param address The server address.
+     * @returns The resulting RecommendedServerInfo.
+     */
+    fetchRecommendedServerInfo(address: string): Promise<RecommendedServerInfo>;
+    /**
+     * Fetches the RecommendedServerInfo for multiple server addresses.
+     * @param servers An array of server addresses.
+     * @returns The RecommendedServerInfo for each address.
+     */
+    discover(servers: Array<string>, minimumScore?: RecommendedServerInfoScore): Promise<Array<RecommendedServerInfo>>;
+}

package/lib/discovery/recommended-server-discovery.js

@@ -0,0 +1,153 @@
+"use strict";
+/**
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RecommendedServerDiscovery = void 0;
+var compare_versions_1 = require("compare-versions");
+var __1 = require("..");
+var system_api_1 = require("../utils/api/system-api");
+/** The expected product name in system info. */
+var PRODUCT_NAME = 'Jellyfin Server';
+/** Requests taking longer than 3s are considered slow. */
+var SLOW_RESPONSE_TIME = 3000;
+/** System info request timeout. */
+var HTTP_TIMEOUT = 5000;
+/** Get the minimum RecommendedServerInfoScore from an array. */
+function getMinScore(scores, defaultScore) {
+    if (defaultScore === void 0) { defaultScore = __1.RecommendedServerInfoScore.GREAT; }
+    return scores.length > 0 ? Math.min.apply(Math, scores) : defaultScore;
+}
+/** Builds a RecommendedServerInfo from a SystemInfoResult. */
+function toRecommendedServerInfo(result) {
+    var _a, _b, _c;
+    var issues = [];
+    var scores = [];
+    if (!((_a = result.response) === null || _a === void 0 ? void 0 : _a.data) || result.error) {
+        // The response did not return valid data or returned an error
+        issues.push(new __1.SystemInfoIssue(result.error));
+        scores.push(__1.RecommendedServerInfoScore.BAD);
+    }
+    else if (result.response.data.ProductName !== PRODUCT_NAME) {
+        // The product name returned was invalid
+        issues.push(new __1.ProductNameIssue(result.response.data.ProductName));
+        scores.push(__1.RecommendedServerInfoScore.BAD);
+    }
+    var version = (_b = result.response) === null || _b === void 0 ? void 0 : _b.data.Version;
+    if (!version) {
+        // No version was returned
+        issues.push(new __1.VersionMissingIssue());
+        scores.push(__1.RecommendedServerInfoScore.BAD);
+    }
+    else if ((0, compare_versions_1.compare)(version, __1.MINIMUM_VERSION, '<')) {
+        // Version is less than the minimum supported
+        issues.push(new __1.VersionUnsupportedIssue(version));
+        scores.push(__1.RecommendedServerInfoScore.OK);
+    }
+    else if ((0, compare_versions_1.compare)(version, __1.API_VERSION, '<')) {
+        // Version is less than the generated client, but above the minimum
+        issues.push(new __1.VersionOutdatedIssue(version));
+        scores.push(__1.RecommendedServerInfoScore.GOOD);
+    }
+    if (result.responseTime > SLOW_RESPONSE_TIME) {
+        // Response was slow
+        issues.push(new __1.SlowResponseIssue(result.responseTime));
+        scores.push(__1.RecommendedServerInfoScore.GOOD);
+    }
+    return {
+        address: result.address,
+        responseTime: result.responseTime,
+        score: getMinScore(scores),
+        issues: issues,
+        systemInfo: (_c = result.response) === null || _c === void 0 ? void 0 : _c.data
+    };
+}
+/** Class to discover and evaluate potential servers. */
+var RecommendedServerDiscovery = /** @class */ (function () {
+    function RecommendedServerDiscovery(jellyfin) {
+        this.jellyfin = jellyfin;
+    }
+    /**
+     * Fetches the RecommendedServerInfo for a single server address.
+     * @param address The server address.
+     * @returns The resulting RecommendedServerInfo.
+     */
+    RecommendedServerDiscovery.prototype.fetchRecommendedServerInfo = function (address) {
+        return __awaiter(this, void 0, void 0, function () {
+            var api, startTime;
+            return __generator(this, function (_a) {
+                api = this.jellyfin.createApi(address);
+                startTime = Date.now();
+                return [2 /*return*/, (0, system_api_1.getSystemApi)(api).getPublicSystemInfo({ timeout: HTTP_TIMEOUT })
+                        .then(function (response) { return ({
+                        address: address,
+                        response: response,
+                        responseTime: Date.now() - startTime
+                    }); })
+                        .catch(function (error) { return ({
+                        address: address,
+                        error: error,
+                        responseTime: Date.now() - startTime
+                    }); })
+                        .then(function (result) { return toRecommendedServerInfo(result); })];
+            });
+        });
+    };
+    /**
+     * Fetches the RecommendedServerInfo for multiple server addresses.
+     * @param servers An array of server addresses.
+     * @returns The RecommendedServerInfo for each address.
+     */
+    RecommendedServerDiscovery.prototype.discover = function (servers, minimumScore) {
+        if (minimumScore === void 0) { minimumScore = __1.RecommendedServerInfoScore.BAD; }
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, Promise.all(servers.map(function (server) { return _this.fetchRecommendedServerInfo(server); }))];
+                    case 1: return [2 /*return*/, (_a.sent()).filter(function (serverInfo) { return serverInfo.score >= minimumScore; })];
+                }
+            });
+        });
+    };
+    return RecommendedServerDiscovery;
+}());
+exports.RecommendedServerDiscovery = RecommendedServerDiscovery;

package/lib/generated-client/api/activity-log-api.d.ts

@@ -0,0 +1,113 @@
+/**
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * Do not edit the class manually.
+ *
+ * Jellyfin API
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+import { AxiosPromise, AxiosInstance } from 'axios';
+import { Configuration } from '../configuration';
+import { RequestArgs, BaseAPI } from '../base';
+import { ActivityLogEntryQueryResult } from '../models';
+/**
+ * ActivityLogApi - axios parameter creator
+ * @export
+ */
+export declare const ActivityLogApiAxiosParamCreator: (configuration?: Configuration) => {
+    /**
+     *
+     * @summary Gets activity log entries.
+     * @param {number} [startIndex] Optional. The record index to start at. All items with a lower index will be dropped from the results.
+     * @param {number} [limit] Optional. The maximum number of records to return.
+     * @param {string} [minDate] Optional. The minimum date. Format = ISO.
+     * @param {boolean} [hasUserId] Optional. Filter log entries if it has user id, or not.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    getLogEntries: (startIndex?: number, limit?: number, minDate?: string, hasUserId?: boolean, options?: any) => Promise<RequestArgs>;
+};
+/**
+ * ActivityLogApi - functional programming interface
+ * @export
+ */
+export declare const ActivityLogApiFp: (configuration?: Configuration) => {
+    /**
+     *
+     * @summary Gets activity log entries.
+     * @param {number} [startIndex] Optional. The record index to start at. All items with a lower index will be dropped from the results.
+     * @param {number} [limit] Optional. The maximum number of records to return.
+     * @param {string} [minDate] Optional. The minimum date. Format &#x3D; ISO.
+     * @param {boolean} [hasUserId] Optional. Filter log entries if it has user id, or not.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    getLogEntries(startIndex?: number, limit?: number, minDate?: string, hasUserId?: boolean, options?: any): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ActivityLogEntryQueryResult>>;
+};
+/**
+ * ActivityLogApi - factory interface
+ * @export
+ */
+export declare const ActivityLogApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => {
+    /**
+     *
+     * @summary Gets activity log entries.
+     * @param {number} [startIndex] Optional. The record index to start at. All items with a lower index will be dropped from the results.
+     * @param {number} [limit] Optional. The maximum number of records to return.
+     * @param {string} [minDate] Optional. The minimum date. Format &#x3D; ISO.
+     * @param {boolean} [hasUserId] Optional. Filter log entries if it has user id, or not.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    getLogEntries(startIndex?: number, limit?: number, minDate?: string, hasUserId?: boolean, options?: any): AxiosPromise<ActivityLogEntryQueryResult>;
+};
+/**
+ * Request parameters for getLogEntries operation in ActivityLogApi.
+ * @export
+ * @interface ActivityLogApiGetLogEntriesRequest
+ */
+export interface ActivityLogApiGetLogEntriesRequest {
+    /**
+     * Optional. The record index to start at. All items with a lower index will be dropped from the results.
+     * @type {number}
+     * @memberof ActivityLogApiGetLogEntries
+     */
+    readonly startIndex?: number;
+    /**
+     * Optional. The maximum number of records to return.
+     * @type {number}
+     * @memberof ActivityLogApiGetLogEntries
+     */
+    readonly limit?: number;
+    /**
+     * Optional. The minimum date. Format &#x3D; ISO.
+     * @type {string}
+     * @memberof ActivityLogApiGetLogEntries
+     */
+    readonly minDate?: string;
+    /**
+     * Optional. Filter log entries if it has user id, or not.
+     * @type {boolean}
+     * @memberof ActivityLogApiGetLogEntries
+     */
+    readonly hasUserId?: boolean;
+}
+/**
+ * ActivityLogApi - object-oriented interface
+ * @export
+ * @class ActivityLogApi
+ * @extends {BaseAPI}
+ */
+export declare class ActivityLogApi extends BaseAPI {
+    /**
+     *
+     * @summary Gets activity log entries.
+     * @param {ActivityLogApiGetLogEntriesRequest} requestParameters Request parameters.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof ActivityLogApi
+     */
+    getLogEntries(requestParameters?: ActivityLogApiGetLogEntriesRequest, options?: any): Promise<import("axios").AxiosResponse<ActivityLogEntryQueryResult, any>>;
+}