c3nav 3.4.6 → 3.5.0

package/dist/api/MapAPI.js

@@ -0,0 +1,173 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MapAPI = void 0;
+const Endpoints_1 = require("../Endpoints");
+const APIBase_1 = require("./APIBase");
+class MapAPI extends APIBase_1.APIBase {
+    constructor(apiClient, options) {
+        super(apiClient, options);
+    }
+    /** /bounds/ returns the maximum bounds of the map */
+    getBounds() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = Endpoints_1.Endpoint.Map.bounds();
+            const { data } = yield this.apiClient.get(endpoint);
+            return data;
+        });
+    }
+    getLegend(themeId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = Endpoints_1.Endpoint.Map.legend(themeId);
+            const { data } = yield this.apiClient.get(endpoint);
+            return data;
+        });
+    }
+    getLoad() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = Endpoints_1.Endpoint.Map.load();
+            const { data } = yield this.apiClient.get(endpoint);
+            return data;
+        });
+    }
+    getLocation(idOrSlug_1) {
+        return __awaiter(this, arguments, void 0, function* (idOrSlug, options = {}) {
+            const params = new URLSearchParams();
+            if (options.geometry !== undefined) {
+                params.set('geometry', String(options.geometry));
+            }
+            if (options.showRedirects !== undefined) {
+                params.set('show_redirects', String(options.showRedirects));
+            }
+            const endpoint = typeof idOrSlug === 'string'
+                ? Endpoints_1.Endpoint.Map.locationBySlug(idOrSlug, options.full)
+                : Endpoints_1.Endpoint.Map.locationById(idOrSlug, options.full);
+            const requestPath = params.size > 0 ? `${endpoint}?${params.toString()}` : endpoint;
+            const { data } = yield this.apiClient.get(requestPath);
+            return data;
+        });
+    }
+    getLocationDisplay(idOrSlug) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = typeof idOrSlug === 'string'
+                ? Endpoints_1.Endpoint.Map.locationDisplayBySlug(idOrSlug)
+                : Endpoints_1.Endpoint.Map.locationDisplayById(idOrSlug);
+            const { data } = yield this.apiClient.get(endpoint);
+            return data;
+        });
+    }
+    getLocationGeometry(idOrSlug) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = typeof idOrSlug === 'string'
+                ? Endpoints_1.Endpoint.Map.locationGeometryBySlug(idOrSlug)
+                : Endpoints_1.Endpoint.Map.locationGeometryById(idOrSlug);
+            const { data } = yield this.apiClient.get(endpoint);
+            return data;
+        });
+    }
+    getLocations() {
+        return __awaiter(this, arguments, void 0, function* (options = {}) {
+            const params = new URLSearchParams();
+            if (options.geometry !== undefined) {
+                params.set('geometry', String(options.geometry));
+            }
+            if (options.searchable !== undefined) {
+                params.set('searchable', String(options.searchable));
+            }
+            const endpoint = Endpoints_1.Endpoint.Map.locations(false);
+            const requestPath = params.size > 0 ? `${endpoint}?${params.toString()}` : endpoint;
+            const { data } = yield this.apiClient.get(requestPath);
+            return data;
+        });
+    }
+    getLocationsFull() {
+        return __awaiter(this, arguments, void 0, function* (options = {}) {
+            const params = new URLSearchParams();
+            if (options.geometry !== undefined) {
+                params.set('geometry', String(options.geometry));
+            }
+            if (options.searchable !== undefined) {
+                params.set('searchable', String(options.searchable));
+            }
+            const endpoint = Endpoints_1.Endpoint.Map.locations(true);
+            const requestPath = params.size > 0 ? `${endpoint}?${params.toString()}` : endpoint;
+            const { data } = yield this.apiClient.get(requestPath);
+            return data;
+        });
+    }
+    getMyPositions() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = Endpoints_1.Endpoint.Map.myPositions();
+            const { data } = yield this.apiClient.get(endpoint);
+            return data;
+        });
+    }
+    getPositionById(positionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = Endpoints_1.Endpoint.Map.position(positionId);
+            const { data } = yield this.apiClient.get(endpoint);
+            return data;
+        });
+    }
+    getProjection() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = Endpoints_1.Endpoint.Map.projection();
+            const { data } = yield this.apiClient.get(endpoint);
+            return data;
+        });
+    }
+    getQuests(questType, level) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const params = new URLSearchParams();
+            if (questType) {
+                params.set('quest_type', questType);
+            }
+            if (level !== undefined) {
+                params.set('level', String(level));
+            }
+            const endpoint = Endpoints_1.Endpoint.Map.quests();
+            const requestPath = params.size > 0 ? `${endpoint}?${params.toString()}` : endpoint;
+            const { data } = yield this.apiClient.get(requestPath);
+            return data;
+        });
+    }
+    getSettings() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = Endpoints_1.Endpoint.Map.settings();
+            const { data } = yield this.apiClient.get(endpoint);
+            return data;
+        });
+    }
+    getWifiData() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = Endpoints_1.Endpoint.Map.wifidata();
+            const { data } = yield this.apiClient.get(endpoint);
+            return data;
+        });
+    }
+    setPosition(positionId, coordinatesId, timeout) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = Endpoints_1.Endpoint.Map.position(positionId);
+            const { data } = yield this.apiClient.put(endpoint, {
+                coordinates_id: coordinatesId,
+                timeout,
+            });
+            return data;
+        });
+    }
+    updateLoad(aps) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = Endpoints_1.Endpoint.Map.load();
+            yield this.apiClient.post(endpoint, { aps });
+        });
+    }
+}
+exports.MapAPI = MapAPI;

package/dist/api/MeshAPI.d.ts

@@ -0,0 +1,10 @@
+import type { APIClient } from '@ffflorian/api-client';
+import type { ClientOptions, MeshFirmware, MeshListResponse, MeshMap, MeshMessage } from '../interfaces';
+import { APIBase } from './APIBase';
+export declare class MeshAPI extends APIBase {
+    constructor(apiClient: APIClient, options: ClientOptions);
+    getFirmwareById(firmwareId: number): Promise<MeshFirmware>;
+    getMap(levelId: number): Promise<MeshMap>;
+    listFirmwares(limit?: number, offset?: number): Promise<MeshListResponse<MeshFirmware>>;
+    listMessages(limit?: number, offset?: number): Promise<MeshListResponse<MeshMessage>>;
+}

package/dist/api/MeshAPI.js

@@ -0,0 +1,64 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MeshAPI = void 0;
+const Endpoints_1 = require("../Endpoints");
+const APIBase_1 = require("./APIBase");
+class MeshAPI extends APIBase_1.APIBase {
+    constructor(apiClient, options) {
+        super(apiClient, options);
+    }
+    getFirmwareById(firmwareId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = Endpoints_1.Endpoint.Mesh.firmwareById(firmwareId);
+            const { data } = yield this.apiClient.get(endpoint);
+            return data;
+        });
+    }
+    getMap(levelId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = Endpoints_1.Endpoint.Mesh.map(levelId);
+            const { data } = yield this.apiClient.get(endpoint);
+            return data;
+        });
+    }
+    listFirmwares(limit, offset) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const params = new URLSearchParams();
+            if (limit !== undefined) {
+                params.set('limit', String(limit));
+            }
+            if (offset !== undefined) {
+                params.set('offset', String(offset));
+            }
+            const endpoint = Endpoints_1.Endpoint.Mesh.firmwares();
+            const requestPath = params.size > 0 ? `${endpoint}?${params.toString()}` : endpoint;
+            const { data } = yield this.apiClient.get(requestPath);
+            return data;
+        });
+    }
+    listMessages(limit, offset) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const params = new URLSearchParams();
+            if (limit !== undefined) {
+                params.set('limit', String(limit));
+            }
+            if (offset !== undefined) {
+                params.set('offset', String(offset));
+            }
+            const endpoint = Endpoints_1.Endpoint.Mesh.messages();
+            const requestPath = params.size > 0 ? `${endpoint}?${params.toString()}` : endpoint;
+            const { data } = yield this.apiClient.get(requestPath);
+            return data;
+        });
+    }
+}
+exports.MeshAPI = MeshAPI;

package/dist/api/ObstaclesAPI.d.ts

@@ -0,0 +1,11 @@
+import type { APIClient } from '@ffflorian/api-client';
+import type { ClientOptions, Obstacles } from '../interfaces/';
+import { APIBase } from './APIBase';
+export declare class ObstaclesAPI extends APIBase {
+    constructor(apiClient: APIClient, options: ClientOptions);
+    /**
+     * @param id The id to get
+     */
+    getById(id: number): Promise<Obstacles>;
+    getList(): Promise<Obstacles[]>;
+}

package/dist/api/ObstaclesAPI.js

@@ -0,0 +1,37 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObstaclesAPI = void 0;
+const Endpoints_1 = require("../Endpoints");
+const APIBase_1 = require("./APIBase");
+class ObstaclesAPI extends APIBase_1.APIBase {
+    constructor(apiClient, options) {
+        super(apiClient, options);
+    }
+    /**
+     * @param id The id to get
+     */
+    getById(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = Endpoints_1.Endpoint.obstacles(id);
+            const { data } = yield this.apiClient.get(endpoint);
+            return data;
+        });
+    }
+    getList() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = Endpoints_1.Endpoint.obstacles();
+            const { data } = yield this.apiClient.get(endpoint);
+            return data;
+        });
+    }
+}
+exports.ObstaclesAPI = ObstaclesAPI;

package/dist/api/POIs.d.ts

@@ -0,0 +1,11 @@
+import type { APIClient } from '@ffflorian/api-client';
+import type { ClientOptions, POIs } from '../interfaces';
+import { APIBase } from './APIBase';
+export declare class PoisAPI extends APIBase {
+    constructor(apiClient: APIClient, options: ClientOptions);
+    /**
+     * @param id The id to get
+     */
+    getById(id: number): Promise<POIs>;
+    getList(): Promise<POIs[]>;
+}

package/dist/api/POIs.js

@@ -0,0 +1,37 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PoisAPI = void 0;
+const Endpoints_1 = require("../Endpoints");
+const APIBase_1 = require("./APIBase");
+class PoisAPI extends APIBase_1.APIBase {
+    constructor(apiClient, options) {
+        super(apiClient, options);
+    }
+    /**
+     * @param id The id to get
+     */
+    getById(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = Endpoints_1.Endpoint.pois(id);
+            const { data } = yield this.apiClient.get(endpoint);
+            return data;
+        });
+    }
+    getList() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = Endpoints_1.Endpoint.pois();
+            const { data } = yield this.apiClient.get(endpoint);
+            return data;
+        });
+    }
+}
+exports.PoisAPI = PoisAPI;

package/dist/api/PositioningAPI.d.ts

@@ -0,0 +1,8 @@
+import type { APIClient } from '@ffflorian/api-client';
+import type { ClientOptions, PositioningLocateRequest, PositioningLocateResponse } from '../interfaces';
+import { APIBase } from './APIBase';
+export declare class PositioningAPI extends APIBase {
+    constructor(apiClient: APIClient, options: ClientOptions);
+    locate(payload: PositioningLocateRequest): Promise<PositioningLocateResponse>;
+    locateTest(): Promise<PositioningLocateResponse>;
+}

package/dist/api/PositioningAPI.js

@@ -0,0 +1,34 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PositioningAPI = void 0;
+const Endpoints_1 = require("../Endpoints");
+const APIBase_1 = require("./APIBase");
+class PositioningAPI extends APIBase_1.APIBase {
+    constructor(apiClient, options) {
+        super(apiClient, options);
+    }
+    locate(payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = Endpoints_1.Endpoint.Positioning.locate();
+            const { data } = yield this.apiClient.post(endpoint, payload);
+            return data;
+        });
+    }
+    locateTest() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = Endpoints_1.Endpoint.Positioning.locateTest();
+            const { data } = yield this.apiClient.get(endpoint);
+            return data;
+        });
+    }
+}
+exports.PositioningAPI = PositioningAPI;

package/dist/api/RampsAPI.d.ts

@@ -0,0 +1,11 @@
+import type { APIClient } from '@ffflorian/api-client';
+import type { ClientOptions, Ramps } from '../interfaces/';
+import { APIBase } from './APIBase';
+export declare class RampsAPI extends APIBase {
+    constructor(apiClient: APIClient, options: ClientOptions);
+    /**
+     * @param id The id to get
+     */
+    getById(id: number): Promise<Ramps>;
+    getList(): Promise<Ramps[]>;
+}

package/dist/api/RampsAPI.js

@@ -0,0 +1,37 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RampsAPI = void 0;
+const Endpoints_1 = require("../Endpoints");
+const APIBase_1 = require("./APIBase");
+class RampsAPI extends APIBase_1.APIBase {
+    constructor(apiClient, options) {
+        super(apiClient, options);
+    }
+    /**
+     * @param id The id to get
+     */
+    getById(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = Endpoints_1.Endpoint.ramps(id);
+            const { data } = yield this.apiClient.get(endpoint);
+            return data;
+        });
+    }
+    getList() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = Endpoints_1.Endpoint.ramps();
+            const { data } = yield this.apiClient.get(endpoint);
+            return data;
+        });
+    }
+}
+exports.RampsAPI = RampsAPI;

package/dist/api/RoutingAPI.d.ts

@@ -0,0 +1,15 @@
+import type { APIClient } from '@ffflorian/api-client';
+import type { ClientOptions, Routing, RoutingOptions, RoutingOptionsFormItem, RoutingRequest } from '../interfaces/';
+import { APIBase } from './APIBase';
+export declare class RoutingAPI extends APIBase {
+    constructor(apiClient: APIClient, options: ClientOptions);
+    /**
+     * @param id The id to get
+     */
+    getById(id: number): Promise<Routing>;
+    getList(): Promise<Routing[]>;
+    getOptions(): Promise<RoutingOptions>;
+    getOptionsForm(): Promise<RoutingOptionsFormItem[]>;
+    postRoute(request: RoutingRequest): Promise<Routing>;
+    setOptions(options: Partial<RoutingOptions>): Promise<RoutingOptions>;
+}

package/dist/api/RoutingAPI.js

@@ -0,0 +1,65 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoutingAPI = void 0;
+const Endpoints_1 = require("../Endpoints");
+const APIBase_1 = require("./APIBase");
+class RoutingAPI extends APIBase_1.APIBase {
+    constructor(apiClient, options) {
+        super(apiClient, options);
+    }
+    /**
+     * @param id The id to get
+     */
+    getById(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = Endpoints_1.Endpoint.routing(id);
+            const { data } = yield this.apiClient.get(endpoint);
+            return data;
+        });
+    }
+    getList() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = Endpoints_1.Endpoint.routing();
+            const { data } = yield this.apiClient.get(endpoint);
+            return data;
+        });
+    }
+    getOptions() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = Endpoints_1.Endpoint.Routing.options();
+            const { data } = yield this.apiClient.get(endpoint);
+            return data;
+        });
+    }
+    getOptionsForm() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = Endpoints_1.Endpoint.Routing.optionsForm();
+            const { data } = yield this.apiClient.get(endpoint);
+            return data;
+        });
+    }
+    postRoute(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = Endpoints_1.Endpoint.Routing.route();
+            const { data } = yield this.apiClient.post(endpoint, request);
+            return data;
+        });
+    }
+    setOptions(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = Endpoints_1.Endpoint.Routing.options();
+            const { data } = yield this.apiClient.put(endpoint, options);
+            return data;
+        });
+    }
+}
+exports.RoutingAPI = RoutingAPI;

package/dist/api/SessionAPI.d.ts

@@ -0,0 +1,10 @@
+import type { APIClient } from '@ffflorian/api-client';
+import type { ClientOptions, Session, SessionKey } from '../interfaces/';
+import { APIBase } from './APIBase';
+export declare class SessionAPI extends APIBase {
+    constructor(apiClient: APIClient, options: ClientOptions);
+    getById(_id: number): Promise<Session>;
+    getList(): Promise<Session[]>;
+    getSessionKey(): Promise<SessionKey>;
+    getStatus(): Promise<Session>;
+}

package/dist/api/SessionAPI.js

@@ -0,0 +1,45 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionAPI = void 0;
+const Endpoints_1 = require("../Endpoints");
+const APIBase_1 = require("./APIBase");
+class SessionAPI extends APIBase_1.APIBase {
+    constructor(apiClient, options) {
+        super(apiClient, options);
+    }
+    getById(_id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getStatus();
+        });
+    }
+    getList() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const status = yield this.getStatus();
+            return [status];
+        });
+    }
+    getSessionKey() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = Endpoints_1.Endpoint.Session.key();
+            const { data } = yield this.apiClient.get(endpoint);
+            return data;
+        });
+    }
+    getStatus() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = Endpoints_1.Endpoint.Session.status();
+            const { data } = yield this.apiClient.get(endpoint);
+            return data;
+        });
+    }
+}
+exports.SessionAPI = SessionAPI;

package/dist/api/SourcesAPI.d.ts

@@ -0,0 +1,11 @@
+import type { APIClient } from '@ffflorian/api-client';
+import type { ClientOptions, Sources } from '../interfaces/';
+import { APIBase } from './APIBase';
+export declare class SourcesAPI extends APIBase {
+    constructor(apiClient: APIClient, options: ClientOptions);
+    /**
+     * @param id The id to get
+     */
+    getById(id: number): Promise<Sources>;
+    getList(): Promise<Sources[]>;
+}

package/dist/api/SourcesAPI.js

@@ -0,0 +1,37 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SourcesAPI = void 0;
+const Endpoints_1 = require("../Endpoints");
+const APIBase_1 = require("./APIBase");
+class SourcesAPI extends APIBase_1.APIBase {
+    constructor(apiClient, options) {
+        super(apiClient, options);
+    }
+    /**
+     * @param id The id to get
+     */
+    getById(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = Endpoints_1.Endpoint.sources(id);
+            const { data } = yield this.apiClient.get(endpoint);
+            return data;
+        });
+    }
+    getList() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = Endpoints_1.Endpoint.sources();
+            const { data } = yield this.apiClient.get(endpoint);
+            return data;
+        });
+    }
+}
+exports.SourcesAPI = SourcesAPI;

package/dist/api/SpacesAPI.d.ts

@@ -0,0 +1,11 @@
+import type { APIClient } from '@ffflorian/api-client';
+import type { ClientOptions, Spaces } from '../interfaces/';
+import { APIBase } from './APIBase';
+export declare class SpacesAPI extends APIBase {
+    constructor(apiClient: APIClient, options: ClientOptions);
+    /**
+     * @param id The id to get
+     */
+    getById(id: number): Promise<Spaces>;
+    getList(): Promise<Spaces[]>;
+}