@mapvx/web-js 3.5.1 → 4.0.0-dev.1

package/dist/cjs/repository/requester.js

@@ -1,771 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Requester = void 0;
-const routeConfiguration_1 = require("../domain/models/routeConfiguration");
-const mapvxHostname_1 = require("../utils/mapvxHostname");
-/**
- * Default host for routing, health and legacy transport endpoints. In
- * production this differs from the data-API host (`public-api.mapvx.com`).
- * @hidden
- */
-const DEFAULT_MAPVX_API_URL = "https://api.mapvx.com";
-/**
- * Ensures a base URL is absolute (prepends `https://` when the protocol is
- * missing) and strips any trailing slash, so path segments concatenate cleanly.
- * @hidden
- */
-function normalizeBaseUrl(url) {
-    const withProtocol = url.startsWith("http://") || url.startsWith("https://") ? url : `https://${url}`;
-    return withProtocol.endsWith("/") ? withProtocol.slice(0, -1) : withProtocol;
-}
-/**
- * Represents the requester for the repository.
- * @hidden
- */
-class Requester {
-    constructor(lang, apiUrl = "https://public-api.mapvx.com", mapvxRequestContext, endpoints) {
-        var _a, _b, _c, _d;
-        this.lang = lang;
-        this.mapvxRequestContext = mapvxRequestContext;
-        const cleanApiUrl = normalizeBaseUrl(apiUrl);
-        // The `/api/sdk/v2` (api-key) and `/api/portal` (bearer) surfaces can live on
-        // different hosts (e.g. split local backends); `endpoints.portalApiUrl` overrides
-        // the portal host, defaulting to the sdk host when omitted.
-        // `?.trim() ||` for the same reason as the three hosts below: a blank/whitespace
-        // override must fall back to `apiUrl`, not build `https:// /api/portal/`.
-        const portalOverride = (_a = endpoints === null || endpoints === void 0 ? void 0 : endpoints.portalApiUrl) === null || _a === void 0 ? void 0 : _a.trim();
-        const cleanPortalUrl = portalOverride ? normalizeBaseUrl(portalOverride) : cleanApiUrl;
-        this.baseUrl = `${cleanApiUrl}/api/sdk/v2/`;
-        this.baseUrlPortal = `${cleanPortalUrl}/api/portal/`;
-        // Routing, health and legacy-transport endpoints live on a different host
-        // than `apiUrl` in production (api.mapvx.com vs public-api.mapvx.com), so
-        // they default to that host and can each be overridden independently — an
-        // offline totem points them at its local edge server so routes resolve
-        // without reaching the public internet.
-        // `?.trim() ||`, not `??`: an explicit blank/whitespace override (e.g. from a config object
-        // spread over incomplete defaults) must fall back to the default host too, not resolve to a
-        // bare-hostname URL like `https://sdk/`.
-        const routeBase = normalizeBaseUrl(((_b = endpoints === null || endpoints === void 0 ? void 0 : endpoints.routeApiUrl) === null || _b === void 0 ? void 0 : _b.trim()) || DEFAULT_MAPVX_API_URL);
-        const healthBase = normalizeBaseUrl(((_c = endpoints === null || endpoints === void 0 ? void 0 : endpoints.healthApiUrl) === null || _c === void 0 ? void 0 : _c.trim()) || DEFAULT_MAPVX_API_URL);
-        const legacyBase = normalizeBaseUrl(((_d = endpoints === null || endpoints === void 0 ? void 0 : endpoints.legacyApiUrl) === null || _d === void 0 ? void 0 : _d.trim()) || DEFAULT_MAPVX_API_URL);
-        this.baseUrlHealth = `${healthBase}/api/sdk/v2/health`;
-        this.oldBaseUrl = `${legacyBase}/api/sdk/`;
-        this.routeBaseUrl = `${routeBase}/sdk/`;
-    }
-    /**
-     * function to change the lang of requests
-     * @param lang request response language
-     */
-    setLang(lang) {
-        this.lang = lang;
-    }
-    /**
-     * Build headers for MapVx request context when target is under `*.mapvx.com`.
-     * Only non-empty context values are added (X-MapVx-* and mvx-product).
-     */
-    getMapVxContextHeaders(requestHost) {
-        var _a, _b, _c, _d, _e, _f, _g, _h;
-        if (!(0, mapvxHostname_1.isMapVxRequestHostname)(requestHost) || !this.mapvxRequestContext) {
-            return {};
-        }
-        const ctx = this.mapvxRequestContext;
-        const headers = {};
-        if ((_a = ctx.baseUrl) === null || _a === void 0 ? void 0 : _a.trim())
-            headers["X-MapVx-Base-Url"] = ctx.baseUrl.trim();
-        if ((_b = ctx.totemId) === null || _b === void 0 ? void 0 : _b.trim())
-            headers["X-MapVx-Totem-Id"] = ctx.totemId.trim();
-        if ((_c = ctx.originId) === null || _c === void 0 ? void 0 : _c.trim())
-            headers["X-MapVx-Origin-Id"] = ctx.originId.trim();
-        if ((_d = ctx.institutionId) === null || _d === void 0 ? void 0 : _d.trim())
-            headers["X-MapVx-Institution-Id"] = ctx.institutionId.trim();
-        if ((_e = ctx.parentPlace) === null || _e === void 0 ? void 0 : _e.trim())
-            headers["X-MapVx-Parent-Place"] = ctx.parentPlace.trim();
-        if ((_f = ctx.institutionName) === null || _f === void 0 ? void 0 : _f.trim())
-            headers["X-MapVx-Institution-Name"] = ctx.institutionName.trim();
-        if ((_g = ctx.fullUrl) === null || _g === void 0 ? void 0 : _g.trim())
-            headers["X-MapVx-Full-Url"] = ctx.fullUrl.trim();
-        if ((_h = ctx.mvxProduct) === null || _h === void 0 ? void 0 : _h.trim())
-            headers["mvx-product"] = ctx.mvxProduct.trim();
-        return headers;
-    }
-    /**
-     * Make a request using {@link fetch}.
-     * When the request target hostname matches `*.mapvx.com` and mapvxRequestContext is set,
-     * adds X-MapVx-* headers and `mvx-product` when set (baseUrl, totemId, originId, institutionId,
-     * parentPlace, institutionName, fullUrl, mvxProduct).
-     *
-     * @param resourceUrl Path to endpoint
-     * @param params should have the token included plus any extra parameter that the url needs
-     * @param options option for fetch method
-     * @returns Response promise
-     */
-    async fetchFromUrl(resourceUrl, params, options) {
-        const finalUrl = new URL(resourceUrl);
-        finalUrl.search = new URLSearchParams(params).toString();
-        const requestHost = finalUrl.hostname;
-        const contextHeaders = this.getMapVxContextHeaders(requestHost);
-        const mergedOptions = Object.assign({}, options);
-        if (Object.keys(contextHeaders).length > 0) {
-            mergedOptions.headers = Object.assign(Object.assign({}, (options.headers &&
-                typeof options.headers === "object" &&
-                !Array.isArray(options.headers)
-                ? options.headers
-                : {})), contextHeaders);
-        }
-        return fetch(finalUrl.toString(), mergedOptions);
-    }
-    /**
-     *
-     * @param token
-     * @param stopId
-     * @returns
-     */
-    async fetchTransport(token, stopId) {
-        const options = {
-            method: "GET",
-            headers: {
-                "content-type": "application/json",
-                Authorization: `Bearer ${token}`,
-            },
-        };
-        const params = {
-            stopId,
-            lang: this.lang,
-        };
-        return this.fetchFromUrl(this.oldBaseUrl + "vehiclesWithSchedules", params, options);
-    }
-    /**
-     *
-     * @param token
-     * @param stopId
-     * @param vehicleId
-     * @returns
-     */
-    async fetchStops(token, stopId, vehicleId) {
-        const options = {
-            method: "GET",
-            headers: {
-                "content-type": "application/json",
-                Authorization: `Bearer ${token}`,
-            },
-        };
-        const params = {
-            stopId,
-            vehicleId,
-            lang: this.lang,
-        };
-        return this.fetchFromUrl(this.oldBaseUrl + "stops", params, options);
-    }
-    /**
-     * Adds the map-style selection params shared by {@link fetchMapStyle} and
-     * {@link fetchMapStyleByBearer}.
-     *
-     * The theme goes under `styleTheme` (camelCase) while the place and style ref go
-     * under `place_id` / `style_ref`. The mixed casing is the server's actual contract,
-     * not an oversight: `FormInput.styleTheme` predates the snake_case params added
-     * alongside `style_ref` (backend-mono `seedwork/infrastructure/validation.ts`).
-     * Do not "fix" the casing here — `style_theme` is read by nothing.
-     *
-     * @param params Query params object to extend in place.
-     * @param placeId Optional place whose assigned style should be resolved.
-     * @param styleRef Optional explicit style reference, bypassing the place's style.
-     * @param styleTheme Optional theme (`"light"` | `"dark"`).
-     */
-    applyMapStyleParams(params, placeId, styleRef, styleTheme) {
-        if (placeId != null) {
-            params.place_id = placeId;
-        }
-        // Preview an explicit style ref / theme, bypassing the place's assigned style.
-        if (styleRef != null) {
-            params.style_ref = styleRef;
-        }
-        if (styleTheme != null) {
-            params.styleTheme = styleTheme;
-        }
-    }
-    /**
-     *
-     * @param token Client identification
-     * @param placeId
-     * @returns Response promise
-     */
-    async fetchMapStyle(token, placeId, styleRef, styleTheme) {
-        const options = {
-            method: "GET",
-            headers: {
-                "content-type": "application/json",
-                Authorization: `Bearer ${token}`,
-            },
-        };
-        const params = {
-            lang: this.lang,
-        };
-        this.applyMapStyleParams(params, placeId, styleRef, styleTheme);
-        return this.fetchFromUrl(this.baseUrl + "mapStyleJson", params, options);
-    }
-    /**
-     * Bearer-authenticated variant of {@link fetchMapStyle}: resolves the style JSON
-     * using the logged-in user's token, so access is authorized by the user's client
-     * permissions rather than the api key's scopes. Same query contract
-     * (`place_id`, `style_ref`, `styleTheme`).
-     */
-    async fetchMapStyleByBearer(authToken, placeId, styleRef, styleTheme) {
-        const options = {
-            method: "GET",
-            headers: {
-                "content-type": "application/json",
-                Authorization: `Bearer ${authToken}`,
-            },
-        };
-        const params = {
-            lang: this.lang,
-        };
-        this.applyMapStyleParams(params, placeId, styleRef, styleTheme);
-        return this.fetchFromUrl(this.baseUrlPortal + "mapStyleJson", params, options);
-    }
-    /**
-     * Fetches the map style configuration for a specified institution.
-     * Can be used to obtain any map style from an Institution, without the limitation of the ApiKey.
-     * Therefore, does not make use of an ApiKey but rather an authentication token.
-     *
-     * Sends a GET request to the "mapStyle" endpoint using the provided authentication token
-     * and institution ID. The request includes language and institution ID as query parameters.
-     *
-     * @param token - The Bearer authentication token to authorize the request.
-     * @param institutionId - The unique identifier of the institution whose map style is being requested.
-     * @returns A promise that resolves to the HTTP response containing the map style data.
-     */
-    async fetchAnyMapStyle(authToken, institutionId) {
-        const options = {
-            method: "GET",
-            headers: {
-                "content-type": "application/json",
-                Authorization: `Bearer ${authToken}`,
-            },
-        };
-        const params = {
-            lang: this.lang,
-            institution_id: institutionId,
-        };
-        return this.fetchFromUrl(this.baseUrlPortal + "mapStyle", params, options);
-    }
-    /**
-     * Obtain allowed Places associated with the key
-     * @param token
-     * @returns Response promise
-     */
-    async fetchAllowedPlaces(token) {
-        const options = {
-            method: "GET",
-            headers: {
-                "content-type": "application/json",
-                Authorization: `Bearer ${token}`,
-            },
-        };
-        const params = {
-            lang: this.lang,
-        };
-        return this.fetchFromUrl(this.baseUrl + "availablePlaces", params, options);
-    }
-    /**
-     * Fetches the available places for a given institution using the provided authentication token.
-     * Does not make use of an ApiKey but rather an authentication token, therefore it is not limited by the allowed ApiKey places.
-     *
-     * Sends a GET request to the `availablePlaces` endpoint with the institution ID and language as parameters.
-     *
-     * @param authToken - The authentication token used for authorization in the request header.
-     * @param institutionId - The unique identifier of the institution whose places are to be fetched.
-     * @returns A promise that resolves to the response from the API.
-     */
-    async fetchPlacesFromAnyInstitution(institutionId, authToken) {
-        const options = {
-            method: "GET",
-            headers: {
-                "content-type": "application/json",
-                Authorization: `Bearer ${authToken}`,
-            },
-        };
-        const params = {
-            institution_id: institutionId,
-            lang: this.lang,
-        };
-        return this.fetchFromUrl(this.baseUrlPortal + "availablePlaces", params, options);
-    }
-    /**
-     * Obtain info about specific place. Use mainly to obtain innerFloors.
-     *
-     * When `placeId` is an internal alias that may be reused across buildings, pass
-     * `buildingId` (and optionally `floorId`/`level`) to disambiguate which venue the
-     * alias refers to. `floorId` takes precedence over the numeric `level`.
-     * @param token
-     * @param placeId
-     * @param buildingId (Optional) Parent building/venue that contains the place.
-     * @param floorId (Optional) Floor ID within the building.
-     * @param level (Optional) Numeric floor level; used only when `floorId` is absent.
-     * @returns
-     */
-    async fetchPlaceDetail(token, placeId, buildingId, floorId, level) {
-        const options = {
-            method: "GET",
-            headers: {
-                "content-type": "application/json",
-                Authorization: `Bearer ${token}`,
-            },
-        };
-        const params = {
-            place_id: placeId,
-            lang: this.lang,
-        };
-        if (buildingId !== undefined) {
-            params.building = buildingId;
-        }
-        if (floorId !== undefined) {
-            params.floor = floorId;
-        }
-        else if (level !== undefined) {
-            params.floor = level;
-        }
-        return this.fetchFromUrl(this.baseUrl + "place", params, options);
-    }
-    /**
-     * Fetches detailed information for a specific place using its unique identifier.
-     * Can be used to obtain any place detail, without the limitation of the ApiKey.
-     * Therefore, does not make use of an ApiKey but rather an authentication token.
-     *
-     * When `placeId` is an internal alias that may be reused across buildings, pass
-     * `buildingId` (and optionally `floorId`/`level`) to disambiguate which venue the
-     * alias refers to. `floorId` takes precedence over the numeric `level`.
-     *
-     * @param authToken - The authentication token used for authorization in the request header.
-     * @param placeId - The unique identifier of the place to retrieve details for.
-     * @param buildingId - (Optional) Parent building/venue that contains the place.
-     * @param floorId - (Optional) Floor ID within the building.
-     * @param level - (Optional) Numeric floor level; used only when `floorId` is absent.
-     * @returns A promise that resolves to the HTTP response containing the place details.
-     *
-     */
-    async fetchAnyPlaceDetail(authToken, placeId, buildingId, floorId, level) {
-        const options = {
-            method: "GET",
-            headers: {
-                "content-type": "application/json",
-                Authorization: `Bearer ${authToken}`,
-            },
-        };
-        const params = {
-            place_id: placeId,
-            lang: this.lang,
-        };
-        if (buildingId !== undefined) {
-            params.building = buildingId;
-        }
-        if (floorId !== undefined) {
-            params.floor = floorId;
-        }
-        else if (level !== undefined) {
-            params.floor = level;
-        }
-        return this.fetchFromUrl(this.baseUrlPortal + "place", params, options);
-    }
-    /**
-     * To obtain all places associated with targetPlace
-     * @param targetPlaceId
-     * @param token
-     * @returns
-     */
-    async fetchSubPlaces(targetPlaceId, token) {
-        const options = {
-            method: "GET",
-            headers: {
-                "content-type": "application/json",
-                Authorization: `Bearer ${token}`,
-            },
-        };
-        const params = {
-            targetPlace: targetPlaceId,
-            lang: this.lang,
-        };
-        return this.fetchFromUrl(this.baseUrl + "subPlaces", params, options);
-    }
-    /**
-     * Fetches sub-places for any specified target place using the Portal API.
-     * Can be used to obtain the sub-places for any target place, without the limitation of the ApiKey.
-     * Therefore, does not make use of an ApiKey but rather an authentication token.
-     *
-     * Sends a GET request to the "subPlaces" endpoint with the provided Bearer authentication token
-     * and target place ID. The request includes language and target place ID as query parameters.
-     *
-     * @param targetPlaceId - The unique identifier of the target place whose sub-places are being requested.
-     * @param authToken - The Bearer authentication token to authorize the request.
-     * @returns A promise that resolves to the HTTP response containing the sub-places data.
-     */
-    async fetchAnySubPlaces(targetPlaceId, authToken) {
-        const options = {
-            method: "GET",
-            headers: {
-                "content-type": "application/json",
-                Authorization: `Bearer ${authToken}`,
-            },
-        };
-        const params = {
-            place_id: targetPlaceId,
-            lang: this.lang,
-        };
-        return this.fetchFromUrl(this.baseUrlPortal + "subPlaces", params, options);
-    }
-    /**
-     * Build the cleaned query parameters for a route request.
-     *
-     * Resolves both the origin (`from*`) and destination (`to*`) sides of the route
-     * from the provided configuration. For {@link IdLocation} endpoints this also
-     * forwards the building (`fromBuilding`/`toBuilding`) and floor
-     * (`fromFloor`/`toFloor`) so internal aliases that are reused across buildings
-     * can be disambiguated. Parameters that resolve to `null`/`undefined` are dropped.
-     * @param routeConfig The route configuration to translate into query params.
-     * @returns The cleaned query parameters ready to be appended to the request URL.
-     */
-    buildRouteParams(routeConfig) {
-        const params = {
-            fromLatLng: undefined,
-            fromBuilding: undefined,
-            fromFloor: undefined,
-            toLatLng: undefined,
-            toBuilding: undefined,
-            toFloor: undefined,
-            fromPlaceId: undefined,
-            toPlaceId: undefined,
-            travelMode: routeConfiguration_1.TransportationMode.walking,
-            reducedMobility: routeConfig.preferAccessibleRoute ? 1 : 0,
-            announceFormat: routeConfig.announceFormat,
-            userBearing: routeConfig.userBearing,
-            lang: this.lang,
-            unitSystem: routeConfig.unitSystem,
-        };
-        if ("id" in routeConfig.initialLocation) {
-            const { id, buildingId, floorId, level } = routeConfig.initialLocation;
-            params.fromPlaceId = id;
-            if (buildingId !== undefined) {
-                params.fromBuilding = buildingId;
-            }
-            if (floorId !== undefined) {
-                params.fromFloor = floorId;
-            }
-            else if (level !== undefined) {
-                params.fromFloor = level;
-            }
-        }
-        else {
-            const { lat, lng, floorId, placeId } = routeConfig.initialLocation;
-            params.fromLatLng = `${lat},${lng}`;
-            params.fromFloor = floorId;
-            params.fromBuilding = placeId;
-        }
-        if ("id" in routeConfig.finalLocation) {
-            const { id, buildingId, floorId, level } = routeConfig.finalLocation;
-            params.toPlaceId = id;
-            if (buildingId !== undefined) {
-                params.toBuilding = buildingId;
-            }
-            if (floorId !== undefined) {
-                params.toFloor = floorId;
-            }
-            else if (level !== undefined) {
-                params.toFloor = level;
-            }
-        }
-        else {
-            const { lat, lng, floorId, placeId } = routeConfig.finalLocation;
-            params.toLatLng = `${lat},${lng}`;
-            params.toFloor = floorId;
-            params.toBuilding = placeId;
-        }
-        const cleanParams = {};
-        for (const key in params) {
-            const value = params[key];
-            if (value != null) {
-                cleanParams[key] = value;
-            }
-        }
-        return cleanParams;
-    }
-    /**
-     * To obtain the route
-     * @param routeConfig
-     * @returns
-     */
-    async fetchRoute(routeConfig, token) {
-        const options = {
-            method: "GET",
-            headers: {
-                "content-type": "application/json",
-                Authorization: `Bearer ${token}`,
-            },
-        };
-        const cleanParams = this.buildRouteParams(routeConfig);
-        return this.fetchFromUrl(this.routeBaseUrl + "route", cleanParams, options);
-    }
-    /**
-     * To obtain the route
-     * @param routeConfig
-     * @returns
-     */
-    async fetchRouteV2(routeConfig, token) {
-        const options = {
-            method: "GET",
-            headers: {
-                "content-type": "application/json",
-                Authorization: `Bearer ${token}`,
-            },
-        };
-        const cleanParams = this.buildRouteParams(routeConfig);
-        return this.fetchFromUrl(this.routeBaseUrl + "v2/route", cleanParams, options);
-    }
-    /**
-     * To obtain the route from the live routing endpoint (`/sdk/liveroute`).
-     * @param routeConfig
-     * @returns
-     */
-    async fetchLiveRoute(routeConfig, token) {
-        const options = {
-            method: "GET",
-            headers: {
-                "content-type": "application/json",
-                Authorization: `Bearer ${token}`,
-            },
-        };
-        const cleanParams = this.buildRouteParams(routeConfig);
-        return this.fetchFromUrl(this.routeBaseUrl + "liveroute", cleanParams, options);
-    }
-    /**
-     * To obtain info associated to an Institution based on id provided
-     * It return 403 if the institution id
-     * @param targetPlaceId
-     * @param token
-     * @returns
-     */
-    async fetchInstitutions(token) {
-        const options = {
-            method: "GET",
-            headers: {
-                "content-type": "application/json",
-                Authorization: `Bearer ${token}`,
-            },
-        };
-        const params = {
-            lang: this.lang,
-        };
-        return this.fetchFromUrl(this.baseUrl + "institution", params, options);
-    }
-    /**
-     * To obtain places from an institution whose name is similar to provided input
-     * @param institutionId
-     * @param input Provided value to look for
-     * @param token Client identification
-     * @param parentIds Identifier of the parent place
-     * @param origin The ID of a totem or a place origin from directories. Used to return search results based on distance from the origin.
-     * @param lat Latitude as a string for location-based search.
-     * @param lng Longitude as a string for location-based search.
-     * @param floor Floor ID as a string for location-based search.
-     * @returns Response promise
-     */
-    async fetchSearchResults(institutionId, input, token, parentIds, origin, lat, lng, floor) {
-        const options = {
-            method: "GET",
-            headers: {
-                "content-type": "application/json",
-                Authorization: `Bearer ${token}`,
-            },
-        };
-        const params = {
-            institution_id: institutionId,
-            input,
-            lang: this.lang,
-        };
-        if (parentIds) {
-            params.parentPlaces = [...parentIds];
-        }
-        if (origin) {
-            params.origin = origin;
-        }
-        if (lat) {
-            params.lat = lat;
-        }
-        if (lng) {
-            params.lng = lng;
-        }
-        if (floor) {
-            params.floor = floor;
-        }
-        return this.fetchFromUrl(this.baseUrl + "searchPlacesWithFilters", params, options);
-    }
-    /**
-     * Search places by one or more tags via the v2 endpoint `/api/sdk/v2/searchPlacesByTags`.
-     *
-     * Multiple tags are sent as a repeated/joined `tags` query parameter; the API
-     * accepts both `?tags=a&tags=b` and `?tags=a,b` forms.
-     *
-     * @param institutionId Institution to search within.
-     * @param tags Tags to match against. Must contain at least one entry.
-     * @param token Client API token.
-     * @param parentPlaces Optional list of parent place ids used to scope the search.
-     * @param sort Result ordering: `match` (Elastic scoring, default), `alphabetical`,
-     *   or `distance` (requires `origin` or `lat`+`lng`+`floor`+`parentPlaces`).
-     * @param origin Place id of an origin (e.g. a totem) used as the distance reference.
-     * @param lat Latitude as string for distance-based ordering.
-     * @param lng Longitude as string for distance-based ordering.
-     * @param floor Floor id as string for distance-based ordering.
-     * @returns Response promise.
-     */
-    async fetchSearchPlacesByTags(institutionId, tags, token, parentPlaces, sort, origin, lat, lng, floor) {
-        // The v2 endpoints authenticate via the Authorization header (Bearer),
-        // not via a `token` query parameter like the legacy /api/sdk/* routes.
-        const options = {
-            method: "GET",
-            headers: {
-                "content-type": "application/json",
-                Authorization: `Bearer ${token}`,
-            },
-        };
-        const params = {
-            institution_id: institutionId,
-            tags: [...tags],
-            lang: this.lang,
-        };
-        if (parentPlaces && parentPlaces.length > 0) {
-            params.parentPlaces = [...parentPlaces];
-        }
-        if (sort) {
-            params.sort = sort;
-        }
-        if (origin) {
-            params.origin = origin;
-        }
-        if (lat) {
-            params.lat = lat;
-        }
-        if (lng) {
-            params.lng = lng;
-        }
-        if (floor) {
-            params.floor = floor;
-        }
-        return this.fetchFromUrl(this.baseUrl + "searchPlacesByTags", params, options);
-    }
-    async fetchConfiguration(token, place_id, product) {
-        const options = {
-            method: "GET",
-            headers: {
-                "content-type": "application/json",
-                Authorization: `Bearer ${token}`,
-            },
-        };
-        const params = {
-            lang: this.lang,
-        };
-        if (place_id)
-            params.place_id = place_id;
-        if (product)
-            params.product = product;
-        return this.fetchFromUrl(this.baseUrl + "configuration", params, options);
-    }
-    /**
-     * Fetches the campaigns configured for a maps-group (totem screensaver playlist).
-     * `place_id` is the maps-group firebase id; `kiosk_id` optionally narrows to a
-     * single totem. Uses the api-key (`/api/sdk/v2/`) surface.
-     */
-    async fetchCampaigns(token, place_id, kiosk_id) {
-        const options = {
-            method: "GET",
-            headers: {
-                "content-type": "application/json",
-                Authorization: `Bearer ${token}`,
-            },
-        };
-        const params = {
-            placeId: place_id,
-        };
-        if (kiosk_id)
-            params.kioskId = kiosk_id;
-        return this.fetchFromUrl(this.baseUrl + "campaigns", params, options);
-    }
-    async fetchCategories(token, place_id) {
-        const options = {
-            method: "GET",
-            headers: {
-                "content-type": "application/json",
-                Authorization: `Bearer ${token}`,
-            },
-        };
-        const params = {
-            lang: this.lang,
-        };
-        if (place_id)
-            params.id = place_id;
-        return this.fetchFromUrl(this.baseUrl + "category", params, options);
-    }
-    async fetchRoutesForOrigin(token, parentPlaceId, fromPlaceId, announceFormat, unitSystem, mode) {
-        const options = {
-            method: "GET",
-            headers: {
-                "content-type": "application/json",
-                Authorization: `Bearer ${token}`,
-            },
-        };
-        const params = {
-            placeId: parentPlaceId,
-            fromPlace: fromPlaceId,
-            announceFormat,
-            unitSystem,
-            mode,
-            lang: this.lang,
-        };
-        return this.fetchFromUrl(this.routeBaseUrl + "routes_for_origin", params, options);
-    }
-    async fetchCacheTimestamp(token, placeId) {
-        const options = {
-            method: "GET",
-            headers: {
-                "content-type": "application/json",
-                Authorization: `Bearer ${token}`,
-            },
-        };
-        const params = {
-            placeId,
-        };
-        return this.fetchFromUrl(this.routeBaseUrl + "cache_timestamp", params, options);
-    }
-    async fetchCssCustomization(token, type) {
-        const options = {
-            method: "GET",
-            headers: {
-                "content-type": "application/json",
-                Authorization: `Bearer ${token}`,
-            },
-        };
-        const params = {
-            type,
-        };
-        return this.fetchFromUrl(this.baseUrl + "styles/customStyles", params, options);
-    }
-    async postHealth(token, healthPingId, placeId, totemId, status) {
-        const requestData = JSON.stringify({
-            healthPingId: healthPingId,
-            placeId: placeId,
-            totemId: totemId,
-            status: status,
-        });
-        const params = {};
-        const options = {
-            method: "POST",
-            headers: {
-                accept: "application/json",
-                "Content-Type": "application/json",
-                Authorization: `Bearer ${token}`,
-            },
-            body: requestData,
-        };
-        return this.fetchFromUrl(this.baseUrlHealth, params, options);
-    }
-}
-exports.Requester = Requester;
-//# sourceMappingURL=requester.js.map