c3nav 3.4.7 → 3.5.0

package/dist/api/MapAPI.js

@@ -24,5 +24,150 @@ class MapAPI extends APIBase_1.APIBase {
             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/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/RoutingAPI.d.ts

@@ -1,5 +1,5 @@
 import type { APIClient } from '@ffflorian/api-client';
-import type { ClientOptions, Routing } from '../interfaces/';
+import type { ClientOptions, Routing, RoutingOptions, RoutingOptionsFormItem, RoutingRequest } from '../interfaces/';
 import { APIBase } from './APIBase';
 export declare class RoutingAPI extends APIBase {
     constructor(apiClient: APIClient, options: ClientOptions);
@@ -8,4 +8,8 @@ export declare class RoutingAPI extends APIBase {
      */
     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

@@ -33,5 +33,33 @@ class RoutingAPI extends APIBase_1.APIBase {
             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

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

package/dist/api/SessionAPI.js

@@ -16,19 +16,27 @@ class SessionAPI extends APIBase_1.APIBase {
     constructor(apiClient, options) {
         super(apiClient, options);
     }
-    /**
-     * @param id The id to get
-     */
-    getById(id) {
+    getById(_id) {
         return __awaiter(this, void 0, void 0, function* () {
-            const endpoint = Endpoints_1.Endpoint.session(id);
+            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;
         });
     }
-    getList() {
+    getStatus() {
         return __awaiter(this, void 0, void 0, function* () {
-            const endpoint = Endpoints_1.Endpoint.session();
+            const endpoint = Endpoints_1.Endpoint.Session.status();
             const { data } = yield this.apiClient.get(endpoint);
             return data;
         });

package/dist/api/UpdatesAPI.d.ts

@@ -3,9 +3,7 @@ import type { ClientOptions, Updates } from '../interfaces/';
 import { APIBase } from './APIBase';
 export declare class UpdatesAPI extends APIBase {
     constructor(apiClient: APIClient, options: ClientOptions);
-    /**
-     * @param id The id to get
-     */
-    getById(id: number): Promise<Updates>;
+    fetchUpdates(): Promise<Updates>;
+    getById(_id: number): Promise<Updates>;
     getList(): Promise<Updates[]>;
 }

package/dist/api/UpdatesAPI.js

@@ -16,21 +16,22 @@ class UpdatesAPI extends APIBase_1.APIBase {
     constructor(apiClient, options) {
         super(apiClient, options);
     }
-    /**
-     * @param id The id to get
-     */
-    getById(id) {
+    fetchUpdates() {
         return __awaiter(this, void 0, void 0, function* () {
-            const endpoint = Endpoints_1.Endpoint.updates(id);
+            const endpoint = Endpoints_1.Endpoint.Updates.fetch();
             const { data } = yield this.apiClient.get(endpoint);
             return data;
         });
     }
+    getById(_id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.fetchUpdates();
+        });
+    }
     getList() {
         return __awaiter(this, void 0, void 0, function* () {
-            const endpoint = Endpoints_1.Endpoint.updates();
-            const { data } = yield this.apiClient.get(endpoint);
-            return data;
+            const updates = yield this.fetchUpdates();
+            return [updates];
         });
     }
 }

package/dist/api/index.d.ts

@@ -15,8 +15,10 @@ export * from './LocationGroupCategoriesAPI';
 export * from './LocationGroupsAPI';
 export * from './LocationsAPI';
 export * from './MapAPI';
+export * from './MeshAPI';
 export * from './ObstaclesAPI';
 export * from './POIs';
+export * from './PositioningAPI';
 export * from './RampsAPI';
 export * from './RoutingAPI';
 export * from './SessionAPI';

package/dist/api/index.js

@@ -31,8 +31,10 @@ __exportStar(require("./LocationGroupCategoriesAPI"), exports);
 __exportStar(require("./LocationGroupsAPI"), exports);
 __exportStar(require("./LocationsAPI"), exports);
 __exportStar(require("./MapAPI"), exports);
+__exportStar(require("./MeshAPI"), exports);
 __exportStar(require("./ObstaclesAPI"), exports);
 __exportStar(require("./POIs"), exports);
+__exportStar(require("./PositioningAPI"), exports);
 __exportStar(require("./RampsAPI"), exports);
 __exportStar(require("./RoutingAPI"), exports);
 __exportStar(require("./SessionAPI"), exports);

package/dist/c3nav.d.ts

@@ -1,5 +1,5 @@
 import type { API, ClientOptions } from './interfaces';
-export declare class LibrariesIO {
+export declare class c3nav {
     readonly api: API;
     private readonly apiClient;
     constructor(apiUrl: string);
@@ -10,3 +10,5 @@ export declare class LibrariesIO {
      */
     setApiUrl(newURL: string): void;
 }
+export declare class LibrariesIO extends c3nav {
+}

package/dist/c3nav.js

@@ -1,14 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LibrariesIO = void 0;
+exports.LibrariesIO = exports.c3nav = void 0;
 const api_client_1 = require("@ffflorian/api-client");
 const api_1 = require("./api");
-class LibrariesIO {
+class c3nav {
     constructor(options) {
         if (typeof options === 'string') {
             options = { apiUrl: options };
         }
-        this.apiClient = new api_client_1.APIClient('https://c3nav.de/api/');
+        this.apiClient = new api_client_1.APIClient(options.apiUrl || 'https://c3nav.de');
         this.api = {
             accessRestrictionGroups: new api_1.AccessRestrictionGroupsAPI(this.apiClient, options),
             accessRestrictions: new api_1.AccessRestrictionsAPI(this.apiClient, options),
@@ -27,8 +27,10 @@ class LibrariesIO {
             locationGroups: new api_1.LocationGroupsAPI(this.apiClient, options),
             locations: new api_1.LocationsAPI(this.apiClient, options),
             map: new api_1.MapAPI(this.apiClient, options),
+            mesh: new api_1.MeshAPI(this.apiClient, options),
             obstacles: new api_1.ObstaclesAPI(this.apiClient, options),
             pois: new api_1.PoisAPI(this.apiClient, options),
+            positioning: new api_1.PositioningAPI(this.apiClient, options),
             ramps: new api_1.RampsAPI(this.apiClient, options),
             routing: new api_1.RoutingAPI(this.apiClient, options),
             session: new api_1.SessionAPI(this.apiClient, options),
@@ -46,4 +48,7 @@ class LibrariesIO {
         this.apiClient.setBaseURL(newURL);
     }
 }
+exports.c3nav = c3nav;
+class LibrariesIO extends c3nav {
+}
 exports.LibrariesIO = LibrariesIO;

package/dist/interfaces/API.d.ts

@@ -1,4 +1,4 @@
-import type { AccessRestrictionGroupsAPI, AccessRestrictionsAPI, AreasAPI, BuildingsAPI, ChangesetsAPI, ColumnsAPI, CrossDescriptionsAPI, DoorsAPI, EditorAPI, HolesAPI, LeaveDescriptionsAPI, LevelListAPI, LineObstaclesAPI, LocationGroupCategoriesAPI, LocationGroupsAPI, LocationsAPI, MapAPI, ObstaclesAPI, PoisAPI, RampsAPI, RoutingAPI, SessionAPI, SourcesAPI, SpacesAPI, StairsAPI, UpdatesAPI } from '../api/';
+import type { AccessRestrictionGroupsAPI, AccessRestrictionsAPI, AreasAPI, BuildingsAPI, ChangesetsAPI, ColumnsAPI, CrossDescriptionsAPI, DoorsAPI, EditorAPI, HolesAPI, LeaveDescriptionsAPI, LevelListAPI, LineObstaclesAPI, LocationGroupCategoriesAPI, LocationGroupsAPI, LocationsAPI, MapAPI, MeshAPI, ObstaclesAPI, PoisAPI, PositioningAPI, RampsAPI, RoutingAPI, SessionAPI, SourcesAPI, SpacesAPI, StairsAPI, UpdatesAPI } from '../api/';
 export interface API {
     accessRestrictionGroups: AccessRestrictionGroupsAPI;
     accessRestrictions: AccessRestrictionsAPI;
@@ -17,8 +17,10 @@ export interface API {
     locationGroups: LocationGroupsAPI;
     locations: LocationsAPI;
     map: MapAPI;
+    mesh: MeshAPI;
     obstacles: ObstaclesAPI;
     pois: PoisAPI;
+    positioning: PositioningAPI;
     ramps: RampsAPI;
     routing: RoutingAPI;
     session: SessionAPI;

package/dist/interfaces/Editor.d.ts

@@ -1,2 +1,9 @@
-export interface Editor {
+import type { Bounds } from './Bounds';
+export interface Editor extends Bounds {
 }
+export interface EditorBeaconsLookup {
+    ibeacons: Record<string, unknown>;
+    wifi_beacons: Record<string, unknown>;
+}
+export type EditorGeometries = Array<[string, string] | Record<string, unknown>>;
+export type GeometryStyles = Record<string, string>;

package/dist/interfaces/Map.d.ts

@@ -0,0 +1,54 @@
+import type { Location, LocationDetails, LocationGeometry } from './Location';
+export interface MapLegend {
+    base: MapLegendItem[];
+    groups: MapLegendItem[];
+    obstacles: MapLegendItem[];
+}
+export interface MapLegendItem {
+    border: string;
+    fill: string;
+    title: string;
+}
+export type MapLocation = Location;
+export type MapLocationDisplay = LocationDetails;
+export type MapLocationGeometry = LocationGeometry;
+export interface MapLocationOptions extends MapLocationQueryOptions {
+    full?: boolean;
+    showRedirects?: boolean;
+}
+export interface MapLocationQueryOptions {
+    geometry?: boolean;
+    searchable?: boolean;
+}
+export interface MapSettings {
+    grid?: null | Record<string, unknown>;
+    initial_bounds: Array<[number, number]> | null;
+    initial_level: null | number;
+    tile_server?: null | string;
+}
+export interface Position {
+    available: boolean;
+    effective_slug: string;
+    icon: null | string;
+    id: number | string;
+    short_name: string;
+    slug: string;
+    subtitle: string;
+    title: string;
+}
+export interface Projection {
+    pipeline?: null | string;
+    proj4: string;
+    rotation: number;
+    rotation_matrix?: null | number[];
+    zero_point: [number, number];
+}
+export interface Quest {
+    identifier: string;
+    level_id: number;
+    point: {
+        coordinates: [number, number];
+        type: 'Point';
+    };
+    quest_type: string;
+}

package/dist/interfaces/Map.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/interfaces/Mesh.d.ts

@@ -0,0 +1,24 @@
+export interface MeshFirmware {
+    builds: Array<Record<string, unknown>>;
+    created: string;
+    id: number;
+    idf_version: string;
+    project_name: string;
+    version: string;
+}
+export interface MeshListResponse<T> {
+    count: number;
+    items: T[];
+}
+export interface MeshMap {
+    connections: Array<Record<string, unknown>>;
+    ranges: Array<Record<string, unknown>>;
+    ranging_beacons: Array<Record<string, unknown>>;
+}
+export interface MeshMessage {
+    data: Record<string, unknown>;
+    datetime: string;
+    id: number;
+    message_type: string;
+    src_node: string;
+}

package/dist/interfaces/Mesh.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/interfaces/Positioning.d.ts

@@ -0,0 +1,13 @@
+export interface PositioningLocateRequest {
+    ibeacon_peers: Array<Record<string, unknown>>;
+    wifi_peers: Array<Record<string, unknown>>;
+}
+export interface PositioningLocateResponse {
+    location: null | Record<string, unknown>;
+    precision: null | number;
+    suggested_peers: PositioningPeerSuggestion[];
+}
+export interface PositioningPeerSuggestion {
+    bssid: string;
+    frequencies: number[];
+}

package/dist/interfaces/Positioning.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });