@smarterplan/ngx-smarterplan-core 0.3.11

package/lib/services/models/navigation.service.d.ts

@@ -0,0 +1,22 @@
+import { Navigation, Zone } from "../../types.service";
+import { BaseUserService } from "../user.service";
+import { ZoneService } from "./zone.service";
+import * as i0 from "@angular/core";
+export declare class NavigationService {
+    private userService;
+    private zoneService;
+    API: any;
+    constructor(apiInjected: any, userService: BaseUserService, zoneService: ZoneService);
+    createNavigation(navInput: Navigation): Promise<Navigation>;
+    deleteNavigation(id: string): Promise<Navigation>;
+    getNavigationsForNode(nodeID: string): Promise<Navigation[]>;
+    getNavigation(id: string): Promise<Navigation>;
+    getSweepsIDsForSpace(spaceID: string): Promise<string[]>;
+    getAllowedSweepsIDsForUserInSpace(spaceID: string): Promise<string[]>;
+    getForbiddenNavigationIDsForUserInSpace(spaceID: string): Promise<string[]>;
+    getNavigationsForMatterportIDForSpace(matterportID: string, spaceID: string): Promise<Navigation[]>;
+    getNavigationsForZone(zone: Zone): Promise<Navigation[]>;
+    updateNavigation(navInput: any): Promise<Navigation>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavigationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NavigationService>;
+}

package/lib/services/models/node.service.d.ts

@@ -0,0 +1,12 @@
+import { Node } from "../../types.service";
+import * as i0 from "@angular/core";
+export declare class NodeService {
+    API: any;
+    constructor(apiInjected: any);
+    updateNode(input: any): Promise<Node>;
+    deleteNode(id: string): Promise<Node>;
+    getNode(id: string): Promise<Node>;
+    createNode(input: Node): Promise<Node>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NodeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NodeService>;
+}

package/lib/services/models/operation.service.d.ts

@@ -0,0 +1,15 @@
+import { Operation, Ticket } from "../../types.service";
+import * as i0 from "@angular/core";
+export declare class OperationService {
+    API: any;
+    constructor(apiInjected: any);
+    getOperationsByTicketID(id: string): Promise<Operation[]>;
+    getOperationsByEquipmentID(id: string): Promise<Operation[]>;
+    getTicketsByEquipmentID(id: string): Promise<Ticket[]>;
+    deleteOperationsForEquipment(equipID: string): Promise<Operation[]>;
+    deleteOperationsForTicket(ticketID: string): Promise<void>;
+    deleteOperation(operationID: string): Promise<Operation>;
+    createOperation(operation: Operation): Promise<Operation>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OperationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<OperationService>;
+}

package/lib/services/models/organisation.service.d.ts

@@ -0,0 +1,19 @@
+import { Organisation, Property } from "../../types.service";
+import * as i0 from "@angular/core";
+export declare class OrganisationService {
+    smarterPlanID: string;
+    API: any;
+    constructor(apiInjected: any);
+    getPropertiesForOrganisation(orgID: string): Promise<Array<Property>>;
+    getOrganisationByToken(token: string): Promise<Organisation>;
+    tokenIsExpiredForOrg(org: Organisation): boolean;
+    softDeteleOrg(orgID: string): Promise<Organisation>;
+    updateOrganisation(input: any): Promise<Organisation>;
+    deleteOrganisation(orgID: string): Promise<Organisation>;
+    createOrganisation(input: Organisation): Promise<Organisation>;
+    getOrganisation(orgID: string): Promise<Organisation>;
+    listOrganisations(): Promise<Organisation[]>;
+    getOrganisationForSpace(spaceID: string): Promise<Organisation>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OrganisationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<OrganisationService>;
+}

package/lib/services/models/plan.service.d.ts

@@ -0,0 +1,117 @@
+import { Subject } from "rxjs";
+import { Router } from "@angular/router";
+import { Plan, PoiType, Zone } from "../../types.service";
+import { BaseVisibilityService } from "../baseVisibility.service";
+import { MatterportService } from "../matterport.service";
+import { ViewerService } from "../viewer.service";
+import { ZoneService } from "./zone.service";
+import { NavigationService } from "./navigation.service";
+import { BaseTagService } from "../tag.service";
+import { Config } from "../../config";
+import * as i0 from "@angular/core";
+export declare class PlanService {
+    private zoneService;
+    private navigationService;
+    private viewerService;
+    private router;
+    private matterportService;
+    private visibilityService;
+    chosenPlan: Plan;
+    currentPlan: Plan;
+    currentSweep: string;
+    planFileCache: File;
+    planCanvas: any;
+    planDiv: HTMLElement | SVGElement;
+    panzoom: any;
+    isReady: boolean;
+    userPositionBtn: HTMLButtonElement;
+    coeffPlanX: number;
+    coeffPlanY: number;
+    calibrationPlan: any;
+    detailTagDiv: HTMLElement;
+    detailTagDivIsHover: boolean;
+    btnTagIsHover: boolean;
+    resizePlanSubscription: Subject<boolean>;
+    imgPlan: HTMLImageElement;
+    lastTouchTime: number;
+    delayDblTouch: number;
+    htmlContentToInject: {
+        title: string;
+        content: string;
+        elementID: string;
+        y: number;
+        x: number;
+        tagIcon: string;
+        url: string;
+    }[];
+    cache: {
+        equipIDs: string[];
+        ticketIDs: string[];
+        measurementsIDs: string[];
+        featureIDs: string[];
+        zoneID: string;
+        plan: Plan;
+        htmlContent: {
+            title: string;
+            content: string;
+            elementID: string;
+            y: number;
+            x: number;
+            tagIcon: string;
+            url: string;
+        }[];
+    };
+    focusMouseTagDiv: boolean;
+    API: any;
+    constructor(apiInjected: any, zoneService: ZoneService, navigationService: NavigationService, viewerService: ViewerService, router: Router, matterportService: MatterportService, visibilityService: BaseVisibilityService);
+    createPlan(planInput: Plan): Promise<Plan>;
+    deletePlan(plan: Plan): Promise<Plan>;
+    getPlansForSpace(spaceID: string): Promise<Plan[]>;
+    getPlansForZone(zoneID: string): Promise<Plan[]>;
+    getSingedPlansForSpace(spaceID: string): Promise<Plan[]>;
+    getPlansWithZonesForSpace(spaceID: string): Promise<Plan[]>;
+    setChosenPlan(chosenPlan: Plan): void;
+    getChosenPlan(): Plan;
+    setPlanFileCache(planFileCache: File): Promise<void>;
+    getPlanFileCache(): File;
+    createPlanWithAnnexe(plan: Plan, file: File): Promise<Plan>;
+    updatePlan(plan: any): Promise<Plan>;
+    updatePlanFile(): Promise<string>;
+    setAllPlansForZoneNotCurrent(zoneID: string, currentPlanID: string): Promise<void>;
+    configurePlan(currentPlan: Plan, divId?: string): Promise<boolean>;
+    clearPlanImage(): void;
+    drawPdf(currentPlan: Plan): Promise<void>;
+    drawElement(element: any, tagType: PoiType, currentPlan: Plan, tagService: BaseTagService, config: Config): Promise<void>;
+    drawUserPosition(currentSweep?: string): Promise<void>;
+    removeCurrentPosition(): void;
+    styleButton(button: HTMLButtonElement, url: string): void;
+    addListenersToButton(button: HTMLButtonElement, url: string): void;
+    clearBtn(idList: any[]): void;
+    clearAllButtons(): void;
+    onPlanRemove(): void;
+    resizePlan(isRemoving: boolean): Promise<void>;
+    handleTouch(event: any): void;
+    onDblClickPlan(event: any): Promise<void>;
+    /**
+     * Configures plan from cache (previous plan).
+     */
+    uploadPlanFromCache(): Promise<void>;
+    /**
+     * Puts buttons (tags) from cache according to passed element IDs (for filter if any)
+     * @param elementIDs elements (tickets, equipments, etc) to be shown on plan
+     */
+    uploadTagsFromCache(): void;
+    getCalibratedPlanForZone(zone: Zone): Promise<Plan>;
+    transformPosition3DForNewCalibration(position: {
+        x: number;
+        y: number;
+        z: number;
+    }): {
+        x: number;
+        y: number;
+        coeffX: number;
+        coeffY: number;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<PlanService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PlanService>;
+}

package/lib/services/models/poi.service.d.ts

@@ -0,0 +1,15 @@
+import { POI, PoiType } from "../../types.service";
+import * as i0 from "@angular/core";
+export declare class PoiService {
+    API: any;
+    constructor(apiInjected: any);
+    getPoiByElementId(elementId: string): Promise<POI | null>;
+    getPoisByType(type: PoiType): Promise<[POI] | any>;
+    createPOIForSpaceID(poi: POI): Promise<POI>;
+    poiIsVirtual(poi: POI): boolean;
+    updatePoi(poi: {}): Promise<POI>;
+    deletePoi(poiID: string): Promise<POI>;
+    getPoisByMatterportSweepByType(sweep: string, type: PoiType): Promise<POI[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PoiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PoiService>;
+}

package/lib/services/models/profile.service.d.ts

@@ -0,0 +1,15 @@
+import { Profile } from "../../types.service";
+import * as i0 from "@angular/core";
+export declare class ProfileService {
+    API: any;
+    constructor(apiInjected: any);
+    createProfile(profile: Profile): Promise<Profile>;
+    getProfile(id: string): Promise<Profile>;
+    updateProfile(profile: any): Promise<Profile>;
+    deleteProfile(id: string): Promise<Profile>;
+    getProfileFromAWSID(userID: string): Promise<Profile>;
+    getUsersForMail(mail: string): Promise<Profile[]>;
+    getProfilesForStatus(status: string): Promise<Profile[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProfileService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ProfileService>;
+}

package/lib/services/models/property.service.d.ts

@@ -0,0 +1,13 @@
+import { Property } from "../../types.service";
+import * as i0 from "@angular/core";
+export declare class PropertyService {
+    API: any;
+    constructor(apiInjected: any);
+    createProperty(property: Property): Promise<Property>;
+    deleteProperty(propertyID: string): Promise<Property>;
+    getPropertiesForOrganisation(orgID: string): Promise<Property[]>;
+    listProperties(): Promise<Property[]>;
+    listPropertiesForSpace(spaceID: string): Promise<Property[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PropertyService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PropertyService>;
+}

package/lib/services/models/space.service.d.ts

@@ -0,0 +1,38 @@
+import { Subject } from "rxjs";
+import { Space, Layer } from "../../types.service";
+import { BaseUserService } from "../user.service";
+import { CaptureService } from "./capture.service";
+import { MissionService } from "./mission.service";
+import { PropertyService } from "./property.service";
+import { VisitService } from "./visit.service";
+import * as i0 from "@angular/core";
+export declare class SpaceService {
+    private visitService;
+    private userService;
+    private propertyService;
+    private captureService;
+    private missionService;
+    locationsForUser: Space[];
+    locationUpdated: Subject<Space[]>;
+    API: any;
+    constructor(visitService: VisitService, userService: BaseUserService, propertyService: PropertyService, captureService: CaptureService, missionService: MissionService, apiInjected: any);
+    listSpaces(): Promise<Space[]>;
+    getLocationsForCurrentUser(): Promise<Space[]>;
+    signUrlForSpace(loc: Space): Promise<void>;
+    getAllowedSpacesForOrg(orgID: string, userOrgID: string): Promise<Space[]>;
+    getSpacesForOrg(orgID: string): Promise<Space[]>;
+    createSpace(values: Space, layer?: Layer): Promise<any>;
+    updateSpace(input: any): Promise<Space>;
+    getSpace(id: string): Promise<Space>;
+    getModel3DForSpace(spaceID: string): Promise<string>;
+    getAllowedModel3DForSpace(spaceID: string): Promise<string>;
+    softDeleteSpace(spaceID: string): Promise<void>;
+    /**
+     * If current user can archive a space (only if his organisation is owning the property (PropertyType.PROPERTY))
+     * @param spaceID
+     * @returns
+     */
+    canArchiveSpace(spaceID: string): Promise<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpaceService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SpaceService>;
+}

package/lib/services/models/template.service.d.ts

@@ -0,0 +1,15 @@
+import { VisitTemplate } from "../../types.service";
+import * as i0 from "@angular/core";
+export declare class TemplateService {
+    API: any;
+    constructor(apiInjected: any);
+    create(template: VisitTemplate): Promise<VisitTemplate>;
+    update(template: any): Promise<VisitTemplate>;
+    detele(templateID: string): Promise<VisitTemplate>;
+    softDelete(templateID: string): Promise<VisitTemplate>;
+    get(templateID: string): Promise<VisitTemplate>;
+    getTemplatesBySpace(spaceID: string): Promise<VisitTemplate[]>;
+    getTemplatesByZone(zoneID: string): Promise<VisitTemplate[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TemplateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TemplateService>;
+}

package/lib/services/models/ticket.service.d.ts

@@ -0,0 +1,86 @@
+import { NgbModal } from "@ng-bootstrap/ng-bootstrap";
+import { Subject, Subscription } from "rxjs";
+import { MattertagData } from "../../mattertagData";
+import { Event, Ticket, TicketType, TicketStatus, Affectation, POI, IUpdate } from "../../types.service";
+import { FilterService } from "../filter.service";
+import { NavigatorService } from "../navigator.service";
+import { BaseUserService } from "../user.service";
+import { ViewerService } from "../viewer.service";
+import { BaseObjectService } from "./base-object.service";
+import { NavigationService } from "./navigation.service";
+import { OperationService } from "./operation.service";
+import { PoiService } from "./poi.service";
+import { EventService } from "./event.service";
+import { InterventionService } from "../intervention.service";
+import { AffectationService } from "./affectation.service";
+import * as i0 from "@angular/core";
+export declare class TicketsService extends BaseObjectService {
+    private operationService;
+    private eventService;
+    private affectationService;
+    private userService;
+    private navigatorService;
+    private filterService;
+    private interventionService;
+    private viewerService;
+    private modalService;
+    currentTickets: {
+        zone: Ticket[];
+        space: Ticket[];
+    };
+    ticketTags: Subject<Ticket[]>;
+    ticketsFiltered: Ticket[];
+    ticketsUpdated: Subject<{
+        zone: Ticket[];
+        space: Ticket[];
+    }>;
+    currentSpaceID: string;
+    zoneIDFilter: string;
+    dateFilter: Date[];
+    ticketTypeFilter: TicketType[];
+    reportingIcon: import("@iconify/types").IconifyIcon;
+    maintenanceIcon: import("@iconify/types").IconifyIcon;
+    workorderIcon: import("@iconify/types").IconifyIcon;
+    informationIcon: import("@iconify/types").IconifyIcon;
+    accidentIcon: import("@iconify/types").IconifyIcon;
+    updateDone: Subject<boolean>;
+    updating: Subject<boolean>;
+    API: any;
+    isMuseumUser: boolean;
+    navSubscription: Subscription;
+    filetrSubscription: Subscription;
+    constructor(apiInjected: any, operationService: OperationService, eventService: EventService, affectationService: AffectationService, poiService: PoiService, userService: BaseUserService, navigatorService: NavigatorService, filterService: FilterService, interventionService: InterventionService, navigationService: NavigationService, viewerService: ViewerService, modalService: NgbModal);
+    initTickets(): Promise<void>;
+    adaptTicket(ticket: Ticket): Promise<Ticket>;
+    getPriorityColor(ticket: Ticket): string;
+    getStatusColor(ticket: Ticket): string;
+    getTicketPriorityNumber(t: any): number;
+    getTicketIcon(type: TicketType): any;
+    addEventToTicket(ticket: Ticket, event: Event): Promise<Event>;
+    addTicket(ticket: Ticket): Promise<Ticket | void>;
+    updateTicketWithEvent(ticket: IUpdate & Partial<Ticket>, event?: Event): Promise<Ticket>;
+    removeAssigneeFromTicket(ticket: Ticket, assignee: Affectation): Promise<Ticket>;
+    updateTicketLocation(ticket: Ticket, tagData: MattertagData): Promise<POI>;
+    updateStatusOfTicket(ticket: Ticket, status: TicketStatus): Promise<any>;
+    updateTypeOfTicket(ticket: Ticket, type: TicketType): Promise<any>;
+    getTicketsForUserForSpace(spaceID: string): Promise<Ticket[]>;
+    /** Basic CRUD operations */
+    readTicket(id: string): Promise<any>;
+    createTicket(input: Ticket): Promise<Ticket>;
+    updateTicket(input: IUpdate & Partial<Ticket>): Promise<Ticket>;
+    deleteTicket(ticket: Ticket): Promise<Ticket>;
+    /** Custom requests */
+    getTicketsBySpace(spaceID: string): Promise<Ticket[]>;
+    updateIconForAllTicketsInSpace(tagIcon: string, spaceID: string): Promise<{
+        tickets: Ticket[];
+        pois: POI[];
+    }>;
+    /** Archive related */
+    /** Return true if the current user has archived this ticket */
+    isArchived(ticket: Ticket): boolean;
+    setArchived(ticket: Ticket, archived: boolean): Promise<Ticket>;
+    navigateToTicketIn3D(ticket: Ticket, forceSwitchVisit?: boolean): Promise<void>;
+    initSubscriptions(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TicketsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TicketsService>;
+}

package/lib/services/models/visit.service.d.ts

@@ -0,0 +1,24 @@
+import { Plan, Space, Visit, Zone } from "../../types.service";
+import { BaseUserService } from "../user.service";
+import { CaptureService } from "./capture.service";
+import { NavigationService } from "./navigation.service";
+import { NodeService } from "./node.service";
+import { PlanService } from "./plan.service";
+import { ZoneService } from "./zone.service";
+import * as i0 from "@angular/core";
+export declare class VisitService {
+    private captureService;
+    private nodeService;
+    private navigationService;
+    private zoneService;
+    private planService;
+    private userService;
+    choosenPlan: Plan;
+    constructor(captureService: CaptureService, nodeService: NodeService, navigationService: NavigationService, zoneService: ZoneService, planService: PlanService, userService: BaseUserService);
+    getVisitsForSpaceForUser(spaceID: string): Promise<Visit[]>;
+    deleteVisit(visit: Visit, spaceID: string): Promise<any>;
+    loadImagesForSpace(space: Space): Promise<any>;
+    getDefaultZoneForVisit(visit: Visit): Promise<Zone>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisitService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<VisitService>;
+}

package/lib/services/models/zone.service.d.ts

@@ -0,0 +1,25 @@
+import { DbObjectType, Zone } from "../../types.service";
+import { BaseUserService } from "../user.service";
+import * as i0 from "@angular/core";
+export declare class ZoneService {
+    private userService;
+    API: any;
+    constructor(apiInjected: any, userService: BaseUserService);
+    getZonesBySpace(spaceID: string): Promise<Array<Zone>>;
+    getZonesBySpaceForUser(spaceID: string): Promise<Zone[]>;
+    filterZonesIDsForUser(zones: Zone[]): Promise<Zone[]>;
+    deleteZone(zoneID: string): Promise<Zone>;
+    getZonesForSweepForSpace(sweepID: string, spaceID: string): Promise<Zone[]>;
+    sortZonesFromChildToParent(zonesToSort: Zone[]): Zone[];
+    getZonesForObject(object: DbObjectType): Promise<Zone[]>;
+    createVirtualZone(zoneInput: Zone): Promise<Zone>;
+    zoneIsVirtual(zone: Zone): boolean;
+    getModel3DForZone(zoneID: string): Promise<string>;
+    getZone(zoneID: string): Promise<Zone>;
+    getDefaultZoneForSpace(spaceID: string): Promise<Zone>;
+    create(input: Zone): Promise<Zone>;
+    updateZone(input: any): Promise<Zone>;
+    getZonesForNodeForSpace(nodeID: string, spaceID: string): Promise<Zone[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ZoneService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ZoneService>;
+}

package/lib/services/navigator.service.d.ts

@@ -0,0 +1,55 @@
+import { Subject } from "rxjs";
+import { Zone } from "../types.service";
+import { MatterportService } from "./matterport.service";
+import { ZoneService } from "./models/zone.service";
+import { BaseUserService } from "./user.service";
+import { ViewerService } from "./viewer.service";
+import * as i0 from "@angular/core";
+export declare class NavigatorService {
+    private matterportService;
+    private viewerService;
+    private zoneService;
+    private userService;
+    currentSweep: string | null;
+    targetSweep: string | null;
+    targetRotation: {
+        x: number;
+        y: number;
+    } | null;
+    currentModel3D: string | null;
+    currentSpaceID: string | null;
+    currentZone: Zone | null;
+    visitLastPosition: Map<string, {
+        sweep: string;
+        rotation: any;
+    }>;
+    floorToGo: Zone | null;
+    locationIDChange: Subject<string | null>;
+    zoneChange: Subject<Zone | null>;
+    navBarZoneIDChange: Subject<string | null>;
+    isVisibleChanged: Subject<boolean>;
+    currentNavBarLocationID: string;
+    currentNavBarZoneID: string;
+    zonesSortedForCurrentSweep: Zone[] | null;
+    zonesForUserChange: Subject<Zone[] | null>;
+    zonesForUserForSpace: Zone[] | null;
+    queueSweeps: string[];
+    constructor(matterportService: MatterportService, viewerService: ViewerService, zoneService: ZoneService, userService: BaseUserService);
+    getLastPositionForModel(model3D: string): {
+        sweep: string;
+        rotation: any;
+    };
+    goToSweepWithRotation(sweep: string, rotation?: {
+        x: number;
+        y: number;
+    } | null): void;
+    goToFloor(floor: Zone): void;
+    onViewerLoaded(): Promise<void>;
+    checkRotationForSweep(sweep: string): {
+        x: number;
+        y: number;
+    } | null;
+    setZonesForCurrentSweep(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavigatorService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NavigatorService>;
+}

package/lib/services/s3.service.d.ts

@@ -0,0 +1,13 @@
+import { Equipment } from "../types.service";
+export declare const deleteFromS3: (path: any) => Promise<void>;
+export declare const uploadFileToS3: (path: string, file: File, objectId: string | null) => Promise<string>;
+export declare const getSignedImageUrlForEquipment: (equip: Equipment) => Promise<string | null>;
+export declare const getSignedImageUrlForProfile: (profile: any) => Promise<string | void>;
+export declare const getSignedImageUrlForSpace: (space: any) => Promise<string | void>;
+export declare const uploadBase64Image: (uri: string, objectId: string | null, path: string, friendlyFileName: string) => Promise<string>;
+export declare const removeAllFilesFromFolderS3: (folderPath: string) => Promise<any>;
+export declare const listFilesInFolder: (folderPath: string) => Promise<any>;
+export declare const getSignedFile: (path: any) => Promise<string | null>;
+export declare const downloadFileAsObject: (path: any) => Promise<Object | void>;
+export declare const getBufferForFileFromS3: (path: any) => Promise<ArrayBuffer>;
+export declare const uploadJsonToS3: (path: string, json: string, filename: string) => Promise<string>;

package/lib/services/search.service.d.ts

@@ -0,0 +1,20 @@
+import { FilterService } from "./filter.service";
+import { EquipmentService } from "./models/equipment.service";
+import * as i0 from "@angular/core";
+export declare enum SearchObjectType {
+    USER = "USER",
+    EQUIPMENT = "EQUIPMENT",
+    TICKET = "TICKET",
+    LOCATION = "LOCATION",
+    FEATURE = "FEATURE",
+    TEMPLATE = "TEMPLATE"
+}
+export declare class SearchService {
+    private filterService;
+    private equipmentService;
+    constructor(filterService: FilterService, equipmentService: EquipmentService);
+    searchForTermForTypeInMap(term: string, objectType: SearchObjectType, searchable: any): Promise<any>;
+    searchForTermForTypeInList(term: string, objectType: SearchObjectType, searchable: any[]): Promise<any[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SearchService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SearchService>;
+}

package/lib/services/support.service.d.ts

@@ -0,0 +1,17 @@
+import { NgbModal } from "@ng-bootstrap/ng-bootstrap";
+import * as i0 from "@angular/core";
+export declare class SupportService {
+    modalService: NgbModal;
+    modalReference: any;
+    constructor(modalService: NgbModal);
+    /**
+     * Open the support form
+     */
+    openSupportForm(formComponent: any): void;
+    /**
+     * Send support request to jira
+     */
+    sendSupport(data: any): Promise<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SupportService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SupportService>;
+}

package/lib/services/tag.service.d.ts

@@ -0,0 +1,45 @@
+import { Comment, DbObjectType, Equipment, Feature, POI, PoiType, Ticket } from "../types.service";
+import * as i0 from "@angular/core";
+export declare class BaseTagService {
+    constructor();
+    getHtmlToInject(tagType: PoiType, object: DbObjectType, maxHeightDiv: number): Promise<{
+        html: string;
+        height: number;
+    }>;
+    getUrlForSeeDetails(object: DbObjectType, tagType: PoiType): string;
+    prepareEquipmentHtml(equip: Equipment): Promise<{
+        htmlObject: string;
+        height: number;
+    }>;
+    prepareTicketHtml(ticket: Ticket): Promise<{
+        htmlObject: string;
+        height: number;
+    }>;
+    prepareFeatureHtml(feature: Feature): Promise<{
+        htmlObject: string;
+        height: number;
+    }>;
+    prepareMeasurementHtml(measure: Comment): Promise<{
+        htmlObject: string;
+        height: number;
+    }>;
+    prepareDeskHtml(feature: Feature): Promise<{
+        htmlObject: string;
+        height: number;
+    }>;
+    prepareIndicatorHtml(feature: Feature): Promise<{
+        htmlObject: string;
+        height: number;
+    }>;
+    getSignedTagIconSource(tagIconSrc: string): Promise<string | null>;
+    getIconTagImageForFeature(feature: DbObjectType, poi: POI): string;
+    getScriptForTag(object: any, tagType: PoiType): string;
+    onActionDetailClick(url: string): void;
+    onActionAudioClick(audioCommentID: string): void;
+    onActionVideoClick(url: string): void;
+    onActionImageClick(imageCommentID: string): void;
+    onActionDocClick(url: string): void;
+    onActionYoutubeClick(url: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseTagService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BaseTagService>;
+}