c3nav 3.4.6 → 3.5.0

package/dist/api/ColumnsAPI.d.ts

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

package/dist/api/ColumnsAPI.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.ColumnsAPI = void 0;
+const Endpoints_1 = require("../Endpoints");
+const APIBase_1 = require("./APIBase");
+class ColumnsAPI 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.columns(id);
+            const { data } = yield this.apiClient.get(endpoint);
+            return data;
+        });
+    }
+    getList() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = Endpoints_1.Endpoint.columns();
+            const { data } = yield this.apiClient.get(endpoint);
+            return data;
+        });
+    }
+}
+exports.ColumnsAPI = ColumnsAPI;

package/dist/api/CrossDescriptionsAPI.d.ts

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

package/dist/api/CrossDescriptionsAPI.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.CrossDescriptionsAPI = void 0;
+const Endpoints_1 = require("../Endpoints");
+const APIBase_1 = require("./APIBase");
+class CrossDescriptionsAPI 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.crossDescriptions(id);
+            const { data } = yield this.apiClient.get(endpoint);
+            return data;
+        });
+    }
+    getList() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = Endpoints_1.Endpoint.crossDescriptions();
+            const { data } = yield this.apiClient.get(endpoint);
+            return data;
+        });
+    }
+}
+exports.CrossDescriptionsAPI = CrossDescriptionsAPI;

package/dist/api/DoorsAPI.d.ts

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

package/dist/api/DoorsAPI.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.DoorsAPI = void 0;
+const Endpoints_1 = require("../Endpoints");
+const APIBase_1 = require("./APIBase");
+class DoorsAPI 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.doors(id);
+            const { data } = yield this.apiClient.get(endpoint);
+            return data;
+        });
+    }
+    getList() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = Endpoints_1.Endpoint.doors();
+            const { data } = yield this.apiClient.get(endpoint);
+            return data;
+        });
+    }
+}
+exports.DoorsAPI = DoorsAPI;

package/dist/api/EditorAPI.d.ts

@@ -0,0 +1,13 @@
+import type { APIClient } from '@ffflorian/api-client';
+import type { ClientOptions, Editor, EditorBeaconsLookup, EditorGeometries, GeometryStyles } from '../interfaces/';
+import { APIBase } from './APIBase';
+export declare class EditorAPI extends APIBase {
+    constructor(apiClient: APIClient, options: ClientOptions);
+    getBeaconsLookup(): Promise<EditorBeaconsLookup>;
+    getBounds(): Promise<Editor>;
+    getById(_id: number): Promise<Editor>;
+    getGeometryStyles(): Promise<GeometryStyles>;
+    getLevelGeometries(levelId: number | string, updateCacheKey?: string): Promise<EditorGeometries>;
+    getList(): Promise<Editor[]>;
+    getSpaceGeometries(spaceId: number | string, updateCacheKey?: string): Promise<EditorGeometries>;
+}

package/dist/api/EditorAPI.js

@@ -0,0 +1,72 @@
+"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.EditorAPI = void 0;
+const Endpoints_1 = require("../Endpoints");
+const APIBase_1 = require("./APIBase");
+class EditorAPI extends APIBase_1.APIBase {
+    constructor(apiClient, options) {
+        super(apiClient, options);
+    }
+    getBeaconsLookup() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = Endpoints_1.Endpoint.Editor.beaconsLookup();
+            const { data } = yield this.apiClient.get(endpoint);
+            return data;
+        });
+    }
+    getBounds() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = Endpoints_1.Endpoint.Editor.bounds();
+            const { data } = yield this.apiClient.get(endpoint);
+            return data;
+        });
+    }
+    getById(_id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getBounds();
+        });
+    }
+    getGeometryStyles() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = Endpoints_1.Endpoint.Editor.geometryStyles();
+            const { data } = yield this.apiClient.get(endpoint);
+            return data;
+        });
+    }
+    getLevelGeometries(levelId, updateCacheKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = Endpoints_1.Endpoint.Editor.levelGeometries(levelId);
+            const requestPath = updateCacheKey
+                ? `${endpoint}?update_cache_key=${encodeURIComponent(updateCacheKey)}`
+                : endpoint;
+            const { data } = yield this.apiClient.get(requestPath);
+            return data;
+        });
+    }
+    getList() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const bounds = yield this.getBounds();
+            return [bounds];
+        });
+    }
+    getSpaceGeometries(spaceId, updateCacheKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = Endpoints_1.Endpoint.Editor.spaceGeometries(spaceId);
+            const requestPath = updateCacheKey
+                ? `${endpoint}?update_cache_key=${encodeURIComponent(updateCacheKey)}`
+                : endpoint;
+            const { data } = yield this.apiClient.get(requestPath);
+            return data;
+        });
+    }
+}
+exports.EditorAPI = EditorAPI;

package/dist/api/HolesAPI.d.ts

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

package/dist/api/HolesAPI.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.HolesAPI = void 0;
+const Endpoints_1 = require("../Endpoints");
+const APIBase_1 = require("./APIBase");
+class HolesAPI 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.holes(id);
+            const { data } = yield this.apiClient.get(endpoint);
+            return data;
+        });
+    }
+    getList() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = Endpoints_1.Endpoint.holes();
+            const { data } = yield this.apiClient.get(endpoint);
+            return data;
+        });
+    }
+}
+exports.HolesAPI = HolesAPI;

package/dist/api/LeaveDescriptionsAPI.d.ts

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

package/dist/api/LeaveDescriptionsAPI.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.LeaveDescriptionsAPI = void 0;
+const Endpoints_1 = require("../Endpoints");
+const APIBase_1 = require("./APIBase");
+class LeaveDescriptionsAPI 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.leaveDescriptions(id);
+            const { data } = yield this.apiClient.get(endpoint);
+            return data;
+        });
+    }
+    getList() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = Endpoints_1.Endpoint.leaveDescriptions();
+            const { data } = yield this.apiClient.get(endpoint);
+            return data;
+        });
+    }
+}
+exports.LeaveDescriptionsAPI = LeaveDescriptionsAPI;

package/dist/api/LevelListAPI.d.ts

@@ -0,0 +1,11 @@
+import type { APIClient } from '@ffflorian/api-client';
+import type { ClientOptions, Level, LevelListOptions } from '../interfaces';
+import { APIBase } from './APIBase';
+/**
+ * A Level is a Location – so if it is visible, you can use its ID in the Location API as well.
+ */
+export declare class LevelListAPI extends APIBase {
+    constructor(apiClient: APIClient, options: ClientOptions);
+    getDetail(id: number, options?: LevelListOptions): Promise<Level>;
+    getList(options?: LevelListOptions): Promise<Level[]>;
+}

package/dist/api/LevelListAPI.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.LevelListAPI = void 0;
+const Endpoints_1 = require("../Endpoints");
+const APIBase_1 = require("./APIBase");
+/**
+ * A Level is a Location – so if it is visible, you can use its ID in the Location API as well.
+ */
+class LevelListAPI extends APIBase_1.APIBase {
+    constructor(apiClient, options) {
+        super(apiClient, options);
+    }
+    getDetail(id, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = Endpoints_1.Endpoint.Level.levels(id);
+            const { data } = yield this.apiClient.get(endpoint, { data: options });
+            return data;
+        });
+    }
+    getList(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = Endpoints_1.Endpoint.Level.levels();
+            const { data } = yield this.apiClient.get(endpoint, { data: options });
+            return data;
+        });
+    }
+}
+exports.LevelListAPI = LevelListAPI;

package/dist/api/LineObstaclesAPI.d.ts

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

package/dist/api/LineObstaclesAPI.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.LineObstaclesAPI = void 0;
+const Endpoints_1 = require("../Endpoints");
+const APIBase_1 = require("./APIBase");
+class LineObstaclesAPI 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.lineObstacles(id);
+            const { data } = yield this.apiClient.get(endpoint);
+            return data;
+        });
+    }
+    getList() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = Endpoints_1.Endpoint.lineObstacles();
+            const { data } = yield this.apiClient.get(endpoint);
+            return data;
+        });
+    }
+}
+exports.LineObstaclesAPI = LineObstaclesAPI;

package/dist/api/LocationGroupCategoriesAPI.d.ts

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

package/dist/api/LocationGroupCategoriesAPI.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.LocationGroupCategoriesAPI = void 0;
+const Endpoints_1 = require("../Endpoints");
+const APIBase_1 = require("./APIBase");
+class LocationGroupCategoriesAPI 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.locationGroupCategories(id);
+            const { data } = yield this.apiClient.get(endpoint);
+            return data;
+        });
+    }
+    getList() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = Endpoints_1.Endpoint.locationGroupCategories();
+            const { data } = yield this.apiClient.get(endpoint);
+            return data;
+        });
+    }
+}
+exports.LocationGroupCategoriesAPI = LocationGroupCategoriesAPI;

package/dist/api/LocationGroupsAPI.d.ts

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

package/dist/api/LocationGroupsAPI.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.LocationGroupsAPI = void 0;
+const Endpoints_1 = require("../Endpoints");
+const APIBase_1 = require("./APIBase");
+class LocationGroupsAPI 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.locationGroups(id);
+            const { data } = yield this.apiClient.get(endpoint);
+            return data;
+        });
+    }
+    getList() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = Endpoints_1.Endpoint.locationGroups();
+            const { data } = yield this.apiClient.get(endpoint);
+            return data;
+        });
+    }
+}
+exports.LocationGroupsAPI = LocationGroupsAPI;

package/dist/api/LocationsAPI.d.ts

@@ -0,0 +1,23 @@
+import type { APIClient } from '@ffflorian/api-client';
+import type { ClientOptions, Location, LocationDetails, LocationGeometry, LocationType } from '../interfaces/';
+import { APIBase } from './APIBase';
+/**
+ * Locations are Levels, Spaces, Areas, POIs and Location Groups (see `/locations/types/`). They have a shared ID pool.
+ *
+ * This API endpoint only accesses locations that have `can_search` or `can_describe` set to `true`.
+ *
+ * If you want to access all of them, use the API endpoints for the Location Types.
+ *
+ * Additionally, you can access Custom Locations (Coordinates) by using `c:<level.short_label>:x:y` as an id or slug.
+ */
+export declare class LocationsAPI extends APIBase {
+    constructor(apiClient: APIClient, options: ClientOptions);
+    getDetails(id: number): Promise<LocationDetails>;
+    getDetails(slug: string): Promise<LocationDetails>;
+    getGeometry(id: number): Promise<LocationGeometry>;
+    getGeometry(slug: string): Promise<LocationGeometry>;
+    getList(geometry?: boolean): Promise<Location[]>;
+    getLocation(id: number): Promise<Location>;
+    getLocation(slug: string): Promise<Location>;
+    getTypes(): Promise<LocationType[]>;
+}

package/dist/api/LocationsAPI.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.LocationsAPI = void 0;
+const Endpoints_1 = require("../Endpoints");
+const APIBase_1 = require("./APIBase");
+/**
+ * Locations are Levels, Spaces, Areas, POIs and Location Groups (see `/locations/types/`). They have a shared ID pool.
+ *
+ * This API endpoint only accesses locations that have `can_search` or `can_describe` set to `true`.
+ *
+ * If you want to access all of them, use the API endpoints for the Location Types.
+ *
+ * Additionally, you can access Custom Locations (Coordinates) by using `c:<level.short_label>:x:y` as an id or slug.
+ */
+class LocationsAPI extends APIBase_1.APIBase {
+    constructor(apiClient, options) {
+        super(apiClient, options);
+    }
+    getDetails(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = Endpoints_1.Endpoint.Location.details(id);
+            const { data } = yield this.apiClient.get(endpoint);
+            return data;
+        });
+    }
+    getGeometry(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = Endpoints_1.Endpoint.Location.geometry(id);
+            const { data } = yield this.apiClient.get(endpoint);
+            return data;
+        });
+    }
+    getList(geometry) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = Endpoints_1.Endpoint.Location.locations();
+            const requestPath = geometry === undefined ? endpoint : `${endpoint}?geometry=${String(geometry)}`;
+            const { data } = yield this.apiClient.get(requestPath);
+            return data;
+        });
+    }
+    getLocation(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = Endpoints_1.Endpoint.Location.detail(id);
+            const { data } = yield this.apiClient.get(endpoint);
+            return data;
+        });
+    }
+    getTypes() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = Endpoints_1.Endpoint.Location.types();
+            const { data } = yield this.apiClient.get(endpoint);
+            return data;
+        });
+    }
+}
+exports.LocationsAPI = LocationsAPI;

package/dist/api/MapAPI.d.ts

@@ -0,0 +1,23 @@
+import type { APIClient } from '@ffflorian/api-client';
+import type { Bounds, ClientOptions, MapLegend, MapLocation, MapLocationDisplay, MapLocationGeometry, MapLocationOptions, MapLocationQueryOptions, MapSettings, Position, Projection, Quest } from '../interfaces/';
+import { APIBase } from './APIBase';
+export declare class MapAPI extends APIBase {
+    constructor(apiClient: APIClient, options: ClientOptions);
+    /** /bounds/ returns the maximum bounds of the map */
+    getBounds(): Promise<Bounds>;
+    getLegend(themeId: number | string): Promise<MapLegend>;
+    getLoad(): Promise<Record<string, number>>;
+    getLocation(idOrSlug: number | string, options?: MapLocationOptions): Promise<MapLocation>;
+    getLocationDisplay(idOrSlug: number | string): Promise<MapLocationDisplay>;
+    getLocationGeometry(idOrSlug: number | string): Promise<MapLocationGeometry>;
+    getLocations(options?: MapLocationQueryOptions): Promise<MapLocation[]>;
+    getLocationsFull(options?: MapLocationQueryOptions): Promise<MapLocation[]>;
+    getMyPositions(): Promise<Position[]>;
+    getPositionById(positionId: number | string): Promise<Position>;
+    getProjection(): Promise<Projection>;
+    getQuests(questType?: string, level?: number): Promise<Quest[]>;
+    getSettings(): Promise<MapSettings>;
+    getWifiData(): Promise<Record<string, unknown>>;
+    setPosition(positionId: number | string, coordinatesId: null | string, timeout?: null | number): Promise<Position>;
+    updateLoad(aps: Record<string, number>): Promise<void>;
+}