@pointr-tech/web-sdk 10.8.0-rc.3

package/dist/pointrwebsdk.d.ts

@@ -0,0 +1,3022 @@
+import maplibregl from 'maplibre-gl';
+import * as THREE from 'three';
+import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js';
+
+declare global {
+    interface Object {
+        can(methodName: string): boolean;
+        implement(intrface: new (...args: unknown[]) => unknown): void;
+        isDictionary(): boolean;
+    }
+}
+
+interface LatLngDict {
+    lat: number;
+    lng: number;
+}
+declare class LatLng {
+    lat?: number;
+    lng?: number;
+    constructor(dict: LatLngDict);
+    static isValid(dict: LatLngDict): boolean;
+}
+
+type JsonPrimitive = string | number | boolean | null | undefined;
+type JsonValue = JsonPrimitive | JsonObject | JsonValue[];
+type JsonObject = {
+    [key: string]: JsonValue;
+};
+interface ViewStatusOptions {
+    shouldEnable: boolean;
+}
+interface MapPointFeature {
+    id?: string | number;
+    geometry: {
+        coordinates: [number, number];
+    };
+    properties?: JsonObject;
+}
+interface RouteDataDirection {
+    buildingInternalIdentifier?: string | undefined;
+    message: string;
+    latLng: LatLng;
+    levelIndex?: number | undefined;
+    iconName: string;
+    iconType?: string;
+}
+interface RouteFeatureProperties {
+    type: string;
+    bid?: string;
+    lvl?: number;
+    distanceUntilMeters?: number;
+    distanceUntilFeet?: number;
+    transitionInfo?: {
+        mainType?: string;
+        subType?: string;
+        name?: string;
+        groupId?: string;
+    };
+    [key: string]: JsonValue;
+}
+interface RouteDataResponse {
+    timeSeconds?: number;
+    distanceMeters?: number;
+    distanceFeet?: number;
+    directions?: {
+        features?: Array<{
+            properties: RouteFeatureProperties;
+            geometry: {
+                coordinates: [number, number];
+            };
+        }>;
+    };
+    nodes?: {
+        features?: Array<{
+            properties: {
+                bid?: string;
+                lvl?: number;
+                transitionInfo?: {
+                    mainType?: string;
+                    subType?: string;
+                    groupId?: string;
+                };
+            };
+            geometry: {
+                coordinates: [number, number];
+            };
+        }>;
+    };
+}
+
+interface SearchablePoi {
+    searchName(): string;
+    searchDescription(): string;
+    searchKeywords(): string;
+    properties: {
+        bid?: string;
+        name?: string;
+        lvl?: number | string;
+        [key: string]: JsonValue;
+    };
+}
+interface WorldModePoi {
+    properties: {
+        name?: string;
+    };
+    siteTitle: string;
+}
+
+declare class Language {
+    static _allCodes: Record<string, string>;
+    static _supportedCodes: string[];
+    private _code;
+    private _language;
+    private _locale;
+    private _title;
+    static mapChineseVariants(code: string | undefined | null): string;
+    static allRecognisedLanguages(): Language[];
+    static isRecognisedLanguageCode(code: string): boolean;
+    static isSupportedLanguageCode(code: string): boolean;
+    static fromCode(code: string): Language | undefined;
+    constructor(pCode: string);
+    toString(): string;
+    get code(): string;
+    get language(): string;
+    get locale(): string;
+    get title(): string;
+}
+
+interface PoiGeometry {
+    type?: string;
+    coordinates?: number[] | number[][][];
+}
+interface PoiProperties {
+    readonly fid?: number;
+    readonly sid?: string;
+    readonly bid?: string;
+    readonly lvl?: number | string;
+    eid?: string;
+    readonly mainType?: string;
+    readonly subType?: string;
+    readonly mapPersonas?: string[] | null;
+    name?: string;
+    description?: string;
+    keywords?: string | string[];
+    internalIdentifier?: string;
+    imageUrl?: string;
+    snapshotUrl?: string;
+    levelIndex?: number | string;
+    icon?: string;
+    color?: string;
+    outlineColor?: string;
+    extrusionHeight?: number;
+    opacity?: number;
+    searchName?: string;
+    searchDescription?: string;
+    searchKeywords?: string;
+    poiPosition?: number | string;
+    poiPositionIndex?: number;
+    readonly isFeatured?: boolean;
+    [key: string]: JsonValue;
+}
+interface PoiData {
+    type?: string;
+    properties?: PoiProperties;
+    geometry?: PoiGeometry;
+}
+interface PoiStyleObject {
+    icon?: string;
+    color?: string;
+    outlineColor?: string;
+    extrusionHeight?: number;
+    opacity?: number;
+}
+declare class Poi implements SearchablePoi {
+    #private;
+    protected _properties: PoiProperties;
+    protected readonly _geometry: Readonly<PoiGeometry> | undefined;
+    type?: string;
+    siteTitle?: string;
+    buildingInternalIdentifier?: string;
+    siteInternalIdentifier?: string;
+    constructor(data?: PoiData);
+    protected normalizeProperties(value: PoiProperties): PoiProperties;
+    protected lockImmutableProperty(target: PoiProperties, key: keyof PoiProperties, propertyValue: unknown): void;
+    protected warnIfImmutablePropertyChanged(current: PoiProperties, incoming: PoiProperties, key: keyof PoiProperties): void;
+    isValid(): boolean;
+    set properties(value: PoiProperties);
+    get properties(): PoiProperties;
+    get geometry(): Readonly<PoiGeometry> | undefined;
+    get identifier(): string | undefined;
+    get imageUrl(): string | undefined;
+    get levelIndex(): number | undefined;
+    name(language?: Language | null): string;
+    snapshotUrl(): string | undefined;
+    description(language?: Language | null): string;
+    keywords(language?: Language | null): string;
+    getTranslationOrDefault(propertyName: string, languageObj?: Language | null): string;
+    get lowerCaseKeywords(): string;
+    searchName(): string;
+    searchDescription(): string;
+    searchKeywords(): string;
+    setIcon(icon: string | undefined): void;
+    setColor(color: string | undefined): void;
+    setOutlineColor(outlineColor: string | undefined): void;
+    setExtrusionHeight(height: number | undefined): void;
+    setOpacity(opacity: number | undefined): void;
+    setStyle(styleObject: PoiStyleObject | null | undefined): void;
+    resetStyle(): void;
+    getProperties(): PoiProperties;
+    getGeometry(): PoiGeometry;
+    toGeoJSON(): GeoJSON.Feature;
+}
+
+interface FeatureGeometry {
+    type: string;
+    coordinates: number[] | number[][][];
+}
+declare class Feature {
+    id: string;
+    properties: JsonObject;
+    geometry: FeatureGeometry;
+    constructor(properties: JsonObject | undefined, geometry: FeatureGeometry, id?: string | number);
+}
+
+interface NetworkCoordinatorConfigureOptions {
+    baseUrl?: string | undefined;
+    clientIdentifier?: string | undefined;
+    licenseKey?: string | undefined;
+}
+interface SiteCDNVersions {
+    beacon?: number;
+    mapContent?: number;
+    mapObject?: number;
+    obstacle?: number;
+    path?: number;
+    poi?: number;
+    siteMeta?: number;
+    siteInternalIdentifier?: string;
+    [key: string]: number | string | undefined;
+}
+interface DecodedToken {
+    publishedContentServer?: string;
+    signedUrlParams?: string;
+    sasToken?: string;
+    cdnBaseUrl?: string;
+}
+declare class NetworkCoordinator {
+    static _instance: NetworkCoordinator;
+    static REQUEST_COUNTER: number;
+    static apiToken: string | undefined;
+    static baseUrl: string | undefined;
+    static clientIdentifier: string | undefined;
+    static licenseKey: string | undefined;
+    static grantType: string | undefined;
+    static sasToken: string | undefined;
+    static contentBaseUrl: string | undefined;
+    static contentVersions: unknown;
+    static siteCDNVersions: SiteCDNVersions | undefined;
+    static requestCounter: number;
+    static isCDNEnabled: boolean | undefined;
+    static decodedToken: DecodedToken | null;
+    shouldCache: Record<string, boolean>;
+    cachedPromises: Record<string, Promise<unknown>>;
+    constructor();
+    static singleton(): NetworkCoordinator;
+    static configure(options?: NetworkCoordinatorConfigureOptions): void;
+    get apiToken(): string | undefined;
+    get baseUrl(): string | undefined;
+    get clientIdentifier(): string | undefined;
+    get licenseKey(): string | undefined;
+    get grantType(): string | undefined;
+    get sasToken(): string | undefined;
+    get contentBaseUrl(): string | undefined;
+    get contentVersions(): unknown;
+    get requestCounter(): number;
+    set requestCounter(value: number);
+    set licenseKey(value: string | undefined);
+    set grantType(value: string | undefined);
+    set apiToken(value: string | undefined);
+    set sasToken(value: string | undefined);
+    set contentBaseUrl(value: string | undefined);
+    set contentVersions(value: unknown);
+    get siteCDNVersions(): SiteCDNVersions | undefined;
+    set siteCDNVersions(value: SiteCDNVersions | undefined);
+    set clientIdentifier(value: string | undefined);
+    set baseUrl(value: string | undefined);
+    get isCDNEnabled(): boolean | undefined;
+    set isCDNEnabled(value: boolean | undefined);
+    static decreaseRequestCounter(): void;
+    static setApiToken(pointrCloudToken?: string): Promise<boolean>;
+    static decodeAndProcessToken(accessToken: string): void;
+    static processSasToken(decodedToken: DecodedToken): void;
+    static processCdnUrl(decodedToken: DecodedToken): void;
+    getCDNVersions(): Promise<void>;
+    getSiteCDNVersions(siteInternalIdentifier: string): Promise<SiteCDNVersions>;
+    getConfigurations(): Promise<unknown>;
+    getClient(): Promise<unknown>;
+    getPersonas(): Promise<unknown>;
+    getTiles(): Promise<unknown>;
+    getSites(): Promise<unknown>;
+    getBuildings(): Promise<unknown>;
+    getFeatureTypes(): Promise<unknown>;
+    getPois(siteInternalIdentifier: string): Promise<Record<string, Poi>>;
+    fetchNavigation(startObject: Poi | Feature | unknown, destinationObject: Poi | Feature | unknown, navigationMode: string, personaIdentifier?: string): Promise<unknown> | undefined;
+    fetchStyleJson(styeJsonUrl: string): Promise<unknown>;
+    postEvent(analyticsEventUploadUrl: string, eventData: unknown, sasToken: string): Promise<unknown>;
+    cdnFetchHelper(cdnUrl: string, baseUrl: string): Promise<unknown>;
+    fetchHelper(url: string, isCDNRequest?: boolean): Promise<unknown>;
+    fetchData(url: string, isCDNRequest?: boolean, _block?: boolean): Promise<unknown>;
+    handleApiResponse(url: string, data: unknown, isCDNRequest: boolean | undefined, response: Response): Promise<unknown>;
+    handleApiError(url: string, error: {
+        code?: string;
+        message?: string;
+    } | undefined, isCDNRequest: boolean | undefined, response: Response): Promise<unknown>;
+    handleError(url: string, error: Error): string;
+    decreaseRequestCounter(): Promise<void>;
+}
+
+interface PointrOptions {
+    isSearchEnabled: boolean;
+    isPoiDetailsEnabled: boolean;
+    isZoomControlEnabled: boolean;
+    isLanguageSelectorEnabled: boolean;
+    isNavigationEnabled: boolean;
+    isAccessibilityEnabled: boolean;
+    isQuickAccessEnabled: boolean;
+    baseUrl: string | undefined;
+    clientIdentifier: string | undefined;
+    licenseKey: string | undefined;
+    siteInternalIdentifier: string | undefined;
+    buildingInternalIdentifier: string | undefined;
+    siteExternalIdentifier: string | undefined;
+    buildingExternalIdentifier: string | undefined;
+    levelExternalIdentifier: string | undefined;
+    levelIndex: number | undefined;
+    mapMinZoom: number;
+    mapMaxZoom: number;
+    initialZoomLevel: number | undefined;
+    latitude: number | undefined;
+    longitude: number | undefined;
+    bearing: number | undefined;
+    pitch: number | undefined;
+    navigationStartPoi: string | undefined;
+    startLevelIndex: number | undefined;
+    startPointLat: number | undefined;
+    startPointLng: number | undefined;
+    navigationDestinationPoi: string | undefined;
+    destinationLevelIndex: number | undefined;
+    destinationPointLat: number | undefined;
+    destinationPointLng: number | undefined;
+    highlightPoiIdentifier: string | undefined;
+    highlightPointLat: number | undefined;
+    highlightPointLng: number | undefined;
+    language: string;
+    languageList: string[];
+    container: string;
+    mode: string;
+    deviceIdentifierForAnalytics: string | undefined;
+    personaIdentifier: string | undefined;
+    analyticsCustomLaunchParams: JsonObject | undefined;
+    quickAccessSelectionZoomLevel: number | undefined;
+    isAppBannerEnabled: boolean;
+    pointrCloudToken: string | undefined;
+}
+type PointrOptionsInput = Partial<PointrOptions>;
+interface OptionsValidationResult {
+    isValid: boolean;
+    errorMsg?: string | undefined;
+}
+interface SiteBuildingValidationResult {
+    isValid: boolean;
+    errorTitle?: string;
+    errorMsg?: string;
+}
+declare class Options {
+    defaultOptions: PointrOptions;
+    _mapMinZoom: number;
+    _mapMaxZoom: number;
+    _initialZoomLevel: number | undefined;
+    _latitude: number | undefined;
+    _longitude: number | undefined;
+    _bearing: number | undefined;
+    _pitch: number | undefined;
+    _startPointLat: number | undefined;
+    _startPointLng: number | undefined;
+    _destinationPointLat: number | undefined;
+    _destinationPointLng: number | undefined;
+    _isSearchEnabled: boolean;
+    _isPoiDetailsEnabled: boolean;
+    _isZoomControlEnabled: boolean;
+    _isLanguageSelectorEnabled: boolean;
+    _isNavigationEnabled: boolean;
+    _isAccessibilityEnabled: boolean;
+    _isQuickAccessEnabled: boolean;
+    _clientIdentifier: string | undefined;
+    _licenseKey: string | undefined;
+    _baseUrl: string | undefined;
+    _siteInternalIdentifier: string | undefined;
+    _buildingInternalIdentifier: string | undefined;
+    _siteExternalIdentifier: string | undefined;
+    _buildingExternalIdentifier: string | undefined;
+    _levelIndex: number | undefined;
+    _levelExternalIdentifier: string | undefined;
+    _startLevelIndex: number | undefined;
+    _destinationLevelIndex: number | undefined;
+    _navigationStartPoi: string | undefined;
+    _navigationDestinationPoi: string | undefined;
+    _highlightPoiIdentifier: string | undefined;
+    _highlightPointLat: number | undefined;
+    _highlightPointLng: number | undefined;
+    _language: string;
+    _languageList: string[];
+    _container: string;
+    _mode: string;
+    _deviceIdentifierForAnalytics: string | undefined;
+    _personaIdentifier: string | undefined;
+    _analyticsCustomLaunchParams: JsonObject | undefined;
+    _quickAccessSelectionZoomLevel: number | undefined;
+    _isAppBannerEnabled: boolean;
+    _pointrCloudToken: string | undefined;
+    constructor(options?: PointrOptionsInput | null);
+    validate(): OptionsValidationResult;
+    validateSite(sites: Array<{
+        siteInternalIdentifier: string;
+    }>): SiteBuildingValidationResult;
+    validateBuilding(buildings: Array<{
+        buildingInternalIdentifier: string;
+        levels?: Array<{
+            levelIndex: number;
+            externalIdentifier?: string;
+        }>;
+    }>): SiteBuildingValidationResult;
+    set mapMinZoom(value: number);
+    get mapMinZoom(): number;
+    set mapMaxZoom(value: number);
+    get mapMaxZoom(): number;
+    set initialZoomLevel(value: number | undefined);
+    get initialZoomLevel(): number | undefined;
+    set latitude(value: number | undefined);
+    get latitude(): number | undefined;
+    set longitude(value: number | undefined);
+    get longitude(): number | undefined;
+    set startPointLat(value: number | undefined);
+    get startPointLat(): number | undefined;
+    set startPointLng(value: number | undefined);
+    get startPointLng(): number | undefined;
+    set destinationPointLat(value: number | undefined);
+    get destinationPointLat(): number | undefined;
+    set destinationPointLng(value: number | undefined);
+    get destinationPointLng(): number | undefined;
+    set bearing(value: number | undefined);
+    get bearing(): number | undefined;
+    set pitch(value: number | undefined);
+    get pitch(): number | undefined;
+    set isSearchEnabled(value: boolean | undefined);
+    get isSearchEnabled(): boolean;
+    set isZoomControlEnabled(value: boolean | undefined);
+    get isZoomControlEnabled(): boolean;
+    set isLanguageSelectorEnabled(value: boolean | undefined);
+    get isLanguageSelectorEnabled(): boolean;
+    set isNavigationEnabled(value: boolean | undefined);
+    get isNavigationEnabled(): boolean;
+    set isAccessibilityEnabled(value: boolean | undefined);
+    get isAccessibilityEnabled(): boolean;
+    set isQuickAccessEnabled(value: boolean | undefined);
+    get isQuickAccessEnabled(): boolean;
+    set clientIdentifier(value: string | undefined);
+    get clientIdentifier(): string | undefined;
+    set licenseKey(value: string | undefined);
+    get licenseKey(): string | undefined;
+    set baseUrl(value: string | undefined);
+    get baseUrl(): string | undefined;
+    set isPoiDetailsEnabled(value: boolean | undefined);
+    get isPoiDetailsEnabled(): boolean;
+    set siteInternalIdentifier(value: string | undefined);
+    get siteInternalIdentifier(): string | undefined;
+    set buildingInternalIdentifier(value: string | undefined);
+    get buildingInternalIdentifier(): string | undefined;
+    set levelIndex(value: number | undefined);
+    get levelIndex(): number | undefined;
+    set levelExternalIdentifier(value: string | undefined);
+    get levelExternalIdentifier(): string | undefined;
+    set startLevelIndex(value: number | undefined);
+    get startLevelIndex(): number | undefined;
+    set destinationLevelIndex(value: number | undefined);
+    get destinationLevelIndex(): number | undefined;
+    set navigationStartPoi(value: string | undefined);
+    get navigationStartPoi(): string | undefined;
+    set siteExternalIdentifier(value: string | undefined);
+    get siteExternalIdentifier(): string | undefined;
+    set navigationDestinationPoi(value: string | undefined);
+    get navigationDestinationPoi(): string | undefined;
+    set buildingExternalIdentifier(value: string | undefined);
+    get buildingExternalIdentifier(): string | undefined;
+    set highlightPoiIdentifier(value: string | undefined);
+    get highlightPoiIdentifier(): string | undefined;
+    set highlightPointLng(value: number | undefined);
+    get highlightPointLng(): number | undefined;
+    set highlightPointLat(value: number | undefined);
+    get highlightPointLat(): number | undefined;
+    set language(value: string | undefined);
+    get language(): string;
+    set languageList(value: string[] | undefined);
+    get languageList(): string[];
+    set container(value: string | number | undefined);
+    get container(): string;
+    set mode(value: string | undefined);
+    get mode(): string;
+    set deviceIdentifierForAnalytics(value: string | undefined);
+    get deviceIdentifierForAnalytics(): string | undefined;
+    set personaIdentifier(value: string | undefined);
+    get analyticsCustomLaunchParams(): JsonObject | undefined;
+    set analyticsCustomLaunchParams(value: JsonObject | undefined);
+    get personaIdentifier(): string | undefined;
+    set quickAccessSelectionZoomLevel(value: number | undefined);
+    get quickAccessSelectionZoomLevel(): number | undefined;
+    set isAppBannerEnabled(value: boolean | undefined);
+    get isAppBannerEnabled(): boolean;
+    set pointrCloudToken(value: string | undefined);
+    get pointrCloudToken(): string | undefined;
+    isContainerNameValid(containerName: string): boolean;
+}
+
+type DataManagerOptions = Partial<Options> & {
+    validateSite?: Options["validateSite"];
+    validateBuilding?: Options["validateBuilding"];
+};
+interface RawConfigItem {
+    key?: string;
+    value: string;
+}
+interface BuildingConfiguration {
+    buildingInternalIdentifier: string;
+    buildingConfiguration: JsonObject;
+}
+interface SiteConfiguration {
+    siteInternalIdentifier: string;
+    siteConfiguration: JsonObject;
+    buildings: BuildingConfiguration[];
+}
+interface StyleSpriteItem {
+    id: string;
+    url: string;
+}
+declare class DataManager {
+    options: DataManagerOptions;
+    networkCoordinator: NetworkCoordinator;
+    constructor(options?: DataManagerOptions);
+    loadConfigAndSiteData(): Promise<unknown[]>;
+    loadData(siteInternalIdentifier?: string): Promise<unknown[]>;
+    downloadStyleJson(styleJsonUrl: string): Promise<unknown>;
+    loadConfigurations(): Promise<unknown>;
+    parseConfigurations(response: unknown): {
+        globalConfiguration: JsonObject;
+        sites: SiteConfiguration[];
+    };
+    parseGlobalConfiguration(clientConfig: RawConfigItem[] | undefined | null): JsonObject;
+    parseSitesConfiguration(sites: Array<{
+        siteIdentifier: string;
+        configurations?: RawConfigItem[];
+        buildings?: Array<{
+            buildingIdentifier: string;
+            configurations?: RawConfigItem[];
+        }>;
+    }> | undefined | null): SiteConfiguration[];
+    parseBuildingsConfiguration(buildings: Array<{
+        buildingIdentifier: string;
+        configurations?: RawConfigItem[];
+    }> | undefined | null): BuildingConfiguration[];
+    parseConfiguration(configs?: RawConfigItem[] | null): JsonObject;
+    processConfigurations(configurations: {
+        globalConfiguration: any;
+        sites: any[];
+    }): string;
+    setStorageAnalytics(globalConfig: any): void;
+    setStorageBanner(globalConfig: any): void;
+    setStorageUI(globalConfig: any): void;
+    setSiteConfiguration(sites: any[] | undefined): void;
+    processStyleJson(styleJson: unknown): void;
+    buildFeaturedPoiSpriteUrl(siteInternalIdentifier: string): string;
+    getDefaultSpriteUrl(): string | undefined;
+    buildSiteSprites(siteInternalIdentifier: string): StyleSpriteItem[];
+    updateSiteSprite(map: {
+        getSprite?: () => StyleSpriteItem[];
+        removeSprite?: (id: string) => void;
+        addSprite?: (id: string, url: string) => void;
+    } | undefined, siteInternalIdentifier: string): void;
+    validateStyleJsonUrl(styleJsonUrl: string | any): string;
+    handleConfigurationError(error: {
+        errorMsg?: string;
+        errorTitle?: string;
+    } | string): never;
+    loadClient(): Promise<unknown>;
+    loadPersonas(): Promise<unknown>;
+    loadSiteCDNVersion(siteInternalIdentifier: string): Promise<void>;
+    loadMapBaseUrl(): Promise<string>;
+    loadSites(): Promise<unknown>;
+    loadSitesWithBuildings(buildings: any): Promise<unknown>;
+    mapSitesResponse(response: any, buildings: any): any[];
+    mapBuildingsForSite(buildings: any, siteFeature: any): any[] | undefined;
+    mapLevelsForBuilding(buildings: any, buildingFeature: any, siteFeature: any): any[] | undefined;
+    processSites(sites: any[]): any[];
+    encodeSitesAndExtractBuildings(sites: any[]): any[];
+    validateAndStoreSites(sites: any[], buildings: any[]): void;
+    handleSitesError(errorMessage: {
+        errorMsg?: string;
+    } | string): never;
+    handleBuildingsError(errorMessage: {
+        errorMsg?: string;
+    } | string): never;
+    loadFeatureTypes(): Promise<unknown>;
+    loadPois(siteInternalIdentifier: string): Promise<Record<string, Poi>>;
+    isPoiVisibleForPersonaKey(poi: Poi, selectedPersonaKey: string): boolean;
+    loadNavigation(startObject: unknown, destinationObject: unknown, navigationMode: string, personaIdentifier?: string): Promise<RouteDataResponse>;
+    postEvent(analyticsEventUploadUrl: string, eventData: unknown, sasToken: string): Promise<unknown>;
+    setCategories(categoriesJSON?: string | null): void;
+}
+
+interface AnalyticsConfiguration {
+    analyticsEventSasPolicyName?: string;
+    analyticsEventSasPrimaryKey?: string;
+    analyticsEventUploadUrl?: string;
+    webSessionTimeout?: number;
+    webMapSessionTimeout?: number;
+    isEnabled?: string;
+}
+interface AnalyticsEventExtraData {
+    actionStatus?: string;
+    resultCount?: number | null;
+    searchTerm?: string | null;
+    sid?: string | null;
+    bid?: string | null;
+    originates?: string | null;
+    poiInteracted?: {
+        fid?: string;
+    } | null;
+    params?: JsonObject | null;
+}
+declare class AnalyticsManager {
+    options: Options;
+    optionsJson: JsonObject;
+    appId: string | null;
+    deviceId: string | null;
+    sessionId: string | null;
+    isFirstSession: boolean;
+    isSessionInProgress: boolean;
+    analyticsEventSasPolicyName: string | undefined;
+    analyticsEventSasPrimaryKey: string | undefined;
+    analyticsEventUploadUrl: string | undefined;
+    webSessionTimeout: number | undefined;
+    webMapSessionTimeout: number | undefined;
+    isAnalyticsEnabled: boolean;
+    isRatingPopupEnabled: boolean;
+    userIdleInterval: ReturnType<typeof setInterval> | undefined;
+    idleTimeInSeconds: number;
+    totalTimeInSeconds: number;
+    sasToken: string | undefined;
+    language: Language | null;
+    userAgent: string;
+    analyticsVersion: string;
+    osVersion: string | null;
+    dataManager: DataManager;
+    eventsToSendList: JsonObject;
+    minSecondsBeforeRatingPopup: number;
+    constructor(options: Options);
+    setAnalyticsConfiguration(configuration: AnalyticsConfiguration): Promise<void>;
+    postListToServer(): void;
+    createSharedAccessToken(): Promise<string | undefined>;
+    setSessionId(): void;
+    setDeviceId(): void;
+    setLanguage(language: Language | null): void;
+    userActivityTimer(): void;
+    checkSessionStart(): void;
+    registerSessionEvents(): void;
+    detectOS(): string | null;
+    getParams(eventType: string, actionStatus: string | null | undefined): JsonObject | undefined;
+    createDeepLinkParams(): string;
+    getActionStatus(action: string, actionStatus: string | undefined): string | null;
+    postEvent(eventType: string, extraData?: AnalyticsEventExtraData): void;
+    removeEmpty<T extends JsonObject>(obj: T): T;
+    prepareDataForEvent(eventType: string, actionStatus: string | null, extraData?: AnalyticsEventExtraData): JsonObject;
+}
+
+interface TranslationDictionary {
+    code: string;
+    [viewKey: string]: Record<string, string> | string;
+}
+declare class Translation {
+    private static _translations;
+    private readonly _language;
+    private readonly _primaryDictionary;
+    private readonly _defaultDictionary;
+    static getAvailableLanguages(): string[];
+    constructor(languageObj?: Language);
+    str(key: string, dynamicVariables?: Record<string, string>): string;
+    getTranslationTextWithKey(className: string, betterKey: string): string;
+    replaceDynamicVariablesWithValue(text: string | undefined, dynamicVariables: Record<string, string> | undefined): string;
+    get language(): Language;
+    availableLanguages(): Language[];
+    static getTranslations(code: string): TranslationDictionary | undefined;
+    private static loadTranslations;
+}
+
+interface LevelDict {
+    externalIdentifier?: string;
+    levelIndex: number;
+    levelLongTitle?: string;
+    levelShortTitle?: string;
+    properties?: JsonObject;
+}
+declare class Level {
+    levelIndex: number;
+    levelLongTitle: string;
+    levelShortTitle: string;
+    properties?: JsonObject;
+    externalIdentifier?: string;
+    constructor(dict: LevelDict);
+    static isValid(dict: LevelDict | undefined | null): boolean;
+}
+
+interface BuildingDict {
+    buildingTitle: string;
+    buildingExternalIdentifier: string;
+    buildingInternalIdentifier: string;
+    siteInternalIdentifier: string;
+    geometry?: GeoJSON.Geometry;
+    levels?: LevelDict[];
+    properties?: JsonObject;
+}
+declare class Building {
+    buildingTitle: string;
+    buildingExternalIdentifier: string;
+    buildingInternalIdentifier: string;
+    siteInternalIdentifier: string;
+    geometry?: GeoJSON.Geometry;
+    levels?: Level[];
+    properties?: JsonObject;
+    constructor(dict: BuildingDict);
+    static isValid(dict: Partial<BuildingDict> | undefined | null): boolean;
+}
+
+interface SiteDict {
+    siteTitle: string;
+    siteInternalIdentifier: string;
+    siteExternalIdentifier: string;
+    properties?: JsonObject;
+    geometry: GeoJSON.Geometry;
+    buildings: Building[];
+}
+declare class Site {
+    siteTitle: string;
+    siteInternalIdentifier: string;
+    siteExternalIdentifier: string;
+    properties: JsonObject;
+    geometry: GeoJSON.Geometry;
+    buildings: Building[];
+    constructor(dict: SiteDict);
+    static isValid(dict: Partial<SiteDict> | undefined | null): boolean;
+}
+
+declare class BaseView {
+    [key: string]: any;
+    events: {
+        viewShown: string;
+        viewHidden: string;
+        draggedUpwards: string;
+    };
+    isHidden: boolean;
+    isReadyToShow: boolean;
+    isDraggingInProgress: boolean;
+    isDragging: boolean;
+    constructor(options?: Options);
+    populate(...args: any[]): boolean;
+    createUi(): void;
+    applyShellAccessibilityLabels(): void;
+    applyAccessibilityLabels(): void;
+    touchStartHandler(event: any): void;
+    touchEndHandler(event: any): void;
+    createUiWrapper(): void;
+    show(): void;
+    hide(): boolean;
+    setTranslation(translation: Translation | undefined): void;
+    getLanguage(): any;
+    getLanguageCode(): any;
+    onDrag(): void;
+}
+
+declare class BaseViewController {
+    [key: string]: any;
+    get buildings(): Building[] | undefined;
+    get sites(): Site[] | undefined;
+    get currentSite(): Site | undefined;
+    set currentSite(site: Site | undefined);
+    get currentBuilding(): Building | undefined;
+    set currentBuilding(building: Building | undefined);
+    get currentLevel(): Level | undefined;
+    set currentLevel(level: Level | undefined);
+    populate(...args: any[]): boolean;
+    createUi(): void;
+    showView(): void;
+    hideView(): void;
+    getView(): BaseView;
+    setTranslation(translation: Translation | undefined): void;
+}
+
+type MarkerFeature = MapPointFeature;
+interface MarkerOptions {
+    minzoom?: number;
+    maxzoom?: number;
+    element?: HTMLElement;
+    offset?: [number, number];
+    [key: string]: JsonValue | HTMLElement | [number, number] | undefined;
+}
+declare class Marker {
+    id: string;
+    feature: MarkerFeature;
+    options: MarkerOptions;
+    minzoom: number;
+    maxzoom: number;
+    isVisible: boolean;
+    marker: maplibregl.Marker;
+    constructor(feature: MarkerFeature, html: HTMLElement | null, options?: MarkerOptions);
+    addMarker(map: maplibregl.Map): void;
+    removeMarker(): void;
+    setVisibility(isVisible: boolean): void;
+    addPopupToMarker(popupObject: {
+        popup: maplibregl.Popup;
+    }, map: maplibregl.Map): void;
+}
+
+type PopupFeature = MapPointFeature;
+interface PopupOptions {
+    closeButton?: boolean;
+    maxWidth?: string;
+    [key: string]: JsonValue;
+}
+declare class Popup {
+    feature: PopupFeature;
+    options: PopupOptions;
+    popup: maplibregl.Popup;
+    constructor(feature: PopupFeature, content: string, options?: PopupOptions);
+    addPopup(map: maplibregl.Map): void;
+    removePopup(): void;
+}
+
+type PoiDict = Record<string, Poi>;
+declare class PoiManager {
+    dataManager: DataManager;
+    constructor(options?: Options);
+    get(poiId: string, site?: {
+        siteInternalIdentifier?: string;
+    } | null): Promise<Poi | undefined>;
+    getPoiByExternalId(poiEid: string, site?: {
+        siteInternalIdentifier?: string;
+    } | null): Promise<Poi | undefined>;
+    getPoisBySite(siteInternalIdentifier?: string): Promise<PoiDict | undefined>;
+    getPoisAsGeoJson(siteInternaldentifier: string): Promise<{
+        type: "FeatureCollection";
+        features: Array<{
+            type: "Feature";
+            properties: any;
+            geometry: any;
+        }>;
+    }>;
+    getPoisAsFeatures(siteInternaldentifier: string): Promise<Feature[]>;
+    setPoisForWorldMode(pois: WorldModePoi[]): void;
+    getPoisForWorldMode(): WorldModePoi[] | undefined;
+    includes(poi: {
+        properties: {
+            fid: string;
+            sid: string;
+        };
+    }): Promise<boolean>;
+    search(query: string, buildingId?: string, siteId?: string | number): Promise<WorldModePoi[] | Poi[]>;
+}
+
+interface BuildingModelDescriptor {
+    buildingInternalIdentifier: string;
+    siteInternalIdentifier?: string;
+    name?: string;
+    url: string;
+    latitude: number;
+    longitude: number;
+    rotation: number;
+    scale: number;
+    brightness: number;
+}
+interface ModelInstance {
+    buildingInternalIdentifier: string;
+    siteInternalIdentifier?: string | undefined;
+    url: string;
+    scene: THREE.Scene;
+    root: THREE.Object3D;
+    longitude: number;
+    latitude: number;
+    rotation: number;
+    scale: number;
+    translation: THREE.Matrix4;
+    local: THREE.Matrix4;
+}
+interface ModelTemplate {
+    scene: THREE.Group;
+    refCount: number;
+}
+interface BuildingModelsCustomLayer {
+    id: string;
+    type: "custom";
+    renderingMode: "3d";
+    map?: maplibregl.Map;
+    camera: THREE.Camera;
+    renderer?: THREE.WebGLRenderer;
+    antialias: boolean;
+    loader?: GLTFLoader;
+    loadedTemplates: Map<string, ModelTemplate>;
+    pendingTemplates: Map<string, Promise<THREE.Group>>;
+    loadedBuildingIds: Set<string>;
+    instances: ModelInstance[];
+    minZoom: number;
+    maxZoom: number;
+    hidden: boolean;
+    hiddenBuildingIds: Set<string>;
+    lastProjectionMatrix: THREE.Matrix4;
+    contextLost: boolean;
+    scratchMatrix: THREE.Matrix4;
+    onAdd(map: maplibregl.Map, gl: WebGLRenderingContext): void;
+    onRemove(map: maplibregl.Map, gl: WebGLRenderingContext): void;
+    render(gl: WebGLRenderingContext, args: {
+        defaultProjectionData: {
+            mainMatrix: number[];
+        };
+    }): void;
+    setHidden(hidden: boolean): void;
+    setHiddenBuildings(ids: Set<string>): void;
+    setZoomRange(minZoom: number, maxZoom: number): void;
+    isInstanceRenderable(instance: ModelInstance): boolean;
+    pickBuildingAt(screenX: number, screenY: number): string | undefined;
+    addModels(models: BuildingModelDescriptor[]): void;
+    removeModelsForSite(siteInternalIdentifier: string): void;
+}
+
+interface MapViewRoutePoint {
+    lon: number;
+    lat: number;
+    class?: string;
+    markerIconName?: string;
+}
+interface MapLibreMapMouseEvent {
+    point: {
+        x: number;
+        y: number;
+    };
+    lngLat: {
+        lng: number;
+        lat: number;
+        toFixed: (n: number) => string;
+    };
+    originalEvent?: {
+        clientX: number;
+        clientY: number;
+        which?: number;
+    };
+}
+declare class MapView extends BaseView {
+    options: Options;
+    poiManager: PoiManager | undefined;
+    analyticsManager: AnalyticsManager | undefined;
+    translation: Translation | undefined;
+    events: BaseView["events"] & {
+        levelChanged: string;
+        zoom: string;
+        zoomChanged: string;
+        mapIdle: string;
+        mapClicked: string;
+        mapLongClicked: string;
+        locationMarked: string;
+        poiClicked: string;
+        poiUnhighlighted: string;
+        poiHighlighted: string;
+        mapReady: string;
+        mapMoveStart: string;
+        mapMoveEnd: string;
+        currentSiteChanged: string;
+        currentBuildingChanged: string;
+        routesShown: string;
+        exitClicked: string;
+        infoClicked: string;
+    };
+    highlightedPois: Set<Poi>;
+    currentZoom: number;
+    animationInterval: ReturnType<typeof setInterval> | undefined;
+    isWheeling: boolean;
+    isZoomInteractionStarted: boolean;
+    isNavigationActive: boolean;
+    exitButtonId: string;
+    exitButtonEl: string;
+    infoButtonId: string;
+    infoButtonEl: string;
+    targetEl: string;
+    topRightEl: string;
+    rootEl: string;
+    map: maplibregl.Map | undefined;
+    clickStartTime: number | undefined;
+    clickEndTime: number | undefined;
+    isLongPress: boolean;
+    isMapMoving: boolean;
+    isClickEventStartedOnMap: boolean;
+    movingHumanMarker: maplibregl.Marker | null;
+    startTransitionMarker: maplibregl.Marker | null;
+    destinationTransitionMarker: maplibregl.Marker | null;
+    destinationMarker: maplibregl.Marker | null;
+    mapLevelIndex: number | undefined;
+    buildingModelsLayer: BuildingModelsCustomLayer | undefined;
+    onBuilding3DModelsWebGLUnavailable: (() => void) | undefined;
+    private isMapReadyEmitted;
+    constructor(options: Options, poiManager: PoiManager | undefined, translation: Translation, analyticsManager: AnalyticsManager | undefined);
+    createUi(): void;
+    applyAccessibilityLabels(): void;
+    buildMapRegionAriaLabel(): string;
+    updateMapRegionAriaLabel(): void;
+    private resolveSiteNameForAria;
+    private resolveBuildingNameForAria;
+    private resolveLevelNameForAria;
+    private resolveLevelForAria;
+    populate(): boolean;
+    onMapLoad(): void;
+    private ensureMapReady;
+    addBuildingModels(models: BuildingModelDescriptor[], minZoom?: number, maxZoom?: number): void;
+    initBuildingModelsLayer(minZoom?: number, maxZoom?: number, onWebGLUnavailable?: () => void): void;
+    removeBuildingModelsLayer(): void;
+    addBuildingModelsForSite(models: BuildingModelDescriptor[]): void;
+    setBuildingModelsHidden(hidden: boolean): void;
+    setHiddenBuildingModels(buildingIds: Set<string>): void;
+    pickBuildingModelAt(screenX: number, screenY: number): string | undefined;
+    hideMapTilerAttribution(): void;
+    handleZoomInteraction(): void;
+    handleZoomEndInteraction(): void;
+    handleMapClick(e: MapLibreMapMouseEvent): void;
+    clickStartEventHandler: () => void;
+    clickEndEventHandler: (e: MapLibreMapMouseEvent) => void;
+    handleWheel(): void;
+    handleMapMoveStart(e: any): void;
+    handleMapMoveEnd(e: any): void;
+    handleMapIdle(e: any): void;
+    handleMapError(e: any): void;
+    handleMapLongClick(e: MapLibreMapMouseEvent): void;
+    setUserInteractionEnabled(isEnabled: boolean): void;
+    scrollTo(latlng: [number, number] | LatLng, zoom?: number, offset?: [number, number]): void;
+    fitBounds(latlngArr: LatLng[]): void;
+    showLayer(layerId: string): void;
+    hideLayer(layerId: string): void;
+    setLayerZoomRange(layerId: string, minZoom: number, maxZoom: number): void;
+    setPaintProperty(layerId: string, property: string, value: any): void;
+    setLayoutProperty(layerId: string, property: string, value: any): void;
+    setFilter(layerId: string, expression: any): void;
+    getAllLayers(): any[];
+    zoomTo(level: number): void;
+    zoomIn(): void;
+    zoomOut(): void;
+    getZoom(): number | undefined;
+    highlightFeatures(highlightedFeatures: Feature[]): void;
+    unhighlightFeatures(highlightedFeatures: Feature[]): void;
+    hideDestinationSymbol(destinationObject: Feature | null | undefined): void;
+    showDestinationSymbol(destinationObject: Feature | null | undefined): void;
+    setTranslationByLanguageCode(code: string | undefined, layerId: string): void;
+    setMaxBounds(bounds: number[][]): void;
+    addMarker(feature: any, htmlElement?: HTMLElement, options?: any): Marker;
+    createMarker(feature: any, htmlElement?: HTMLElement, options?: any): Marker;
+    addMarkerToMap(marker: Marker): void;
+    addPopup(feature: any, content: string | HTMLElement, options?: any): Popup;
+    createPopup(feature: any, content: string | HTMLElement, options?: any): Popup;
+    setCursor(cursor: string): void;
+    displayRoute(routeData: MapViewRoutePoint[] | undefined, type?: string): void;
+    resize(): void;
+    hideRoute(): void;
+    setExitButtonText(text: string): void;
+    setExitButtonStatus(shouldEnable: boolean): void;
+    addSource(id: string, geojsonData: any, cluster?: boolean): any;
+    getSource(sourceId: string): any;
+    addLayer(layer: any, aboveLayerId?: string): any;
+    getLayer(layerId: string): any;
+    bringMainTypeLayerToFront(mainType: string): void;
+    addImage(imageId: string, imageUrl: string): Promise<void>;
+    removeLayer(layerId: string): void;
+    removeSource(sourceId: string): void;
+    updateSourceData(sourceId: string, data: any): void;
+    getPitch(): number | undefined;
+    getBearing(): number | undefined;
+    setPitch(pitch: number): void;
+    setBearing(bearing: number): void;
+    setCenter(center: [number, number]): void;
+    setZoom(zoom: number): void;
+    hideInfoButton(): void;
+    showInfoButton(): void;
+    removeMarker(type: string): void;
+    addTransitionMarker(point: MapViewRoutePoint, type: "start" | "destination"): void;
+    addDestinationMarker(point: MapViewRoutePoint): void;
+    moveLayer(layerId: string, beforeLayerId?: string): void;
+}
+
+type MapLibreFilter = JsonValue[];
+interface LayerOptions {
+    paint?: JsonObject;
+    layout?: JsonObject;
+    minzoom?: number;
+    maxzoom?: number;
+    [key: string]: JsonValue;
+}
+declare abstract class Layer {
+    type: string;
+    id: string;
+    sourceId: string;
+    filter: MapLibreFilter | null;
+    maxzoom: number;
+    minzoom: number;
+    options: {
+        paint: JsonObject;
+        layout: JsonObject;
+    };
+    constructor(options?: LayerOptions, filter?: MapLibreFilter | null, layoutProperties?: string[], paintProperties?: string[]);
+    convertToMapJson(): JsonObject;
+}
+
+interface MapViewControllerClusterOptions {
+    fonts?: string[];
+    textSize?: number;
+    circleColor?: any;
+    circleRadius?: any;
+}
+interface MapViewControllerBuilding {
+    buildingInternalIdentifier: string;
+    buildingExternalIdentifier?: string;
+    buildingTitle?: string;
+    geometry?: any;
+    properties?: JsonObject;
+}
+declare class MapViewController extends BaseViewController {
+    options: Options;
+    dataManager: DataManager;
+    SITE_ZOOM_LEVEL: number;
+    BUILDING_ZOOM_LEVEL: number;
+    MIN_ZOOM_LEVEL: number;
+    MAX_ZOOM_LEVEL: number;
+    buildingOutlineLayers: string[];
+    poiManager: PoiManager | undefined;
+    analyticsManager: AnalyticsManager | undefined;
+    translation: Translation;
+    view: MapView;
+    highlightedPoiObjects: Poi[];
+    customPointMarkerList: Marker[];
+    addedMarkerList: Marker[];
+    isIdleCalculationDisabled: boolean;
+    cachedHighlightedPoiObjects: Poi[];
+    highlightedLevelIndex: number | undefined;
+    highlightedBuildingInternalIdentifiers: string[];
+    layersBeforeUpdatingMinZoom: any[];
+    levelIndex: number | undefined;
+    poiAttributeCache: Record<string, any>;
+    filteredPoiSet: Set<string>;
+    mapMainTypeToFeatureList: Record<string, any[]>;
+    dynamicPois: any[];
+    styledPoiObjects: Poi[];
+    hiddenPoisByMainType: Map<string, Set<string>>;
+    _originalLayerFilters: Map<string, any>;
+    poisOfCategory: Poi[] | undefined;
+    maxZoomOfOutline: number | undefined;
+    highlightedSiteInternalIdentifier: string | undefined;
+    buildingModelsBySite: Map<string, BuildingModelDescriptor[]>;
+    shouldHideBuildingModels: boolean;
+    building3DModelsActive: boolean;
+    constructor(options: Options, poiManager: PoiManager, translation: Translation, analyticsManager: AnalyticsManager);
+    populate(): boolean;
+    setLevel(levelIndex: number | undefined): void;
+    clearLevel(): void;
+    filterExpressionReferencesProperty(expression: any, property: string): boolean;
+    stripRuntimeFilters(originalFilter: any): any;
+    buildLevelFilter(originalFilter: any, extraFilters: any[]): any[];
+    updateLayersForCurrentLevel(levelIndex: number | undefined): void;
+    addTransitionMessageLayer(transition: {
+        lat: number;
+        lon: number;
+    }, isStartInsideBuildings: boolean, buildingToGo: MapViewControllerBuilding | undefined): void;
+    removeTransitionMessageLayer(): void;
+    addPoiOrderNumbers(poisOfCategory: Poi[]): void;
+    removePoiOrderNumbers(): void;
+    cacheOriginalLayerFilter(layerId: string): void;
+    setSelectedPoiLayer(poi: Poi | undefined): void;
+    zoomTo(level: number): void;
+    setUserInteractionEnabled(isEnabled: boolean): void;
+    scrollTo(latlng: LatLng, zoom: number | undefined, shouldDisableBuildingAndSiteUpdate?: boolean, offset?: [number, number]): void;
+    scrollToSite(siteId: string): void;
+    scrollToBuilding(buildingId: string): void;
+    scrollToBuildingByPoi(poi: Poi, zoomToAddBuildingLevel?: number): void;
+    getBottomMapObstructionHeight(): number;
+    getMapPaddingForPoiCards(): {
+        top: number;
+        bottom: number;
+        left: number;
+        right: number;
+    };
+    resetMapPadding(): void;
+    centerPoiInVisibleMapArea(poi: Poi, options?: {
+        duration?: number;
+        pitch?: number;
+        zoom?: number;
+    }): void;
+    isPoiOnScreen(poi: Poi): boolean;
+    scrollToPoi(poi: Poi, zoomToAddBuildingLevel?: number, offset?: [number, number], shouldKeepZoomLevel?: boolean): void;
+    fitBounds(latlngArr: LatLng[]): void;
+    zoomIn(): void;
+    zoomOut(): void;
+    highlightPoi(poi: Poi): void;
+    showAlwaysFillLayers(): void;
+    revertShowAlwaysFillLayers(): void;
+    unhighlightPoi(id: string): void;
+    unhighlightAllPois(): void;
+    setPtrLayersZoomRangeForHighlight(minzoom?: number): void;
+    highlightCachedPois(): void;
+    clearCachedHighlightedPois(): void;
+    removeFromCachedHighlightedPois(poi: Poi): void;
+    addFiltersForZoomRanges(): void;
+    removeFilterForZoomRange(): void;
+    resetMarkersForLevel(): void;
+    MapView_onMapReady: () => void;
+    MapView_onCurrentSiteChangedForModels: (data: {
+        oldSite?: {
+            siteInternalIdentifier?: string;
+        };
+        newSite?: {
+            siteInternalIdentifier?: string;
+        };
+    }) => void;
+    areBuilding3DModelsActive(): boolean;
+    fallbackToBuildingOutlinesFor3DModels(): void;
+    removeInvalidBuilding3DModels(): void;
+    collectBuildingModels(): BuildingModelDescriptor[];
+    collectBuildingModelsBySite(): Map<string, BuildingModelDescriptor[]>;
+    resolveBuildingModelUrl(url: string): string;
+    MapView_onZoomChanged: (zoom: number) => void;
+    initSiteBuildingOutlines(): void;
+    hidePtrLayersExceptOutlines(): void;
+    showLayer(layer: {
+        id: string;
+    }): void;
+    hideLayer(layer: {
+        id: string;
+    }): void;
+    updateBuildingIfOptionSet(): boolean;
+    updateSiteIfOptionSet(): void;
+    updateMapTiles(siteInternalIdentifier: string): Promise<void>;
+    scrollToAllSites(): void;
+    MapView_onPoiHighlighted: (poi: Poi) => void;
+    updateHighlightedBuildingsForWholeSite(): void;
+    MapView_onPoiUnhighlighted: () => void;
+    MapView_onExitClicked: () => void;
+    updateCurrentSiteAndBuilding(): void;
+    handleSiteChange(zoom: number): void;
+    handleWorldModeForSiteCalculation(): void;
+    handleSiteModeForSiteCalculation(): void;
+    isZoomWithinSiteMode(): boolean;
+    setMaxBounds(bounds: [number, number, number, number] | null): void;
+    restrictMapTo10x10Km(): void;
+    unrestrictMap(): void;
+    handleBuildingChange(zoom: number): void;
+    resetCurrentBuildingOnSiteMode(): void;
+    updateCurrentBuildingOnBuildingMode(): void;
+    updateBuildingForNavigation(): void;
+    getNewCurrentBuilding(buildings: MapViewControllerBuilding[]): MapViewControllerBuilding | undefined;
+    setNewCurrentBuilding(newCurrentBuilding: MapViewControllerBuilding | undefined): void;
+    updateCurrentBuilding(buildingId: string): void;
+    updateCurrentSite(siteId: string): void;
+    setTranslation(translation: Translation): void;
+    displayRoute(routeData: any, type: string): void;
+    makeAllSiteVisible(): void;
+    revertShowAllSites(): void;
+    applyBuildingModelsVisibilityState(): void;
+    hideRoute(): void;
+    hideDestinationSymbol(destinationObject: any): void;
+    showDestinationSymbol(destinationObject: any): void;
+    setExitButtonStatus(shouldEnable: boolean): void;
+    updateExitButtonText(): void;
+    resize(): void;
+    clearCustomPointsList(): void;
+    removeAllCustomPointMarkersFromMap(): void;
+    addCustomPointsBackForLevel(levelIndex: number | undefined): void;
+    addCustomPointMarker(feature: Feature | any, htmlElement?: HTMLElement): void;
+    addMarker(feature: Feature, htmlElement?: HTMLElement, options?: JsonObject): Marker | undefined;
+    removeMarkerFromLocation(feature: Feature | any): void;
+    removeMarkerForLevel(marker: Marker): void;
+    removeMarker(marker: Marker): void;
+    deleteAllMarkers(): void;
+    setVisibility(marker: Marker, isVisible: boolean): void;
+    removeAllMarkers(): void;
+    removeAllAddedMarkersFromMap(): void;
+    addAddedMarkersBackForLevel(levelIndex: number | undefined): void;
+    addPopup(feature: Feature, content: HTMLElement | string, options?: JsonObject): Popup | undefined;
+    removePopup(popup: Popup): void;
+    addPopupToMarker(marker: Marker, popup: Popup): void;
+    addImage(imageId: string, imageUrl: string): Promise<void>;
+    addLayer(layer: Layer, clusterOptions?: MapViewControllerClusterOptions, aboveLayerId?: string): Layer | Layer[];
+    updateFeatures(layer: Layer, data?: Feature[] | any[]): void;
+    makeSymbolLayersHiddenForQuickAccess(): void;
+    makeSymbolLayersVisible(): void;
+    removeLayer(layer: Layer): void;
+    getPitch(): number | undefined;
+    getBearing(): number | undefined;
+    setPitch(pitch: number): void;
+    setBearing(bearing: number): void;
+    setCenter(center: [number, number]): void;
+    setZoom(zoom: number): void;
+    fitBoundsForRoute(data: {
+        lat: number;
+        lon: number;
+    }[], maxZoom?: number): void;
+    getPaddingForRoute(): {
+        top: number;
+        bottom: number;
+        left: number;
+        right: number;
+    };
+    hideBuildingOutlines(): void;
+    showBuildingOutlines(): void;
+    destroyMap(): void;
+    hideInfoButton(): void;
+    showInfoButton(): void;
+    updatePoiStyles(poisArray: Poi[], dynamicExtrusionOpacity?: number): Promise<void>;
+    _updatePoiStylesInternal(poisArray: Poi[], dynamicExtrusionOpacity?: number): Promise<void>;
+    _convertPoisToFeatures(poisArray: Poi[]): any[];
+    _cachePoiIcons(poisArray: Poi[], map: any): Promise<void>;
+    _removeOldDynamicLayersAndSources(map: any, style: any): void;
+    _createDynamicLayers(style: any, map: any, dynamicExtrusionOpacity?: number): any[];
+    _createLayerForType(layerType: string, mainType: string, originalLayers: any[], style: any, map: any, dynamicExtrusionOpacity?: number): any;
+    _buildRuntimePaintOverrideExpression(originalValue: any, propertyKey: string, emptyFallback: any): any;
+    _configureLayerPaintAndLayout(newLayer: any, layerType: string, mainType: string, originalLayer: any, map: any, dynamicExtrusionOpacity?: number): void;
+    _processPoiProperties(): void;
+    _addPoiSources(map: any): void;
+    _addDynamicLayersToMap(map: any, dynamicLayers: any[]): void;
+    _hideOriginalPoisForDynamicStyling(): void;
+    getPoiSourceId(mainType: string): string;
+    getDynamicLayerId(layerId: string): string;
+    resetPoiStyles(poisArray: Poi[] | Poi): Promise<void>;
+    resetAllPoiStyles(): Promise<void>;
+    getDynamicPois(): any[];
+    hasDynamicStyling(poiId: string): boolean;
+    _buildPoiHideFilter(poiId: string): any[];
+    _isPoiHideFilter(filterItem: unknown, poiId?: string): boolean;
+    _isLegacyPoiHideFilter(filterItem: unknown, poiIds?: Set<string>): boolean;
+    _hasPoiHideFilterOnLayer(layer: any, poiId: string): boolean;
+    _addPoiHideFilterToLayer(layerId: string, layer: any, poiId: string): void;
+    _getOriginalPoiLayerIds(mainType: string): string[];
+    _removePoiHideFiltersFromLayer(layerId: string, layer: any, poiIds: Set<string>): void;
+    hidePois(poisArray: Poi[]): void;
+    showAllHiddenPois(): void;
+    reapplyHiddenPoiFilters(): void;
+    showPois(poisArray?: Poi[] | null): void;
+    getHiddenPoiIds(): Set<string>;
+    updatePoiExtrusionOpacity(extrusionOpacity: number): void;
+    updateMainTypeProperties(mainType: string, layerType: string, layoutProperties?: JsonObject, paintProperties?: JsonObject): void;
+    setZoomRangeForMainType(mainType: string, minZoom: number, maxZoom: number): void;
+    bringMainTypeLayerToFront(mainType: string): void;
+    moveMainTypeLayer(mainType: string, beforeMainType?: string): void;
+}
+
+interface SearchResultItem {
+    mainText?: string;
+    firstDescriptionText?: string;
+    secondaryDescriptionText?: string;
+    id?: string;
+    bid?: string;
+    mainType?: string;
+    subType?: string;
+    isFeatured?: boolean;
+    logo?: string;
+    [key: string]: JsonValue;
+}
+interface SearchResultGroup {
+    mainText: string;
+    items: SearchResultItem[];
+    descriptionText?: string;
+    mainType?: string;
+    subType?: string;
+    isFeatured?: boolean;
+    [key: string]: JsonValue;
+}
+interface LocationFilterBuilding {
+    buildingName: string;
+    buildingInternalIdentifier: string;
+    [key: string]: JsonValue;
+}
+interface CategoryFilterOption {
+    name: string;
+    [key: string]: JsonValue;
+}
+declare class SearchView extends BaseView {
+    translation?: Translation;
+    events: BaseView["events"] & {
+        searchSelected: string;
+        poiSelected: string;
+        searchCleared: string;
+        resultsPopulated: string;
+        querySearched: string;
+        routeButtonClicked: string;
+        goBackButtonClicked: string;
+        buildingFilterSelected: string;
+        categoryFilterSelected: string;
+        searchResultsShown: string;
+    };
+    options: Options;
+    placeholderValue: string | undefined;
+    searchViewId: string;
+    searchOuterBoxId: string;
+    searchInnerBoxId: string;
+    listHeaderContainerId: string;
+    inputId: string;
+    clearId: string;
+    searchIconId: string;
+    resultId: string;
+    searchResultsStatusId: string;
+    loadingCircleId: string;
+    goBackIconContainerId: string;
+    listHeaderId: string;
+    listHeaderIconId: string;
+    filterContainerId: string;
+    locationFilterId: string;
+    categoryFilterId: string;
+    keyboardPlaceHolderId: string;
+    dropdownContainerClass: string;
+    bottomUi: string;
+    uiId: string;
+    expanderClass: string;
+    draggableBoxId: string;
+    hoverableIconClass: string;
+    searchResultLogoClass: string;
+    clearEl: string;
+    searchIconEl: string;
+    inputEl: string;
+    resultEl: string;
+    searchResultsStatusEl: string;
+    loadingCircleEl: string;
+    listHeaderContainerEl: string;
+    listHeaderEl: string;
+    listHeaderIconEl: string;
+    filterContainerEl: string;
+    locationFilterEl: string;
+    categoryFilterEl: string;
+    searchOuterBoxEl: string;
+    bottomUiEl: string;
+    draggableBoxEl: string;
+    keyboardPlaceHolderEl: string;
+    uiEl: string;
+    goBackIconContainerEl: string;
+    expanderEl: string;
+    arrowContainerEl: string;
+    targetEl: string;
+    rootEl: string;
+    lang: {
+        code?: string;
+        title?: string;
+    } | undefined;
+    constructor(options?: Options, translation?: Translation);
+    createUi(): void;
+    initKeyboardNavigation(): void;
+    applyAccessibilityLabels(): void;
+    goBack(): void;
+    show(shouldDisplayList?: boolean): void;
+    showAllSearchView(shouldHideFilter?: boolean, shouldDisplayList?: boolean): void;
+    populate(): boolean;
+    populateQuery(query: string): void;
+    showClearEl(): void;
+    setQueryToInput(query?: string): void;
+    normalizePoiId(poiId: string | number | undefined | null): string | undefined;
+    itemMatchesPoiId(item: SearchResultItem, selectedPoiId: string | number): boolean;
+    findSelectedItemInGroup(items: SearchResultItem[], selectedPoiId: string | number): SearchResultItem | undefined;
+    expandSearchResultGroup(listItem: any, items: SearchResultItem[], expandableContent: any, expandableContainer: any, selectedPoiId?: string | number): void;
+    scrollSearchResultIntoView(target: HTMLElement | undefined): void;
+    populateResults(searchResults: SearchResultGroup[] | undefined, selectedPoiId?: string | number): void;
+    populateCategoryFilter(filterList: CategoryFilterOption[] | null | undefined, selectedFilterList: number[]): void;
+    populateLocationFilter(buildings: LocationFilterBuilding[], selectedBuildingId?: string): void;
+    createListItem(items: SearchResultItem[], expandableContent: any, expandableContainer: any, mainText: string): any;
+    removeExpandedClasses(): void;
+    createResultSubItems(items: SearchResultItem[], currentExpandableElement: any): void;
+    createFeaturedBadge(): any;
+    createListItemContent(container: any, mainText: string, descriptionText: string, count?: number, options?: {
+        isFeatured?: boolean;
+        logo?: string;
+    }): any;
+    appendHoverableIcon(listItemContent: any, mainText: string): void;
+    appendSearchResultLogo(listItemContent: any, logo: string, mainText: string, isFeatured?: boolean): void;
+    onRouteClicked(): void;
+    showResults(title?: string, icon?: string): void;
+    hide(): boolean;
+    clear(): void;
+    clearResult(): void;
+    emptyResults(): void;
+    announceSearchStatus(message: string): void;
+    clearFilters(): void;
+    clearLocationFilter(): void;
+    clearCategoryFilter(): void;
+    setStatus(options: ViewStatusOptions): void;
+    setHeader(headerText?: string, headerIcon?: string): void;
+    setPlaceholderText(placeholderText: string): void;
+    isLocationFilterVisible(): boolean;
+}
+
+interface GroupedSearchItem {
+    mainText: string;
+    mainType?: string;
+    subType?: string;
+    firstDescriptionText?: string;
+    secondaryDescriptionText?: string;
+    levelIndex?: number;
+    isFeatured?: boolean;
+    [key: string]: JsonValue;
+}
+interface GroupedSearchGroup {
+    mainText: string;
+    buildings: (string | undefined)[];
+    mainType?: string | undefined;
+    subType?: string | undefined;
+    items: GroupedSearchItem[];
+    descriptionText?: string;
+    isFeatured?: boolean;
+    [key: string]: JsonValue;
+}
+declare class SearchViewController extends BaseViewController {
+    options: Options;
+    poiManager: any;
+    translation: Translation;
+    analyticsManager: any;
+    view: SearchView;
+    selectedPoi: Poi | undefined;
+    enabled: boolean;
+    selectedCategoryFilters: number[];
+    selectedBuildingFilter: string | undefined;
+    query: string | undefined;
+    results: Poi[];
+    filteredResults: Poi[];
+    defaultPois: Poi[] | undefined;
+    buildingObjects: {
+        buildingName: string;
+        buildingInternalIdentifier: string;
+    }[];
+    categoryFilter: unknown;
+    eventTimeout: ReturnType<typeof setTimeout> | undefined;
+    lastQueryTime: number | undefined;
+    lang: {
+        code?: string;
+        title?: string;
+    } | undefined;
+    constructor(options: Options | undefined, poiManager: any, translation: Translation, analyticsManager: any);
+    populate(): boolean;
+    generateDefaultPois(): void;
+    setQueryToInput(): void;
+    populateQuery(query: string): void;
+    populateResults(): boolean;
+    populateLocationFilter(): void;
+    hideView(): void;
+    showView(): void;
+    showAllSearchView(): void;
+    hideResults(): void;
+    clearSelectedPoi(): void;
+    getSelectedPoi(): Poi | undefined;
+    clearSearch(): void;
+    SearchView_onPoiSelected: (poiId: string | number | undefined) => void;
+    SearchView_onSearchCleared: () => Promise<void>;
+    SearchView_onSearchSelected: (query: string) => void;
+    SearchView_onQuerySearched: (query: string) => Promise<void>;
+    SearchView_onBuildingFilterSelected: (selectedBuildingId: string | undefined) => void;
+    SearchView_onGoBackButtonClicked: () => void;
+    goBack(): void;
+    shouldDisplayCategories: () => boolean;
+    shouldDisplayList: () => boolean;
+    applyFilter(): void;
+    handleEmptyQuery(): Promise<void>;
+    setStatus(options: ViewStatusOptions): void;
+    updatePlaceholder(): void;
+    setTranslation(translation: Translation): void;
+    getItemDescriptionText(item?: GroupedSearchItem, includeBuilding?: boolean): string;
+    getGroupedDescriptionText(group: GroupedSearchGroup): string;
+    groupPoisByNameAndMainType(itemList: GroupedSearchItem[]): GroupedSearchGroup[];
+    reset(): void;
+}
+
+declare class CategoryListView extends BaseView {
+    events: BaseView["events"] & {
+        categorySelected: string;
+    };
+    categoryListViewId: string;
+    pointrSearchId: string;
+    draggableBoxId: string;
+    categoryItemClass: string;
+    categoryIconClass: string;
+    categoryIconWrapperClass: string;
+    categoryIconWrapperStyleClass: Record<number, string>;
+    categoryNameWrapperClass: string;
+    targetEl: string;
+    rootEl: string;
+    searchEl: string;
+    draggableBoxEl: string;
+    categoryListViewEl: string;
+    maxHeightForMobile: number;
+    options: Options;
+    constructor(options?: Options, translation?: any);
+    createUi(): void;
+    initKeyboardNavigation(): void;
+    private static isKeyboardFocusEvent;
+    refreshCategoryListKeyboard(activeIndex?: number): void;
+    applyAccessibilityLabels(): void;
+    populate(): boolean;
+    show(): void;
+    hide(): boolean;
+    setCategories(_categoryList: unknown[]): void;
+}
+
+declare class CategoryListViewController extends BaseViewController {
+    options: Options;
+    dataManager: DataManager;
+    view: CategoryListView;
+    constructor(options?: Options, translation?: Translation);
+    populate(): boolean;
+    showView(): void;
+    setCategories(categoryList: unknown[]): void;
+    getCategories(): unknown[] | undefined;
+    hideView(): void;
+    setTranslation(translation: Translation): void;
+}
+
+interface LevelSelectorLevelObj {
+    title: string;
+    hoverText: string;
+    [key: string]: JsonValue;
+}
+interface LevelSelectorSizeOptions {
+    shouldExpand: boolean;
+}
+type LevelSelectorStatusOptions = ViewStatusOptions;
+declare class LevelSelectorView extends BaseView {
+    events: BaseView["events"] & {
+        levelSelected: string;
+    };
+    levelClass: string;
+    levelTitleClass: string;
+    levelSelectorViewId: string;
+    tooltipId: string;
+    tooltipTextClass: string;
+    activeClass: string;
+    upArrowClass: string;
+    downArrowClass: string;
+    levelSelectorViewEl: string;
+    levelEl: string;
+    tooltipEl: string;
+    activeEl: string;
+    upArrowEl: string;
+    downArrowEl: string;
+    targetEl: string;
+    rootEl: string;
+    levelObjs: LevelSelectorLevelObj[];
+    expanded: boolean;
+    _currentViewLevel: number;
+    constructor(options?: Options, translation?: Translation);
+    get currentViewLevel(): number;
+    set currentViewLevel(index: number | undefined);
+    setArrows(index: number, shouldExpand: boolean): void;
+    setLevelSelectorSize(options: LevelSelectorSizeOptions): void;
+    private isLevelSelectorDisabled;
+    activateLevel(index: number): void;
+    clear(): void;
+    createUi(): void;
+    applyAccessibilityLabels(): void;
+    populate(levelObjs?: LevelSelectorLevelObj[] | null): boolean;
+    private refreshLevelTabStops;
+    private wireExpandedLevelTabStop;
+    private clearLevelTabStop;
+    private updateExpandedLevelOptionState;
+    setStatus(options: LevelSelectorStatusOptions): void;
+}
+
+interface LevelObjLike {
+    levelIndex: number;
+    levelShortTitle?: string;
+    levelLongTitle?: string;
+    properties?: {
+        name?: string;
+        shortName?: string;
+        [key: string]: JsonValue;
+    };
+    [key: string]: JsonValue;
+}
+declare class LevelSelectorViewController extends BaseViewController {
+    view: LevelSelectorView;
+    analyticsManager: AnalyticsManager | undefined;
+    translation: Translation | undefined;
+    enabled: boolean;
+    levelObjs: LevelObjLike[];
+    level: Level | undefined;
+    previousLevel: Level | undefined;
+    levelIndex: number | undefined;
+    constructor(options?: Options, translation?: Translation, analyticsManager?: AnalyticsManager);
+    populate(): boolean;
+    setLevel(levelIndex: number | undefined): void;
+    setTranslation(translation: Translation): void;
+    getLevel(): Level | undefined;
+    LevelSelectorView_onLevelSelected: (index: number) => void;
+    findViewLevelFromLevelIndex(levelIndex: number): number;
+    getLevelFromIndex(levelIndex: number): Level;
+    getLevelFromExternalIdentifier(levelExternalIdentifier: string): Level;
+    getLevelWithIndex(levelIndex: number): LevelObjLike | undefined;
+    setStatus(options: LevelSelectorStatusOptions): void;
+    setLevelSelectorSize(options: LevelSelectorSizeOptions): void;
+    show(): void;
+    hide(): void;
+}
+
+interface OpenHoursEntry {
+    day?: string | number;
+    open?: string;
+    close?: string;
+    [key: string]: JsonValue;
+}
+interface PoiDetailsButton {
+    title?: string;
+    url?: string;
+    iconUrl?: string;
+    type?: string;
+    [key: string]: JsonValue;
+}
+interface PoiDetailsDict {
+    name?: string;
+    levelTitle?: string;
+    buildingDescription?: string;
+    logo?: string;
+    rating?: number;
+    numberOfRatings?: number;
+    ratingMax?: number;
+    priceRange?: number;
+    openHours?: OpenHoursEntry[] | JsonObject;
+    images?: string[];
+    tags?: string[] | string;
+    description?: string;
+    buttons?: PoiDetailsButton[] | string;
+    isFeatured?: boolean;
+    [key: string]: JsonValue;
+}
+declare class PoiDetailsView extends BaseView {
+    options: Options;
+    translation: Translation;
+    events: BaseView["events"] & {
+        closeClicked: string;
+        routeButtonClicked: string;
+        accessibilityButtonClicked: string;
+        poiButtonClicked: string;
+        expanded: string;
+        minimized: string;
+    };
+    constructor(options?: Options, translation?: Translation);
+    shouldHandleBottomSheetDrag(): boolean;
+    attachSheetTouchMoveListener(): void;
+    detachSheetTouchMoveListener(): void;
+    handleSheetTouchMove(event: Event): void;
+    attachSheetTouchEndListeners(): void;
+    detachSheetTouchEndListeners(): void;
+    lockBottomSheetExpanded(): void;
+    handleSheetTouchEnd(event: Event): void;
+    snapBottomSheetFromDrag(releaseClientY: number): void;
+    createUi(): void;
+    applyAccessibilityLabels(): void;
+    applyAccessibilityRouteSwitch(translation?: Translation): void;
+    dismissPoiDetails(): void;
+    updateAccessibilityRouteLabel(): void;
+    populate(dict: PoiDetailsDict | undefined): boolean;
+    populatePoiName(name: string | undefined): void;
+    populateRating(rating: any, numberOfRatings: any, ratingMax: any): void;
+    isValidRating(rating: any): boolean;
+    getLocalizedRatingValues(rating: any, ratingMax: any, numberOfRatings: any): {
+        ratingLocale: any;
+        ratingMaxLocale: any;
+        numberOfRatingsLocale: any;
+    };
+    createRatingInfoElement(): any;
+    createRatingElement(ratingLocale: any, ratingTextBoxEl: any): any;
+    appendRatingMax(ratingEl: any, ratingMaxLocale: any, rating: any, ratingMax: any): void;
+    appendNumberOfRatings(ratingTextBoxEl: any, numberOfRatings: any, numberOfRatingsLocale: any): void;
+    simplifyNumberOfRatings(numberOfRatings: any): any;
+    populatePriceInfo(priceRange: any): void;
+    populateWorkingHourInfo(openHours: any): boolean;
+    getStatus(currentDate: any): string;
+    setRegionalTimeFormat(): void;
+    populateNextOpenCloseInfo(workingHourExpanderEl: any, status: any, currentDate: any): void;
+    ensureWorkingHoursTableStructure(): void;
+    populateTimeTable(workingHourExpanderEl: any): void;
+    populateImageCarousel(images: any): boolean;
+    generateFullScreenViewer(images: any): void;
+    handleFullScreenViewerOpen(images: any): void;
+    handleErrorOnImageLoad(): void;
+    getVisibleLoaderElement(): any;
+    displayErrorContent(): void;
+    populateThumbnailBullets(images: any): void;
+    addEventHandlers(): void;
+    removeEventHandlers(): void;
+    documentPointerdownHandler(event: any): void;
+    documentPointerupHandler(event: any): void;
+    documentPointercancelHandler(event: any): void;
+    documentPointermoveHandler(event: any): void;
+    documentArrowPressHandler(event: any): void;
+    pinchHandler(zoomRatio: any): void;
+    swipeHandler(swipe: any): void;
+    tapHandler(eventTarget: any): void;
+    updateCurrentImageOnFullscreen(): void;
+    resetFullscreenViewer(): void;
+    setFullScreenViewerUI(shouldShow: any): void;
+    populateTags(tags: any): boolean;
+    populateDescription(description: any): boolean;
+    isDescriptionOverflowing(): boolean;
+    updateReadMoreButtonVisibility(): void;
+    scheduleReadMoreButtonVisibilityUpdate(): void;
+    setupDescriptionResizeObserver(): void;
+    disconnectDescriptionResizeObserver(): void;
+    populateButtons(buttons: any): boolean;
+    show(): void;
+    hide(): boolean;
+    onRouteClicked(): void;
+    onAccessibilityClicked(): void;
+    setAccessibilityButtonStatus(status: any): void;
+    handleAccessibilityStatus(isAnimationActive: any): void;
+    isFsLightboxCloseTarget(target: EventTarget | null): boolean;
+    isFsLightboxChromeTarget(target: EventTarget | null): boolean;
+    setPoiDetailsInteractionBlocked(blocked: boolean): void;
+    openFullscreenViewerAt(index: number): void;
+    closeFullscreenViewer(): void;
+    wireFullscreenViewerCloseButton(): void;
+    setupSplideCarouselAccessibility(): void;
+    clearContent(): void;
+    formatTime(date: any): any;
+    setCanExpand(): void;
+    resetTouchDragState(): void;
+    isInteractiveElement(element: any): boolean;
+}
+
+declare class PoiDetailsViewController extends BaseViewController {
+    options: Options;
+    view: PoiDetailsView;
+    currentPoi: Poi | undefined;
+    translation: Translation;
+    constructor(options?: Options, translation?: Translation);
+    showView(): void;
+    populate(poi: any): boolean;
+    setTranslation(translation: Translation): void;
+    getCurrentPoi(): any;
+    PoiDetailsView_onCloseClicked: () => void;
+    setAccessibilityButtonStatus(isAccessible: boolean): void;
+}
+
+interface LoadingErrorLike {
+    errorTitle?: string;
+    errorMsg?: string;
+    [key: string]: JsonValue;
+}
+declare class LoadingView extends BaseView {
+    events: BaseView["events"] & {
+        errorShown: string;
+        errorHidden: string;
+        errorClosed: string;
+    };
+    options: Options;
+    error: LoadingErrorLike | undefined;
+    isPopup: boolean;
+    loadingViewId: string;
+    loadingStatusId: string;
+    errorId: string;
+    contentClass: string;
+    errorTitleId: string;
+    errorDescriptionId: string;
+    loadingId: string;
+    tryAgainButtonId: string;
+    splashScreenId: string;
+    brandedLogoContentId: string;
+    logoContainerId: string;
+    splashScreenTextId: string;
+    brandedLogoId: string;
+    mapId: string;
+    topLeftUiId: string;
+    errorModalId: string;
+    closeButtonId: string;
+    clientTitleId: string;
+    loadingStatusEl: string;
+    errorEl: string;
+    errorContentEl: string;
+    errorTitleEl: string;
+    targetEl: string;
+    loadingEl: string;
+    rootEl: string;
+    mapEl: string;
+    topLeftUiEl: string;
+    errorModalEl: string;
+    closeButtonEl: string;
+    tryAgainButtonEl: string;
+    splashScreenEl: string;
+    splashScreenTextEl: string;
+    brandedLogoEl: string;
+    clientTitleEl: string;
+    constructor(options?: Options, translation?: Translation);
+    createUi(): void;
+    applyAccessibilityLabels(): void;
+    applyErrorModalAccessibility(): void;
+    showSplashView(): void;
+    showError(error: LoadingErrorLike, isPopup: boolean): boolean;
+    hideError(): boolean;
+    toggleFullError(): void;
+    hideLoading(): boolean;
+    showLoading(): boolean;
+    hide(): boolean;
+    setTranslation(translation: Translation): void;
+}
+
+declare class LoadingViewController extends BaseViewController {
+    view: LoadingView;
+    constructor(options?: Options, translation?: Translation);
+    showLoading(): void;
+    hideLoading(): void;
+    showSplashView(): void;
+    showError(error: LoadingErrorLike, isPopup: boolean): void;
+    hideError(): void;
+    setTranslation(translation: Translation): void;
+}
+
+interface CssStyleRecord {
+    [key: string]: string;
+}
+declare class WatermarkView extends BaseView {
+    events: BaseView["events"] & {
+        visibilityChangeDetected: string;
+    };
+    watermarkId: string | undefined;
+    bottomLeftUiEl: string;
+    bottomUiEl: string;
+    targetEl: string;
+    mobileLogoEl: string;
+    rootEl: string;
+    observer: MutationObserver | null;
+    targetNode: Element | null;
+    watermarkNode: Element | null;
+    attributionText: string;
+    shouldHideText: boolean;
+    constructor(options?: Options, translation?: Translation);
+    createUi(): void;
+    applyAccessibilityLabels(): void;
+    show(): void;
+    generateRandomId(): string;
+    getWatermarkStyles(isMobile: boolean, shouldHideLogo: boolean): CssStyleRecord;
+    getImageStyles(isMobile: boolean): CssStyleRecord;
+    getDivStyles(): CssStyleRecord;
+    observeWatermark(): void;
+    private isNodeInsideWatermark;
+    handleChildListMutation(mutation: MutationRecord): void;
+    handleAttributeMutation(mutation: MutationRecord): void;
+    handleCharacterDataMutation(mutation: MutationRecord): void;
+    handleVisibilityChange(): void;
+    isOutOfViewport(el: Element): boolean;
+    getExpectedWidth(node: Element): number;
+    getExpectedHeight(node: Element, isParent: boolean): number;
+}
+
+declare class WatermarkViewController extends BaseViewController {
+    view: WatermarkView;
+    constructor(options?: Options, translation?: Translation);
+}
+
+type LanguageDict = Language;
+interface LanguageSelectorStatusOption {
+    shouldEnable: boolean;
+}
+declare class LanguageSelectorView extends BaseView {
+    events: BaseView["events"] & {
+        languageSelected: string;
+        expanded: string;
+        shrunk: string;
+    };
+    options: Options;
+    langSelectorViewId: string;
+    langSelectorBtnId: string;
+    selectedLangId: string;
+    languagesId: string;
+    languageSelectorIconId: string;
+    targetEl: string;
+    languagesEl: string;
+    langSelectorBtnEl: string;
+    selectedLangEl: string;
+    rootEl: string;
+    languageSelectorIconEl: string;
+    languages: Language[];
+    constructor(options?: Options, translation?: Translation);
+    createUi(): void;
+    applyAccessibilityLabels(): void;
+    show(): void;
+    populate(dicts: Language[], selectedIndex: number): boolean;
+    toggleLanguageSelector(): void;
+    openLanguageSelector(): void;
+    closeLanguageSelector(): void;
+    clickLanguage(index: number): void;
+    setStatus(options: LanguageSelectorStatusOption): void;
+}
+
+declare class LanguageSelectorViewController extends BaseViewController {
+    options: Options;
+    view: LanguageSelectorView;
+    selectedLanguage: LanguageDict;
+    allLanguages: LanguageDict[];
+    languageObjs: LanguageDict[];
+    enabled: boolean | undefined;
+    poiManager: PoiManager | undefined;
+    constructor(options?: Options, translation?: Translation, poiManager?: PoiManager);
+    populate(): boolean;
+    getSelectedLanguage(): LanguageDict;
+    setSelectedLanguage(languageCode: string): void;
+    openLanguageSelector(): void;
+    closeLanguageSelector(): void;
+    LanguageSelectorView_onLanguageSelected: (languageObject: LanguageDict) => void;
+    setStatus(options: LanguageSelectorStatusOption): void;
+}
+
+declare class ZoomSelectorView extends BaseView {
+    events: BaseView["events"] & {
+        zoomIn: string;
+        zoomOut: string;
+    };
+    options: Options;
+    zoomSelectorViewId: string;
+    zoomInButtonClass: string;
+    zoomOutButtonClass: string;
+    zoomSelectorViewEl: string;
+    zoomInSelectorViewEl: string;
+    zoomOutSelectorViewEl: string;
+    targetEl: string;
+    rootEl: string;
+    constructor(options?: Options, translation?: Translation);
+    applyAccessibilityLabels(): void;
+    createUi(): void;
+    show(): void;
+    populate(): boolean;
+    zoomIn(): void;
+    zoomOut(): void;
+    enableZoomIn(): void;
+    disableZoomIn(): void;
+    enableZoomOut(): void;
+    disableZoomOut(): void;
+}
+
+declare class ZoomSelectorViewController extends BaseViewController {
+    options: Options;
+    view: ZoomSelectorView;
+    zoom: number | undefined;
+    constructor(options?: Options, translation?: Translation);
+    populate(zoom: number): boolean;
+    getZoom(): number | undefined;
+    ZoomSelectorView_onZoomIn: () => void;
+    ZoomSelectorView_onZoomOut: () => void;
+    handleZoomIn(zoom: number): void;
+    handleZoomOut(zoom: number): void;
+}
+
+interface NavigationSearchResult {
+    identifier: string;
+    name: (lang: Language | undefined) => string;
+    buildingTitle?: string;
+    levelTitle?: string;
+    properties?: {
+        bid?: string;
+        lvl?: number;
+    };
+}
+interface NavigationStepInfo {
+    buildingInternalIdentifier?: string;
+    message: string;
+    latLng: {
+        lat: number;
+        lng: number;
+    };
+    iconName?: string;
+}
+interface NavigationRouteInfo {
+    distance: string;
+    minutes: string;
+    estimatedArrivalTime: string;
+}
+interface NavigationDestinationObject {
+    name?: (language?: Language | null) => string;
+    properties?: JsonObject;
+}
+declare class NavigationView extends BaseView {
+    options: Options;
+    translation: Translation;
+    events: BaseView["events"] & {
+        startSelected: string;
+        destinationSelected: string;
+        navigationStarted: string;
+        navigationFailed: string;
+        navigateClicked: string;
+        routeChanged: string;
+        navigationCancelled: string;
+        navigationClosed: string;
+        previousStepSelected: string;
+        nextStepSelected: string;
+        inputsSwapped: string;
+        queryChanged: string;
+        startObjectCanceled: string;
+        destinationObjectCanceled: string;
+        stepSelected: string;
+    };
+    inputsEnum: {
+        start: string;
+        destination: string;
+    };
+    searchResultClicked: boolean;
+    navigationViewId: string;
+    navigationTitleContainerId: string;
+    navigationTitleId: string;
+    navigationDescriptionId: string;
+    startingLocationId: string;
+    destinationLocationId: string;
+    swapLocationId: string;
+    locationSelectorClass: string;
+    closeIconClass: string;
+    clearIconClass: string;
+    navigationButtonId: string;
+    cancelButtonId: string;
+    stepChangeButtonsId: string;
+    prevButtonId: string;
+    nextButtonId: string;
+    locationPointsClass: string;
+    locationInputClass: string;
+    locationInputWrapperClass: string;
+    navigationWrapperId: string;
+    navigationStepId: string;
+    stepCircleClass: string;
+    navigationProgressId: string;
+    stepsContainerForMobileId: string;
+    mobileExpanderIconId: string;
+    stepListId: string;
+    errorBoxId: string;
+    newProgressBarId: string;
+    currentStepId: string;
+    toggleStepsId: string;
+    routeInfoId: string;
+    routeInfoDistanceId: string;
+    routeInfoTimeId: string;
+    routeInfoArrivalTimeId: string;
+    spacerClass: string;
+    locationWithSwapperId: string;
+    loadingCircleId: string;
+    editButtonClass: string;
+    editStartButtonId: string;
+    editDestinationButtonId: string;
+    fromInputTextId: string;
+    toInputTextId: string;
+    draggableBoxId: string;
+    navigationIconContainerId: string;
+    targetEl: string;
+    navigationTitleEl: string;
+    navigationDescriptionEl: string;
+    navigationViewEl: string;
+    closeIconEl: string;
+    startClearEl: string;
+    destinationClearEl: string;
+    navigationButtonEl: string;
+    cancelButtonEl: string;
+    stepChangeButtonsEl: string;
+    prevButtonEl: string;
+    nextButtonEl: string;
+    startingLocationSelectorEl: string;
+    destinationLocationSelectorEl: string;
+    startingLocationInputEl: string;
+    destinationLocationInputEl: string;
+    swapLocationEl: string;
+    navigationWrapperEl: string;
+    navigationStepEl: string;
+    navigationProgressEl: string;
+    newProgressBarEl: string;
+    stepListEl: string;
+    errorBoxEl: string;
+    currentStepEl: string;
+    toggleStepsEl: string;
+    startingLocationPointsEl: string;
+    destinationLocationPointsEl: string;
+    spacerEl: string;
+    locationWithSwapperEl: string;
+    fromInputTextEl: string;
+    toInputTextEl: string;
+    editStartButtonEl: string;
+    editDestinationButtonEl: string;
+    startingLocationInputWrapperEl: string;
+    destinationLocationInputWrapperEl: string;
+    navigationIconContainerEl: string;
+    routeInfoEl: string;
+    routeInfoDistanceEl: string;
+    routeInfoTimeEl: string;
+    routeInfoArrivalTimeEl: string;
+    navigationTitleContainerEl: string;
+    stepsContainerForMobileEl: string;
+    mobileExpanderIconEl: string;
+    topUiEl: string;
+    rootEl: string;
+    draggableBoxEl: string;
+    objectToEdit: string | undefined;
+    isEditingRouteFromNavigation: boolean;
+    callToActionButtons: string[];
+    stepListNavigationReady: boolean;
+    isUserInteraction: boolean;
+    isUserScrolling: boolean;
+    stepPositions: number[][];
+    currentStep: number;
+    startPoiText: string | undefined;
+    destinationPoiText: string | undefined;
+    isRTL: boolean;
+    ensureVisibleTimeout: ReturnType<typeof setTimeout> | undefined;
+    startInputFocusOutTimeout: ReturnType<typeof setTimeout> | undefined;
+    destinationInputFocusOutTimeout: ReturnType<typeof setTimeout> | undefined;
+    locationResultsHideTimeout: ReturnType<typeof setTimeout> | undefined;
+    locationSearchKeyboardReady: boolean;
+    locationSearchResultCache: {
+        start: NavigationSearchResult[];
+        destination: NavigationSearchResult[];
+    };
+    scrollEndTimeout: ReturnType<typeof setTimeout> | undefined;
+    windowScrollX: number;
+    windowScrollY: number;
+    markerEl: JQuery<HTMLElement> | undefined;
+    expandedHeight: number;
+    expanderTouchStartY: number;
+    isDragging: boolean;
+    draggedUpwards: boolean;
+    uiEl: string;
+    constructor(options: Options, translation: Translation);
+    createUi(): void;
+    applyAccessibilityLabels(): void;
+    private onNavigateButtonActivate;
+    private initLocationSearchKeyboard;
+    private dismissLocationSearchResults;
+    private isFocusWithinLocationGroup;
+    private getLocationResultsListId;
+    private initStepListNavigation;
+    hide(): boolean;
+    populate(startPoiText?: string, destinationPoiText?: string): boolean;
+    show(): void;
+    populateInputs(startPoiText?: string, destinationPoiText?: string): void;
+    private findLocationSearchResult;
+    private selectLocationSearchResultFromElement;
+    private selectLocationSearchResult;
+    populateSearchResults(results: NavigationSearchResult[], type: string): void;
+    setDisabledStatus(isDisabled: boolean): void;
+    setLoadingStatus(isLoading: boolean): void;
+    startNavigation(currentStep: number, stepsInfo: NavigationStepInfo[], destinationObject: NavigationDestinationObject | null | undefined): void;
+    setTitle(title: string | undefined): void;
+    populateRouteInfo(routeInfo: NavigationRouteInfo): void;
+    populateProgress(stepToGo: number, allSteps: NavigationStepInfo[]): void;
+    populateNavigationSteps(currentStep: number, stepsInfo: NavigationStepInfo[]): void;
+    updateNavigationStep(currentStep: number, stepsInfo: NavigationStepInfo[]): void;
+    updateCancelButton(currentStep: number, stepsInfo: NavigationStepInfo[]): void;
+    scollToNextDirectionItem(): void;
+    scrollToCurrentDirectionItem(): void;
+    scrollToCurrentDirectionItemInstant(): void;
+    scaleTextToFit(element: Element | null, maxWidth: number): void;
+    populateStep(step: NavigationStepInfo, index: number, currentStep: number, stepsInfo: NavigationStepInfo[]): void;
+    private activateEditStart;
+    private activateEditDestination;
+    private focusLocationInput;
+    private wireEditButtonsAccessibility;
+    populateEditButtons(): void;
+    setPrevButton(isEnabled: boolean): void;
+    setNextButton(isEnabled: boolean): void;
+    resetNavigation(): void;
+    close(): void;
+    private isLocationQueryMatchingCommitted;
+    private isPartialEditOfCommittedLocation;
+    private shouldClearCommittedLocation;
+    private emitLocationSelectionCleared;
+    searchLocation(query: string, type: string): void;
+    focusOutLocationInput(event: Event, type: string): void;
+    private scheduleHideLocationResults;
+    toggleSteps(): void;
+    setError(errorMsg: string): void;
+    swapInputs(): void;
+    isViewVisible(): boolean;
+    setTranslation(translation: Translation): void;
+    scrolling(count: number, self: NavigationView): void;
+    ensureVisible(): void;
+    handleUserScroll(): void;
+    onUserInteraction(event: Event): void;
+    highlightStartPointInput(): void;
+    addEventListeners(): void;
+    removeEventListeners(): void;
+    expanderTouchStartHandler(event: {
+        touches?: {
+            clientY: number;
+        }[];
+        clientY?: number;
+    }): void;
+    expanderTouchEndHandler(event: {
+        preventDefault?: () => void;
+        changedTouches?: {
+            clientY: number;
+        }[];
+    }): void;
+    onDrag(): void;
+    toggleExpandedState(): void;
+    convertToArabicText(text: string | undefined, type: string): string | null | undefined;
+    convertArrivalTimeToArabic(estimatedArrivalTime: string | Date): string | null | undefined;
+    sendEvent(event: string, data?: JsonValue): void;
+}
+
+declare class NavigationModes {
+    static get NORMAL(): string;
+    static get EASY(): string;
+    static get ACCESSIBLE(): string;
+    static isNavigationMode(mode: string): boolean;
+}
+
+declare class NavigationViewController extends BaseViewController {
+    options: Options;
+    dataManager: DataManager;
+    poiManager: PoiManager;
+    translation: Translation;
+    analyticsManager: AnalyticsManager;
+    view: NavigationView;
+    currentStep: number;
+    currentRouteData: RouteDataDirection[][];
+    levelBasedRouteData: RouteDataDirection[];
+    stepsInfo: NavigationStepInfo[] | undefined;
+    isNavigationActive: boolean | undefined;
+    currentMode: NavigationModes;
+    routeInfo: {
+        minutes: string;
+        distance: string;
+        estimatedArrivalTime: string;
+    };
+    directions: RouteDataDirection[];
+    startObject: Poi | Feature | undefined;
+    destinationObject: Poi | Feature | undefined;
+    constructor(options: Options, poiManager: PoiManager, translation: Translation, analyticsManager: any);
+    populate(startObject: Poi | Feature | undefined, destinationObject: Poi | Feature | undefined): boolean;
+    setStartObject(featureOrPoi: Poi | Feature | undefined): void;
+    setDestinationObject(featureOrPoi: Poi | Feature | undefined): void;
+    sameFeatureOrPoi(object1: any, object2: any): boolean;
+    startNavigation(): void;
+    handleRouteData(routeData: RouteDataResponse): void;
+    extractDirections(routeData: RouteDataResponse): RouteDataDirection[];
+    getObjectData(startOrDestinationObject: any): any;
+    getTransitionName(direction: any): string;
+    getMessageForInterBuildingTransition(index: number, displayedDirections: any[], direction: any, transitionName: string, transitionType: string, routeData: RouteDataResponse): string;
+    getMessage(direction: any, displayedDirections: any[], index: number, transitionName: string): string;
+    extractRouteData(routeData: RouteDataResponse): any[];
+    startNavigationByStep(step: number): void;
+    startNextStep(): void;
+    startPreviousStep(): void;
+    getCurrentRouteData(): any[] | undefined;
+    getNextRouteData(): any[] | undefined;
+    groupRouteData(routeData: any[]): any[][];
+    NavigationView_onStartSelected: (featureOrPoi: any) => void;
+    NavigationView_onDestinationSelected: (featureOrPoi: any) => void;
+    NavigationView_onPreviousStepSelected: () => void;
+    NavigationView_onNextStepSelected: () => void;
+    NavigationView_onStepSelected: (stepIndex?: number) => void;
+    NavigationView_onNavigateClicked: () => void;
+    NavigationView_onInputsSwapped: () => void;
+    NavigationView_onQueryChanged: (data: {
+        query: string;
+        type: string;
+    }) => Promise<void>;
+    NavigationView_onStartObjectCanceled: () => void;
+    NavigationView_onDestinationObjectCanceled: () => void;
+    viewOnHidden: () => void;
+    setError(errorMsg: string): void;
+    close(): void;
+    resetNavigation(): void;
+    setMode(mode: string): void;
+    getEventData(routeData: RouteDataResponse | null | undefined, errorMsg?: string): any;
+    setTranslation(translation: Translation): void;
+}
+
+interface PoiCardSearchResult {
+    name?: string;
+    description?: string;
+    iconUrl?: string;
+    tags?: string[] | string;
+    levelLongTitle?: string;
+    buildingTitle?: string;
+    fid?: string | number;
+    isFeatured?: boolean;
+    [key: string]: JsonValue;
+}
+declare class PoiCardsView extends BaseView {
+    options: Options;
+    poiManager: PoiManager | undefined;
+    analyticsManager: AnalyticsManager | undefined;
+    translation: Translation;
+    events: BaseView["events"] & {
+        poiSelected: string;
+        resultsPopulated: string;
+        routeButtonClicked: string;
+        accessibilityButtonClicked: string;
+        goBackButtonClicked: string;
+        poiViewed: string;
+    };
+    poiCardsViewId: string;
+    listHeaderContainerId: string;
+    resultId: string;
+    loadingCircleId: string;
+    goBackIconContainerId: string;
+    listHeaderId: string;
+    listHeaderIconId: string;
+    bottomUi: string;
+    poiCardClass: string;
+    draggableBoxId: string;
+    resultEl: string;
+    loadingCircleEl: string;
+    listHeaderContainerEl: string;
+    listHeaderEl: string;
+    bottomUiEl: string;
+    draggableBoxEl: string;
+    goBackIconContainerEl: string;
+    targetEl: string;
+    rootEl: string;
+    poisOfCategory: PoiCardSearchResult[];
+    activeCardIndex: number;
+    isAnyPoiCardButtonClicked: boolean;
+    isNavigationAccessible: boolean;
+    textColor: string | null;
+    isRTL?: boolean;
+    uiEl: string;
+    constructor(options?: Options, poiManager?: PoiManager, analyticsManager?: AnalyticsManager, translation?: Translation);
+    createUi(): void;
+    applyAccessibilityLabels(): void;
+    goBack(): void;
+    highlightCardAtIndex(index: number, options?: {
+        scrollIntoView?: boolean;
+    }): void;
+    focusPoiCardsList(index?: number): void;
+    prepareBottomDrawerForPoiCardsView(): void;
+    show(): void;
+    populateResults(searchResults?: PoiCardSearchResult[]): void;
+    createListItem(index: number, searchResults: PoiCardSearchResult[]): any;
+    createFeaturedBadge(): any;
+    createListItemContent(container: any, searchResult: PoiCardSearchResult, index: number): any;
+    onRouteClicked(poiId?: string | number): void;
+    onAccessibilityButtonClicked(): void;
+    updateAccessibilityRouteLabels(): void;
+    showResults(title?: string, icon?: string): void;
+    hide(): boolean;
+    clear(): void;
+    clearResult(): void;
+    emptyResults(): void;
+    clearSelectedPoi(): void;
+    setSelectedPoi(poi: any): void;
+    setHeader(headerText?: string, _icon?: string): void;
+    setAccessibilityButtonStatus(status: boolean): void;
+    handleAccessibilityStatus(isAnimationActive: boolean): void;
+    setTranslation(translation: Translation): void;
+}
+
+declare class PoiCardsViewController extends BaseViewController {
+    options: Options;
+    view: PoiCardsView;
+    poiManager: PoiManager | undefined;
+    analyticsManager: AnalyticsManager | undefined;
+    translation: Translation;
+    lang: {
+        code?: string;
+    };
+    selectedPoi: Poi | undefined;
+    enabled: boolean;
+    poisOfCategory: Poi[] | undefined;
+    isNavigationAccessible: boolean;
+    constructor(options?: Options, poiManager?: PoiManager, analyticsManager?: AnalyticsManager, translation?: Translation);
+    populate(): boolean;
+    displayPoisOfCategory(pois: any[], categoryName?: string, categoryIcon?: string): void;
+    hideView(): void;
+    showView(): void;
+    clearSelectedPoi(): void;
+    getSelectedPoi(): any;
+    setSelectedPoi(poi: any): void;
+    PoiCardsView_onPoiSelected: (poiId: string | number) => void;
+    PoiCardsView_onGoBackButtonClicked: () => void;
+    reset(): void;
+    PoiCardsView_onRouteButtonClicked: (poiId: string | number) => void;
+    PoiCardsView_onPoiViewed: (poiId: string | number) => void;
+    goBack(): void;
+    shouldShow(): boolean;
+    PoiCardsView_onAccesssibilityButtonClicked: () => void;
+    setAccessibilityButtonStatus(isAccessible: boolean): void;
+    setTranslation(translation: Translation): void;
+}
+
+interface BannerApp {
+    promotionText?: string;
+    appIcon?: string;
+    downloadUrl?: string;
+    appName?: string;
+    appDescription?: string;
+    buttonTitle?: string;
+    intentLink?: string;
+    webAndroidDeepLinkUrlScheme?: string;
+}
+declare class BannerView extends BaseView {
+    translation: Translation;
+    events: BaseView["events"] & {
+        bannerDismissed: string;
+        installClicked: string;
+    };
+    bannerOverlayId: string;
+    bannerViewContentId: string;
+    bannerId: string;
+    popupContentClass: string;
+    dismissButtonClass: string;
+    alertIconId: string;
+    bannerOverlayEl: string;
+    bannerContainerEl: string;
+    bannerEl: string;
+    popupContentEl: string;
+    dismissButtonEl: string;
+    targetEl: string;
+    rootEl: string;
+    alertIconEl: string;
+    touchStartX: number;
+    constructor(options: Options, translation: Translation);
+    private emitEvent;
+    private resetBannerDomBeforePopulate;
+    createUi(): void;
+    applyAccessibilityLabels(): void;
+    populate(isPopup: boolean, app: BannerApp): boolean;
+    populateBanner(isPopup: boolean, app: BannerApp): void;
+    convertToBanner(): void;
+    dismissBanner(className: string): void;
+    hide(): boolean;
+}
+
+declare class BannerViewController extends BaseViewController {
+    view: BannerView;
+    constructor(options?: Options, translation?: Translation);
+    populate(): boolean;
+}
+
+declare class WelcomeView extends BaseView {
+    events: BaseView["events"] & {
+        closeClicked: string;
+    };
+    options: Options;
+    welcomeOverlayId: string;
+    welcomePopupId: string;
+    welcomeLogoId: string;
+    logoContainerId: string;
+    welcomeHeaderId: string;
+    welcomeDescriptionId: string;
+    quickAccessContentId: string;
+    quickAccessListId: string;
+    quickAccessListItemClass: string;
+    actionButtonId: string;
+    closeIconClass: string;
+    iconContainerClass: string;
+    categoryIconWrapperStyleClass: Record<number, string>;
+    welcomeHeaderEl: string;
+    welcomeDescriptionEl: string;
+    welcomeLogoEl: string;
+    quickAccessContentEl: string;
+    quickAccessListEl: string;
+    targetEl: string;
+    rootEl: string;
+    closeIconEl: string;
+    actionButtonEl: string;
+    constructor(options?: Options, translation?: Translation);
+    createUi(): void;
+    applyAccessibilityLabels(): void;
+    setTranslation(translation: Translation | undefined): void;
+    populate(): boolean;
+}
+
+declare class WelcomeViewController extends BaseViewController {
+    view: WelcomeView;
+    constructor(options?: Options, translation?: Translation);
+    showView(): void;
+    setTranslation(translation: Translation): void;
+}
+
+declare class InfoView extends BaseView {
+    options: Options;
+    infoViewId: string;
+    iframeId: string;
+    closeIconId: string;
+    closeIconEl: string;
+    iframeEl: string;
+    targetEl: string;
+    rootEl: string;
+    language: Language | undefined;
+    constructor(options?: Options | null, translation?: Translation);
+    dismissInfo(): void;
+    createUi(): void;
+    applyAccessibilityLabels(): void;
+    show(): void;
+    setLanguage(language: Language): void;
+    setIframe(): void;
+}
+
+declare class InfoViewController extends BaseViewController {
+    view: InfoView;
+    constructor(options?: Options, translation?: Translation);
+    setLanguage(language: Language): void;
+}
+
+declare class RatingView extends BaseView {
+    events: BaseView["events"] & {
+        feedbackSubmitted: string;
+        dismissed: string;
+    };
+    options: Options;
+    ratingOverlayId: string;
+    ratingPopupId: string;
+    titleId: string;
+    buttonContainerId: string;
+    positiveFeedbackButtonId: string;
+    negativeFeedbackButtonId: string;
+    actionButtonContainerClass: string;
+    feedbackActionButtonContainerId: string;
+    submitButtonId: string;
+    dismissButtonId: string;
+    footNoteId: string;
+    textInputContainerId: string;
+    inputLabelId: string;
+    textInputId: string;
+    charCountId: string;
+    negativeFeedbackButtonContainerId: string;
+    sendButtonId: string;
+    goBackButtonId: string;
+    successContentId: string;
+    successImageId: string;
+    closeButtonId: string;
+    buttonClass: string;
+    ratingOverlayEl: string;
+    ratingPopupEl: string;
+    titleEl: string;
+    positiveFeedbackButtonEl: string;
+    negativeFeedbackButtonEl: string;
+    submitButtonEl: string;
+    dismissButtonEl: string;
+    textInputContainerEl: string;
+    textInputEl: string;
+    labelEl: string;
+    charCountEl: string;
+    feedbackButtonsContainerEl: string;
+    feedbackActionButtonContainerEl: string;
+    negativeFeedbackButtonContainerEl: string;
+    sendButtonEl: string;
+    goBackButtonEl: string;
+    successContentEl: string;
+    successImageEl: string;
+    closeButtonEl: string;
+    rootEl: string;
+    selectedFeedback: "positive" | "negative" | undefined;
+    minChars: number;
+    maxChars: number;
+    constructor(options?: Options, translation?: Translation);
+    createUi(): void;
+    applyAccessibilityLabels(): void;
+    private syncRatingActionButtonStates;
+    showNegativeFeedback(): void;
+    showFeedbackPopup(): void;
+    showSuccess(): void;
+}
+
+declare class RatingViewController extends BaseViewController {
+    view: RatingView;
+    constructor(options?: Options, translation?: Translation);
+}
+
+declare class SiteBuildingManager {
+    getAllSites(): Site[];
+    getAllBuildings(): Building[];
+    getSiteWithInternalIdentifier(internalIdentifier?: string): Site | undefined;
+    getBuildingWithInternalIdentifier(internalIdentifier?: string): Building | undefined;
+    getSiteWithExternalIdentifier(externalIdentifier?: string): Site | undefined;
+    getBuildingWithExternalIdentifier(externalIdentifier?: string): Building | undefined;
+    getLevelWithExternalIdentifier(buildingExternalIdentifier?: string, levelExternalIdentifier?: string): Level | undefined;
+    getLevelWithLevelIndexFromBuilding(buildingInternalIdentifier?: string, levelIndex?: number): Level | undefined;
+}
+
+interface CategoryItem {
+    title: string;
+    iconUrl: string;
+    match?: JsonObject[];
+    [key: string]: JsonValue;
+}
+
+declare class UiController {
+    options: Options;
+    translation: Translation;
+    poiManager: PoiManager;
+    siteBuildingManager: SiteBuildingManager;
+    analyticsManager: AnalyticsManager;
+    mapViewController: MapViewController;
+    searchViewController: SearchViewController;
+    poiCardsViewController: PoiCardsViewController;
+    categoryListViewController: CategoryListViewController;
+    levelSelectorViewController: LevelSelectorViewController;
+    poiDetailsViewController: PoiDetailsViewController;
+    loadingViewController: LoadingViewController;
+    watermarkViewController: WatermarkViewController;
+    languageSelectorViewController: LanguageSelectorViewController;
+    zoomSelectorViewController: ZoomSelectorViewController;
+    navigationViewController: NavigationViewController;
+    bannerViewController: BannerViewController;
+    welcomeViewController: WelcomeViewController;
+    infoViewController: InfoViewController;
+    ratingViewController: RatingViewController;
+    handlingMapClick: boolean;
+    selectedCategory: CategoryItem | undefined;
+    isNavigationAccessible: boolean;
+    isOnboardingCompleted: boolean;
+    ratingPopupInterval: ReturnType<typeof setInterval> | null;
+    shouldHideRatingPopup: boolean;
+    sessionCount: number;
+    isMapReady: boolean;
+    isLevelOptionApplied: boolean | undefined;
+    language: Language | undefined;
+    poiCardsViewedTime: number | undefined;
+    hasPostedPoiDetailsExpandAnalytics: boolean;
+    constructor(options: Options, poiManager: PoiManager, siteBuildingManager: SiteBuildingManager, analyticsManager: AnalyticsManager, translation: Translation);
+    getMapViewController(): MapViewController;
+    getSearchViewController(): SearchViewController;
+    getPoiCardsViewController(): PoiCardsViewController;
+    getCategoryListViewController(): CategoryListViewController;
+    getLanguageSelectorViewController(): LanguageSelectorViewController;
+    getLevelSelectorViewController(): LevelSelectorViewController;
+    getPoiDetailsViewController(): PoiDetailsViewController;
+    getLoadingViewController(): LoadingViewController;
+    getWatermarkViewController(): WatermarkViewController;
+    getZoomSelectorViewController(): ZoomSelectorViewController;
+    getNavigationViewController(): NavigationViewController;
+    getBannerViewController(): BannerViewController;
+    getWelcomeViewController(): WelcomeViewController;
+    getInfoViewController(): InfoViewController;
+    getRatingViewController(): RatingViewController;
+    registerEvents(): void;
+    registerMapViewEvents(): void;
+    registerLevelSelectorViewEvents(): void;
+    registerZoomSelectorViewEvents(): void;
+    registerLanguageSelectorViewEvents(): void;
+    registerSearchViewEvents(): void;
+    registerPoiCardsViewEvents(): void;
+    registerPoiDetailsEvents(): void;
+    registerNavigationEvents(): void;
+    registerCategoryListEvents(): void;
+    registerLoadingViewEvents(): void;
+    registerBannerEvents(): void;
+    registerWatermarkEvents(): void;
+    registerWelcomeEvents(): void;
+    registerInfoEvents(): void;
+    registerRatingEvents(): void;
+    MapView_onMapClicked: (queryRenderedFeatures: any[], point: any) => Promise<void>;
+    handleMapClickNotInNavigation(isNavigationVisible: boolean): void;
+    extractClickedFeatureType(pointrRenderedFeatures: any[]): string;
+    handlePoiClick(pointrRenderedFeatures: any[], isNavigationVisible: boolean, isPoiCardsViewVisible: boolean): Promise<{
+        poiClicked: Poi | undefined;
+        newCurrentPoi: Poi | undefined;
+    }>;
+    findPoiFeature(pointrRenderedFeatures: any[]): any;
+    handleSiteClick(pointrRenderedFeatures: any[]): void;
+    handleBuildingClick(pointrRenderedFeatures: any[]): void;
+    handleDefaultClick(isNavigationVisible: boolean, shouldShowPoiCardsView: boolean, isPoiCardsViewVisible: boolean, isPoiDetailsVisible: boolean): void;
+    navigationMapClickHandler(poi: Poi): void;
+    poiDetailsMapClickHandler(poi: Poi | undefined, currentPoi: Poi | undefined): void;
+    MapView_onMapLongClicked: (event: any) => void;
+    MapView_onZoomChanged: (zoom: number) => void;
+    MapView_onCurrentBuildingChanged: (data: {
+        oldCurrentBuilding?: any;
+        newCurrentBuilding?: any;
+    }) => void;
+    handleSameSiteLevel(oldLevel: Level | undefined, data: {
+        newCurrentBuilding?: any;
+    }): void;
+    handleNoCurrentBuilding: (isNavigationVisible: boolean, isPoiDetailsVisible: boolean) => void;
+    handleDifferentSiteLevel(data: {
+        newCurrentBuilding?: any;
+    }): void;
+    handleNavigation(data: {
+        oldCurrentBuilding?: any;
+        newCurrentBuilding?: any;
+    }, isNavigationVisible: boolean, isPoiCardsVisible?: boolean): void;
+    MapView_onCurrentSiteChanged: (data: {
+        newSite?: any;
+    }) => Promise<void>;
+    handleSiteChange(siteId: string, isPoiDetailsVisible: boolean, isNavigationVisible: boolean): Promise<void>;
+    updateViewsForNewSite(siteId: string, isPoiDetailsVisible: boolean): void;
+    handleNoSite(isPoiDetailsVisible: boolean): void;
+    filterCategoriesWithMatchers(categories: any[], pois: Poi[]): any[];
+    MapView_onMapReady: () => Promise<void>;
+    handleMapReady(): Promise<void>;
+    MapView_onMapIdle: () => void;
+    MapView_onLevelChanged: (levelIndex: number | undefined) => void;
+    MapView_onExitClicked: () => void;
+    MapView_onInfoClicked: () => void;
+    MapView_onDraggedUpwards: () => void;
+    postPoiDetailsExpandedAnalytics(): void;
+    LevelSelectorView_onLevelSelected: () => void;
+    ZoomSelectorView_onZoomIn: () => void;
+    ZoomSelectorView_onZoomOut: () => void;
+    PoiDetailsView_onViewShown: () => void;
+    PoiDetailsView_onViewHidden: () => void;
+    PoiDetailsView_onCloseClicked: () => void;
+    PoiDetailsView_onRouteButtonClicked: () => void;
+    PoiDetailsView_onAccessibilityButtonClicked: (status: boolean) => void;
+    PoiDetailsView_onExpanded: () => void;
+    PoiDetailsView_onMinimized: () => void;
+    NavigationView_onViewShown: () => void;
+    NavigationView_onViewHidden: () => void;
+    NavigationView_onStartSelected: (featureOrPoi?: Poi | Feature) => void;
+    NavigationView_onStartObjectCanceled: (startObject: Poi | Feature) => void;
+    NavigationView_onDestinationObjectCanceled: (destinationObject: Poi | Feature) => void;
+    NavigationView_onDestinationSelected: (featureOrPoi?: Poi | Feature) => void;
+    NavigationView_onNavigateClicked: () => void;
+    NavigationView_onRouteChanged: (type: string) => void;
+    NavigationView_onNavigationCancelled: () => void;
+    NavigationView_onNextStepSelected: () => void;
+    NavigationView_onPreviousStepSelected: () => void;
+    NavigationView_onNavigationClosed: () => void;
+    navigationHighlightHandler(): void;
+    navigationCancelHandler(): void;
+    SearchView_onPoiSelected: () => void;
+    SearchView_onQuerySearched: () => void;
+    SearchView_onRouteButtonClicked: () => void;
+    SearchView_onGoBackButtonClicked: () => void;
+    SearchView_onBuildingSelected: (buildingItem: any) => void;
+    SearchView_onBuildingFilterSelected: () => void;
+    SearchView_onSearchResultsShown: () => void;
+    LanguageSelectorView_onLanguageSelected: () => void;
+    CategoryListView_onCategorySelected: (categoryItem: any) => Promise<void>;
+    LoadingView_onErrorClosed: () => void;
+    BannerView_onBannerDismissed: (source: string) => void;
+    BannerView_onInstallClicked: (source: string) => void;
+    handleNavigationAccessibility: () => void;
+    WatermarkView_onVisibilityChangeDetected: () => void;
+    RatingView_onRatingSubmitted: (feedback: any) => void;
+    RatingView_onViewHidden: () => void;
+    RatingView_onViewShown: () => void;
+    WelcomeView_onViewHidden: () => void;
+    WelcomeView_onCloseClicked: () => void;
+    InfoView_onViewHidden: () => void;
+    highlightCategory: (categoryItem: CategoryItem) => Promise<void>;
+    PoiCardsView_onViewShown: () => void;
+    PoiCardsView_onViewHidden: () => void;
+    PoiCardsView_onGoBackButtonClicked: () => void;
+    PoiCardsView_onPoiSelected: () => void;
+    PoiCardsView_onRouteButtonClicked: () => void;
+    PoiCardsView_onPoiViewed: () => void;
+    PoiCardsView_onAccessibilityButtonClicked: (status: boolean) => void;
+    showLoadingView(): void;
+    showSplashScreen(): void;
+    hideLoadingView(): void;
+    showError(error: string | {
+        errorMsg?: string;
+        errorTitle?: string;
+    }, isPopup?: boolean): void;
+    hideError(): void;
+    show(): void;
+    populate(): void;
+    populateCategoryListView(): void;
+    populateSearchView(): void;
+    handlePoiDetailsConfiguration(): void;
+    handleSiteExternalIdentifier(): void;
+    handleHighlightPoiIdentifier(): void;
+    populateZoomControls(): void;
+    populateLanguageSelector(): void;
+    populateMapAndLevelViews(): void;
+    createFeatureFromOptions(siteId: string | undefined, buildingId: string | undefined, levelIndex: number | undefined, lat: number | undefined, lng: number | undefined): Feature | undefined;
+    addNavigationFeaturesToMap(startPoi: Poi | undefined, destinationPoi: Poi | undefined, startPoint: Feature | undefined, destinationPoint: Feature | undefined): void;
+    updateStartAndDestinationPois(): Promise<void>;
+    setLanguage(language: Language): void;
+    showPoiDetails(featureOrPoi: Poi | Feature): void;
+    hidePoiDetails(): void;
+    setLevel(level: Level | undefined): void;
+    getLevel(): Level | undefined;
+    highlightPoi(poi: Poi): void;
+    unhighlightPoi(poiId: string): void;
+    unhighlightAllPois(): void;
+    focusSite(siteInternalIdentifier: string): void;
+    focusBuilding(buildingInternalIdentifier: string): void;
+    zoomTo(zoom: number): void;
+    shouldScrollMapToPoi(poi: Poi): boolean;
+    scrollMapToPoiIfNeeded(poi: Poi, offset?: [number, number]): void;
+    showPoiOnMap(poi: Poi, offset?: [number, number]): void;
+    getCurrentSite(): any;
+    getCurrentBuilding(): any;
+    routeButtonClickHandler(poi: Poi): void;
+    setCategories(categoryList: any[]): void;
+    centerSelectedPoiForPoiCardsView(poi: Poi): void;
+    showPoiCardsView(): void;
+    showBanner(): void;
+    showBannerIfEligible(): void;
+    shouldShowBanner(): boolean;
+    fitBoundsForRoute(routeData: any[], startObject: Poi | Feature | undefined, destinationObject: Poi | Feature | undefined): void;
+    handleTransitionMessageLayer(routeData: any[], startObject: Poi | Feature | undefined, destinationObject: Poi | Feature | undefined): void;
+    displayRatingPopup(): void;
+    setRatingPopupInterval(): void;
+    canDisplayRatingPopup(): boolean;
+    updatePoiStyles(poisArray: Poi[], dynamicExtrusionOpacity?: number): Promise<void>;
+    resetPoiStyles(poisArray: Poi[] | Poi): void;
+    resetAllPoiStyles(): void;
+    getDynamicPois(): any[];
+    hasDynamicStyling(poiId: string): boolean;
+    hidePois(poisArray: Poi[]): void;
+    showAllHiddenPois(): void;
+    updateMainTypeProperties(mainType: string, layerType: string, layoutProperties?: JsonObject, paintProperties?: JsonObject): void;
+    updatePoiExtrusionOpacity(extrusionOpacity: number): void;
+    setZoomRangeForMainType(mainType: string, minZoom: number, maxZoom: number): void;
+    bringMainTypeLayerToFront(mainType: string): void;
+    moveMainTypeLayer(mainType: string, beforeMainType?: string): void;
+}
+
+interface MapWidgetEvents {
+    dataLoaded: string;
+}
+declare class MapWidget {
+    private static instance;
+    options: Options;
+    isOptionsValid: boolean;
+    events: MapWidgetEvents;
+    isDataLoaded: boolean;
+    isUiInitialized: boolean;
+    protected uiController?: UiController | undefined;
+    protected dataManager?: DataManager | undefined;
+    protected poiManager?: PoiManager | undefined;
+    protected siteBuildingManager?: SiteBuildingManager | undefined;
+    protected analyticsManager?: AnalyticsManager | undefined;
+    protected translation?: Translation | undefined;
+    protected language: Language | undefined;
+    constructor(options: Options);
+    static getInstance(): MapWidget | undefined;
+    start(): void | Promise<void>;
+    initData(): void;
+    initUi(): void;
+    destroy(): void;
+    initLanguageAndTranslation(): void;
+    search(query: string, site?: Site, building?: Building): Promise<Poi[] | WorldModePoi[]>;
+    showPoiDetails(poi: Poi): void;
+    hidePoiDetails(): void;
+    setLevel(level: Level): void;
+    getCurrentLevel(): Level | undefined;
+    highlightPoi(poi: Poi): void;
+    unhighlight(): void;
+    getCurrentSite(): Site | undefined;
+    getCurrentBuilding(): Building | undefined;
+    getUiController(): UiController | undefined;
+    getDataManager(): DataManager | undefined;
+    getPoiManager(): PoiManager | undefined;
+    getSiteBuildingManager(): SiteBuildingManager | undefined;
+    getConfigurations(): JsonObject;
+    setLanguage(language: Language): void;
+    zoomTo(zoom: number): void;
+    focusMap(object?: Site | Building | Level, levelObj?: Level): void;
+    validateBuildingObject(object: Building): boolean;
+    validateSiteObject(object: Site): boolean;
+    validateLevelObject(object: Level): boolean;
+    handleLevelObject(levelObj: Level): void;
+    startNavigation(startObject: Poi | Feature, destinationObject: Poi | Feature): void;
+    updatePoiStyles(poisArray: Poi[], dynamicExtrusionOpacity?: number): Promise<void>;
+    resetPoiStyles(poisArray: Poi[] | Poi): void;
+    resetAllPoiStyles(): void;
+    hidePois(poisArray: Poi[]): void;
+    showAllHiddenPois(): void;
+    setZoomRangeForMainType(mainType: string, minZoom: number, maxZoom: number): void;
+    updatePoiExtrusionOpacity(extrusionOpacity: number): void;
+    setFillExtrusionLayerOpacityForMainType(mainType: string, opacity: number): void;
+    updateMainTypeProperties(mainType: string, layerType: "symbol" | "fill" | "fill-extrusion", layoutProperties?: JsonObject, paintProperties?: JsonObject): void;
+    moveMainTypeLayer(mainType: string, beforeMainType?: string): void;
+    setPointrCloudToken(accessToken: string): void;
+    private _ui;
+    emit: (event: string, ...data: JsonValue[]) => void;
+    on: (event: string, handler: (...data: JsonValue[]) => void) => void;
+}
+
+declare class CircleLayer extends Layer {
+    constructor(options?: JsonObject, filter?: MapLibreFilter);
+}
+
+declare class FillExtrusionLayer extends Layer {
+    constructor(options?: JsonObject, filter?: MapLibreFilter);
+}
+
+declare class FillLayer extends Layer {
+    constructor(options?: JsonObject, filter?: MapLibreFilter);
+}
+
+declare class SymbolLayer extends Layer {
+    constructor(options?: JsonObject, filter?: MapLibreFilter);
+}
+
+type SnapshotClickCallback = (poi: Poi) => void;
+declare class SnapshotImage {
+    poi?: Poi;
+    clickCallback?: SnapshotClickCallback;
+    constructor(poi: unknown, clickCallback: unknown);
+    onClick(): void;
+    toElement(): HTMLImageElement;
+    getPoiId(): string;
+}
+
+declare const PointrWebSDK: {
+    MapWidget: typeof MapWidget;
+    Options: typeof Options;
+    LatLng: typeof LatLng;
+    Level: typeof Level;
+    Site: typeof Site;
+    Building: typeof Building;
+    NavigationModes: typeof NavigationModes;
+    CircleLayer: typeof CircleLayer;
+    Feature: typeof Feature;
+    FillExtrusionLayer: typeof FillExtrusionLayer;
+    FillLayer: typeof FillLayer;
+    SymbolLayer: typeof SymbolLayer;
+    Popup: typeof Popup;
+    Poi: typeof Poi;
+    SnapshotImage: typeof SnapshotImage;
+    Language: typeof Language;
+};
+
+export { Building, CircleLayer, Feature, FillExtrusionLayer, FillLayer, Language, LatLng, Level, MapWidget, NavigationModes, Options, Poi, Popup, Site, SnapshotImage, SymbolLayer, PointrWebSDK as default };
+export type { CategoryItem };