proximiio-js-library 1.2.0

package/lib/controllers/repository.js

@@ -0,0 +1,68 @@
+"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());
+    });
+};
+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.getPackage = void 0;
+var places_1 = require("./places");
+var floors_1 = require("./floors");
+var style_1 = require("./style");
+var geo_1 = require("./geo");
+var getPackage = function (initPolygons) { return __awaiter(void 0, void 0, void 0, function () {
+    var result, promises;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                result = {};
+                promises = [
+                    places_1.getPlaces().then(function (places) { return (result.places = places.data); }),
+                    floors_1.getFloors().then(function (floors) { return (result.floors = floors.data); }),
+                    style_1.getStyle().then(function (style) { return (result.style = style); }),
+                    style_1.getStyles().then(function (styles) { return (result.styles = styles); }),
+                    geo_1.getFeatures(initPolygons).then(function (features) { return (result.features = features); }),
+                    geo_1.getAmenities().then(function (amenities) { return (result.amenities = amenities); }),
+                ];
+                return [4 /*yield*/, Promise.all(promises)];
+            case 1:
+                _a.sent();
+                return [2 /*return*/, result];
+        }
+    });
+}); };
+exports.getPackage = getPackage;
+exports.default = {
+    getPackage: exports.getPackage,
+};

package/lib/controllers/style.d.ts

@@ -0,0 +1,4 @@
+import StyleModel from '../models/style';
+export declare const getStyle: (id?: string) => Promise<StyleModel>;
+export declare const getStyles: () => Promise<any>;
+export declare const getStyleUrl: () => string;

package/lib/controllers/style.js

@@ -0,0 +1,76 @@
+"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());
+    });
+};
+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.getStyleUrl = exports.getStyles = exports.getStyle = void 0;
+var common_1 = require("../common");
+var style_1 = require("../models/style");
+var getStyle = function (id) { return __awaiter(void 0, void 0, void 0, function () {
+    var url, res;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                url = '/v5/geo/style';
+                if (id) {
+                    url += "s/" + id;
+                }
+                return [4 /*yield*/, common_1.axios.get(url)];
+            case 1:
+                res = _a.sent();
+                return [2 /*return*/, new style_1.default(res.data)];
+        }
+    });
+}); };
+exports.getStyle = getStyle;
+var getStyles = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var url, res;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                url = '/v5/geo/styles';
+                return [4 /*yield*/, common_1.axios.get(url)];
+            case 1:
+                res = _a.sent();
+                return [2 /*return*/, res.data.map(function (item) { return new style_1.default(item); })];
+        }
+    });
+}); };
+exports.getStyles = getStyles;
+var getStyleUrl = function () {
+    return "https://api.proximi.fi/v5/geo/style?token=" + common_1.axios.defaults.headers.common.Authorization;
+};
+exports.getStyleUrl = getStyleUrl;

package/lib/eventable.d.ts

@@ -0,0 +1,7 @@
+export declare type Observer = (event?: string, data?: any, eventable?: Eventable) => any;
+export declare class Eventable {
+    _observers?: Observer[];
+    on(observer: Observer): void;
+    off(observer: Observer): void;
+    notify(event?: string, data?: any): void;
+}

package/lib/eventable.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Eventable = void 0;
+var Eventable = /** @class */ (function () {
+    function Eventable() {
+        this._observers = [];
+    }
+    Eventable.prototype.on = function (observer) {
+        if (this._observers) {
+            this._observers.push(observer);
+        }
+    };
+    Eventable.prototype.off = function (observer) {
+        var index = this._observers ? this._observers.findIndex(function (o) { return o === observer; }) : 0;
+        if (index >= 0) {
+            if (this._observers) {
+                this._observers.splice(index, 1);
+            }
+        }
+    };
+    Eventable.prototype.notify = function (event, data) {
+        var _this = this;
+        if (this._observers) {
+            this._observers.forEach(function (observer) { return observer(event, data, _this); });
+        }
+    };
+    return Eventable;
+}());
+exports.Eventable = Eventable;

package/lib/index.d.ts

@@ -0,0 +1,26 @@
+import { Map } from './components/map/main';
+import { Select } from './components/select/main';
+declare const _default: {
+    Auth: {
+        login: (email: string, password: string) => Promise<import("axios").AxiosResponse<any>>;
+        loginWithToken: (token: string) => Promise<import("axios").AxiosResponse<any>>;
+        getUserConfig: () => Promise<any>;
+    };
+    Places: {
+        getPlaces: (limit?: number, skip?: number, order?: string, dir?: string, filterByIndex?: string, q?: string, filter?: string) => Promise<{
+            data: import("./models/place").PlaceModel[];
+            total: number;
+        }>;
+        getPlaceById: (placeId: string) => Promise<import("./models/place").PlaceModel>;
+    };
+    Floors: {
+        getFloors: (limit?: number, skip?: number, order?: string, dir?: string, filterByIndex?: string, q?: string) => Promise<{
+            data: import("./models/floor").FloorModel[];
+            total: number;
+        }>;
+        getPlaceFloors: (placeId: string) => Promise<import("./models/floor").FloorModel[]>;
+    };
+    Map: typeof Map;
+    Select: typeof Select;
+};
+export default _default;

package/lib/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var auth_1 = require("./controllers/auth");
+var places_1 = require("./controllers/places");
+var floors_1 = require("./controllers/floors");
+var main_1 = require("./components/map/main");
+var main_2 = require("./components/select/main");
+exports.default = {
+    Auth: auth_1.default,
+    Places: places_1.default,
+    Floors: floors_1.default,
+    Map: main_1.Map,
+    Select: main_2.Select,
+};

package/lib/models/amenity.d.ts

@@ -0,0 +1,11 @@
+import BaseModel from './base';
+export declare class AmenityModel extends BaseModel {
+    category: string;
+    iconOffset: [number, number];
+    list: boolean;
+    title: string;
+    description: string;
+    icon: string;
+    constructor(data: any);
+    get hasIcon(): boolean;
+}

package/lib/models/amenity.js

@@ -0,0 +1,41 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AmenityModel = void 0;
+var base_1 = require("./base");
+var AmenityModel = /** @class */ (function (_super) {
+    __extends(AmenityModel, _super);
+    function AmenityModel(data) {
+        var _this = _super.call(this, data) || this;
+        _this.category = data.category;
+        _this.iconOffset = data.iconOffset;
+        _this.list = data.list;
+        _this.title = data.title;
+        _this.description = data.description;
+        _this.icon = data.icon;
+        return _this;
+    }
+    Object.defineProperty(AmenityModel.prototype, "hasIcon", {
+        get: function () {
+            return !!this.icon;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return AmenityModel;
+}(base_1.default));
+exports.AmenityModel = AmenityModel;

package/lib/models/auth-data.d.ts

@@ -0,0 +1,4 @@
+export interface LoginDataModel {
+    email: string;
+    password: string;
+}

package/lib/models/auth-data.js

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

package/lib/models/base.d.ts

@@ -0,0 +1,7 @@
+export default class BaseModel {
+    id: string;
+    createdAt?: string;
+    updatedAt?: string;
+    constructor(data: any);
+    get exists(): boolean;
+}

package/lib/models/base.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var BaseModel = /** @class */ (function () {
+    function BaseModel(data) {
+        this.id = data.id || (data.properties ? data.properties.id : undefined);
+        this.createdAt = data.createdAt;
+        this.updatedAt = data.updatedAt;
+    }
+    Object.defineProperty(BaseModel.prototype, "exists", {
+        get: function () {
+            return typeof this.id !== 'undefined';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return BaseModel;
+}());
+exports.default = BaseModel;

package/lib/models/feature.d.ts

@@ -0,0 +1,46 @@
+import BaseModel from './base';
+export declare class Geometry {
+    type: string;
+    coordinates: any[];
+    constructor(data: any);
+}
+export declare class FeatureCollection {
+    type: string;
+    features: Feature[];
+    constructor(data: any);
+    get json(): {
+        type: string;
+        features: any[];
+    };
+}
+export default class Feature extends BaseModel {
+    type: 'Feature';
+    id: string;
+    geometry: Geometry;
+    properties: any;
+    constructor(data: any);
+    get isEditable(): boolean;
+    get isPoint(): boolean;
+    get isPolygon(): boolean;
+    get isLineString(): boolean;
+    get isHazard(): boolean;
+    get isLandmark(): boolean;
+    get isDoor(): boolean;
+    get isEntrance(): boolean;
+    get isDecisionPoint(): boolean;
+    get isTicketGate(): boolean;
+    get isElevator(): boolean;
+    get isEscalator(): boolean;
+    get isStairCase(): boolean;
+    get isLevelChanger(): boolean;
+    get isText(): boolean;
+    get isSynthetic(): boolean;
+    get isRoom(): any;
+    get isRouting(): boolean;
+    get getTitle(): any;
+    get getTitleWithLevel(): string;
+    get json(): any;
+    static point(id: string, latitude: number, longitude: number, properties?: any): Feature;
+    setTitle(title: string, lang?: string): void;
+    hasLevel(level: number): any;
+}

package/lib/models/feature.js

@@ -0,0 +1,277 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeatureCollection = exports.Geometry = void 0;
+var base_1 = require("./base");
+var poi_type_1 = require("./poi_type");
+var Geometry = /** @class */ (function () {
+    function Geometry(data) {
+        this.type = data.type;
+        this.coordinates = data.coordinates;
+    }
+    return Geometry;
+}());
+exports.Geometry = Geometry;
+var FeatureCollection = /** @class */ (function () {
+    function FeatureCollection(data) {
+        this.type = 'FeatureCollection';
+        this.features = (data.features || []).map(function (f) { return new Feature(f).json; });
+    }
+    Object.defineProperty(FeatureCollection.prototype, "json", {
+        get: function () {
+            return {
+                type: 'FeatureCollection',
+                features: this.features.map(function (feature) { return feature.json; }),
+            };
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return FeatureCollection;
+}());
+exports.FeatureCollection = FeatureCollection;
+var Feature = /** @class */ (function (_super) {
+    __extends(Feature, _super);
+    function Feature(data) {
+        var _this = _super.call(this, data) || this;
+        _this.type = 'Feature';
+        _this.id = data.id;
+        _this.geometry = new Geometry(data.geometry);
+        _this.properties = data.properties || {};
+        if (typeof _this.properties.title_i18n === 'string') {
+            _this.properties.title_i18n = JSON.parse(_this.properties.title_i18n);
+        }
+        if (_this.isPoint) {
+            if (!_this.properties.images) {
+                _this.properties.images = [];
+            }
+            if (!_this.properties.range) {
+                _this.properties.range = 3;
+            }
+        }
+        if (typeof _this.properties.images === 'string') {
+            _this.properties.images = JSON.parse(_this.properties.images);
+        }
+        if (_this.isLevelChanger && Array.isArray(_this.properties.levels)) {
+            _this.properties.levels.forEach(function (level) { return (_this.properties["__level_" + level] = true); });
+        }
+        if (_this.properties.type === 'text' && Array.isArray(_this.properties.textFont)) {
+            _this.properties.textFont = _this.properties.textFont[0];
+        }
+        return _this;
+    }
+    Object.defineProperty(Feature.prototype, "isEditable", {
+        get: function () {
+            return this.isPoint || this.isLineString || this.isPolygon;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Feature.prototype, "isPoint", {
+        get: function () {
+            return this.geometry.type === 'Point';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Feature.prototype, "isPolygon", {
+        get: function () {
+            return this.geometry.type === 'Polygon' || this.geometry.type === 'MultiPolygon';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Feature.prototype, "isLineString", {
+        get: function () {
+            return this.geometry.type === 'LineString' || this.geometry.type === 'MultiLineString';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Feature.prototype, "isHazard", {
+        get: function () {
+            return this.properties.type === poi_type_1.POI_TYPE.HAZARD;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Feature.prototype, "isLandmark", {
+        get: function () {
+            return this.properties.type === poi_type_1.POI_TYPE.LANDMARK;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Feature.prototype, "isDoor", {
+        get: function () {
+            return this.properties.type === poi_type_1.POI_TYPE.DOOR;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Feature.prototype, "isEntrance", {
+        get: function () {
+            return this.properties.type === poi_type_1.POI_TYPE.ENTRANCE;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Feature.prototype, "isDecisionPoint", {
+        get: function () {
+            return this.properties.type === poi_type_1.POI_TYPE.DECISION;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Feature.prototype, "isTicketGate", {
+        get: function () {
+            return this.properties.type === poi_type_1.POI_TYPE.TICKET_GATE;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Feature.prototype, "isElevator", {
+        get: function () {
+            return this.properties.type === poi_type_1.POI_TYPE.ELEVATOR;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Feature.prototype, "isEscalator", {
+        get: function () {
+            return this.properties.type === poi_type_1.POI_TYPE.ESCALATOR;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Feature.prototype, "isStairCase", {
+        get: function () {
+            return this.properties.type === poi_type_1.POI_TYPE.STAIRCASE;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Feature.prototype, "isLevelChanger", {
+        get: function () {
+            return this.isElevator || this.isEscalator || this.isStairCase;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Feature.prototype, "isText", {
+        get: function () {
+            return this.properties.type === 'text';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Feature.prototype, "isSynthetic", {
+        get: function () {
+            var keys = ['id', 'place_id', 'floor_id', 'level'];
+            if (this.geometry.type === 'LineString' || this.geometry.type === 'MultiLineString') {
+                keys.push('class');
+            }
+            return (Object.keys(this.properties)
+                .map(function (key) { return !keys.includes(key); })
+                .filter(function (i) { return i; }).length === 0);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Feature.prototype, "isRoom", {
+        get: function () {
+            return this.properties.room;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Feature.prototype, "isRouting", {
+        get: function () {
+            return this.properties.usecase === 'routing';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Feature.prototype, "getTitle", {
+        get: function () {
+            return this.properties.title;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Feature.prototype, "getTitleWithLevel", {
+        get: function () {
+            return this.properties.title + " - Level: " + this.properties.level;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Feature.prototype, "json", {
+        get: function () {
+            if (this.properties.cameFrom) {
+                delete this.properties.cameFrom;
+            }
+            if (this.properties.fixedPointMap) {
+                delete this.properties.fixedPointMap;
+            }
+            var clone = JSON.parse(JSON.stringify(this));
+            if (clone.properties.metadata && typeof clone.properties.metadata !== 'object') {
+                try {
+                    clone.properties.metadata = JSON.parse(clone.properties.metadata);
+                }
+                catch (e) {
+                    console.log('feature parsing failed:', clone.properties.metadata);
+                }
+            }
+            Object.keys(clone.properties).forEach(function (key) {
+                if (key.match('__level')) {
+                    delete clone.properties.key;
+                }
+            });
+            return clone;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Feature.point = function (id, latitude, longitude, properties) {
+        return new Feature({
+            id: id,
+            geometry: {
+                type: 'Point',
+                coordinates: [longitude, latitude],
+            },
+            properties: properties,
+        });
+    };
+    Feature.prototype.setTitle = function (title, lang) {
+        if (lang === void 0) { lang = 'en'; }
+        if (typeof this.properties.title_18n === 'undefined') {
+            this.properties.title_18n = {};
+        }
+        this.properties.title_18n[lang] = title;
+    };
+    Feature.prototype.hasLevel = function (level) {
+        if (this.isLevelChanger) {
+            return this.properties.levels.includes(level);
+        }
+        else {
+            return this.properties.level === level;
+        }
+    };
+    return Feature;
+}(base_1.default));
+exports.default = Feature;

package/lib/models/floor.d.ts

@@ -0,0 +1,30 @@
+import BaseModel from './base';
+import { Geopoint } from './geopoint';
+export interface FloorEditorModel {
+    angle: number;
+    center: Geopoint;
+    opacity: number;
+    scale?: number;
+    url?: string;
+    width?: number;
+    coordinates?: {
+        c1: Geopoint;
+        c2: Geopoint;
+        c3: Geopoint;
+        c4: Geopoint;
+    } | number[][];
+}
+export declare type Coordinates = [number, number];
+export declare class FloorModel extends BaseModel {
+    name: string;
+    placeId: string;
+    placeName?: string;
+    floorplanImageUrl: string;
+    level: number;
+    anchors?: [Coordinates, Coordinates, Coordinates, Coordinates];
+    editor?: FloorEditorModel;
+    geopoint?: [number, number];
+    remoteId?: string;
+    constructor(data: any);
+    get hasFloorplan(): boolean;
+}