mobioffice-cli 1.0.0 → 1.0.2

package/lib/models/contact-us/resquest.model.d.ts

@@ -0,0 +1,30 @@
+import * as admin from "firebase-admin";
+declare class Request {
+    id: string;
+    message: string;
+    phone: string;
+    firstName: string;
+    lastName: string;
+    email: string;
+    private _sendUpdates;
+    get sendUpdates(): boolean;
+    set sendUpdates(value: boolean);
+    constructor();
+    argConstructor(id: string, message: string, phone: string, firstName: string, lastName: string, email: string, _sendUpdates: boolean): void;
+    fromJSON(request: string): void;
+    toJSON(): {
+        id: string;
+        message: string;
+        phone: string;
+        firstName: string;
+        lastName: string;
+        email: string;
+        sendUpdates: boolean;
+    };
+    save(firestore: admin.firestore.Firestore): Promise<{
+        status: string;
+        message: string;
+        path: string;
+    }>;
+}
+export { Request };

package/lib/models/contact-us/resquest.model.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Request = void 0;
+class Request {
+    id;
+    message;
+    phone;
+    firstName;
+    lastName;
+    email;
+    _sendUpdates;
+    get sendUpdates() {
+        return this._sendUpdates;
+    }
+    set sendUpdates(value) {
+        this._sendUpdates = value;
+    }
+    constructor() { }
+    argConstructor(id, message, phone, firstName, lastName, email, _sendUpdates) {
+        this.id = id;
+        this.message = message;
+        this.phone = phone;
+        this.firstName = firstName;
+        this.lastName = lastName;
+        this.email = email;
+        this._sendUpdates = _sendUpdates;
+    }
+    fromJSON(request) {
+        let requestJSON = JSON.parse(request);
+        this.id = requestJSON["phone"];
+        this.message = requestJSON["message"];
+        this.phone = requestJSON["phone"];
+        this.firstName = requestJSON["firstName"];
+        this.lastName = requestJSON["lastName"];
+        this.email = requestJSON["email"];
+        this._sendUpdates = requestJSON["sendUpdates"];
+    }
+    toJSON() {
+        return {
+            id: this.phone,
+            message: this.message,
+            phone: this.phone,
+            firstName: this.firstName,
+            lastName: this.lastName,
+            email: this.email,
+            sendUpdates: this._sendUpdates
+        };
+    }
+    async save(firestore) {
+        let requestDoc = firestore
+            .collection("Requests")
+            .doc(this.phone.toString());
+        const requestDocInfo = await requestDoc.get();
+        const reqsInfo = requestDocInfo.data();
+        if (reqsInfo) {
+            reqsInfo.requests.push(this.toJSON());
+            await requestDoc.set(reqsInfo);
+        }
+        else {
+            const newRequest = {
+                id: this.phone,
+                requests: [this.toJSON()]
+            };
+            await requestDoc.set(newRequest);
+        }
+        return {
+            status: "OK",
+            message: "Request Added Successfully",
+            path: requestDoc.path,
+        };
+    }
+}
+exports.Request = Request;

package/lib/models/crud/crud.d.ts

@@ -0,0 +1,7 @@
+import { Pool, RowDataPacket, ResultSetHeader, OkPacket } from 'mysql2';
+declare class CurdService {
+    private pool;
+    constructor(pool: Pool);
+    query(queryString: string): Promise<RowDataPacket[] | ResultSetHeader | OkPacket>;
+}
+export default CurdService;

package/lib/models/crud/crud.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class CurdService {
+    pool;
+    constructor(pool) {
+        this.pool = pool;
+    }
+    async query(queryString) {
+        return new Promise((resolve, reject) => {
+            this.pool.getConnection((err, connection) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                connection.query(queryString, (err, result) => {
+                    connection.release();
+                    if (err) {
+                        reject(err);
+                        return;
+                    }
+                    resolve(result);
+                });
+            });
+        });
+    }
+}
+exports.default = CurdService;

package/lib/models/customCollection.model.d.ts

@@ -0,0 +1,9 @@
+import * as admin from "firebase-admin";
+declare class CustomCollection {
+    id: string;
+    static createCustomCollection(firestore: admin.firestore.Firestore, collectionDetails: any): Promise<void>;
+    static createNewCollection(firestore: admin.firestore.Firestore, collectionDetails: any): Promise<any>;
+    static restructureDetails(collectionDetails: any): Promise<any>;
+    static getUserWorkAreaList(firestore: admin.firestore.Firestore, companyId: string, phone: string): Promise<admin.firestore.DocumentData | undefined>;
+}
+export { CustomCollection };

package/lib/models/customCollection.model.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomCollection = void 0;
+const user_model_1 = require("./user.model");
+class CustomCollection {
+    id = "";
+    static async createCustomCollection(firestore, collectionDetails) {
+        try {
+            let collection_snapshot = await firestore.collection("customCollection")
+                .get();
+            if (collection_snapshot.empty) {
+                console.log("no collection found: creating one...");
+                await CustomCollection.createNewCollection(firestore, collectionDetails);
+            }
+            else {
+                throw new Error("there is already a collection with this name.");
+            }
+        }
+        catch (error) {
+            console.log(error);
+        }
+    }
+    static async createNewCollection(firestore, collectionDetails) {
+        let restructuredDetails = await CustomCollection.restructureDetails(collectionDetails);
+        let docRef = firestore.collection("CustomCollections").doc();
+        restructuredDetails.id = docRef.id;
+        await docRef.set(restructuredDetails);
+        return restructuredDetails;
+    }
+    static async restructureDetails(collectionDetails) {
+        // for now collectionDetails remain unaltered
+        return collectionDetails;
+    }
+    static async getUserWorkAreaList(firestore, companyId, phone) {
+        let userId = await user_model_1.User.getUserIdByPhone(firestore, phone);
+        let workAreaSnapShot = await firestore.collection("CustomCollections").doc(companyId).collection("Users").doc(userId).get();
+        return workAreaSnapShot.data();
+    }
+}
+exports.CustomCollection = CustomCollection;

package/lib/models/customer/customer.model.d.ts

@@ -0,0 +1,32 @@
+declare class Customer {
+    customerName: string;
+    address: string;
+    zipcode: string;
+    city: string;
+    state: string;
+    GSTNo: string;
+    contactName: string;
+    contactNo: string;
+    constructor(customerName: string, address: string, zipcode: string, city: string, state: string, GSTNo: string, contactName: string, contactNo: string);
+}
+declare class CustomerContact {
+    customerId: number;
+    contactName: string;
+    contactNo: string;
+    alternateContactNo: string;
+    designation: string;
+    constructor(customerId: number, contactName: string, contactNo: string, alternateContactNo: string, designation: string);
+}
+declare class CustomerCard {
+    companyId: string;
+    userId: string;
+    createdAt: string;
+    actionName: string;
+    actionType: string;
+    actionId: string;
+    actionEvent: string;
+    extraData: any;
+    id: string;
+    constructor(companyId: string, userId: string, createdAt: string, actionName: string, actionType: string, actionId: string, actionEvent: string, extraData: any, id: string);
+}
+export { Customer, CustomerContact, CustomerCard };

package/lib/models/customer/customer.model.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomerCard = exports.CustomerContact = exports.Customer = void 0;
+class Customer {
+    customerName;
+    address;
+    zipcode;
+    city;
+    state;
+    GSTNo;
+    contactName;
+    contactNo;
+    constructor(customerName, address, zipcode, city, state, GSTNo, contactName, contactNo) {
+        this.customerName = customerName;
+        this.address = address;
+        this.zipcode = zipcode;
+        this.city = city;
+        this.state = state;
+        this.GSTNo = GSTNo;
+        this.contactName = contactName;
+        this.contactNo = contactNo;
+    }
+}
+exports.Customer = Customer;
+class CustomerContact {
+    customerId;
+    contactName;
+    contactNo;
+    alternateContactNo;
+    designation;
+    constructor(customerId, contactName, contactNo, alternateContactNo, designation) {
+        this.customerId = customerId;
+        this.contactName = contactName;
+        this.contactNo = contactNo;
+        this.alternateContactNo = alternateContactNo;
+        this.designation = designation;
+    }
+}
+exports.CustomerContact = CustomerContact;
+class CustomerCard {
+    companyId;
+    userId;
+    createdAt;
+    actionName;
+    actionType;
+    actionId;
+    actionEvent;
+    extraData;
+    id;
+    constructor(companyId, userId, createdAt, actionName, actionType, actionId, actionEvent, extraData, id) {
+        this.companyId = companyId;
+        this.userId = userId;
+        this.createdAt = createdAt;
+        this.actionName = actionName;
+        this.actionType = actionType;
+        this.actionId = actionId;
+        this.actionEvent = actionEvent;
+        this.extraData = extraData;
+        this.id = id;
+    }
+}
+exports.CustomerCard = CustomerCard;

package/lib/models/deviceChangeReq.d.ts

@@ -0,0 +1,10 @@
+import * as admin from "firebase-admin";
+declare class DeviceChangeReq {
+    static checkIsReqPending(firestore: admin.firestore.Firestore, deviceChangeInfo: any, company: string): Promise<boolean>;
+    static fetchOpenReqs(firestore: admin.firestore.Firestore, companyId: string): Promise<admin.firestore.DocumentData[]>;
+    static approve(firestore: admin.firestore.Firestore, approvalDetails: any): Promise<void>;
+    static replaceOldDeviceWithNew(license: any, objToProcess: any): Promise<any>;
+    static getIndexToReplace(extraDevices: any, deviceId: string): Promise<number | "not found">;
+    static updateCompanyActionDoc(firestore: admin.firestore.Firestore, requestId: string, requestStatus: string): Promise<void>;
+}
+export { DeviceChangeReq };

package/lib/models/deviceChangeReq.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceChangeReq = void 0;
+const action_model_1 = require("./action.model");
+const company_model_1 = require("./company.model");
+class DeviceChangeReq {
+    static async checkIsReqPending(firestore, deviceChangeInfo, company) {
+        const newDeviceId = deviceChangeInfo.extra.extraData.deviceId;
+        const nickName = "mobiOffice";
+        const requestCompanyId = await company_model_1.Company.getCompanyIdByNickName(firestore, company);
+        console.log("requestCompanyId", requestCompanyId);
+        const companyId = await company_model_1.Company.getCompanyIdByNickName(firestore, nickName);
+        const actionName = deviceChangeInfo.actionName;
+        let isReqPending = false;
+        console.log("companyId", companyId, "actionName", actionName);
+        const actionId = await action_model_1.Action.getActionId(firestore, companyId, actionName);
+        console.log(companyId, requestCompanyId);
+        const deviceChangeReqs = await firestore.collection("Companies")
+            .doc(companyId)
+            .collection("Actions")
+            .doc(actionId)
+            .collection(actionName)
+            .where("reqCompanyId", "==", requestCompanyId)
+            .get();
+        deviceChangeReqs.forEach((doc) => {
+            console.log("compare", doc.data().extraData.deviceId, newDeviceId, doc.data().isProcessed);
+            if (doc.data().extraData.deviceId === newDeviceId
+                && doc.data().isProcessed === false) {
+                isReqPending = true;
+            }
+        });
+        return isReqPending;
+    }
+    static async fetchOpenReqs(firestore, companyId) {
+        const nickName = "mobiOffice";
+        const supportCompanyId = await company_model_1.Company.getCompanyIdByNickName(firestore, nickName);
+        const actionName = "requestForm";
+        const actionId = await action_model_1.Action.getActionId(firestore, supportCompanyId, actionName);
+        const allRequestsDocs = await firestore.collection("Companies")
+            .doc(supportCompanyId)
+            .collection("Actions")
+            .doc(actionId)
+            .collection(actionName)
+            .get();
+        let allRequestsData = allRequestsDocs.docs.map((doc) => {
+            return doc.data();
+        });
+        let openRequests = allRequestsData.filter((doc) => {
+            return doc.reqCompanyId === companyId && !doc.isProcessed;
+        });
+        return openRequests;
+    }
+    static async approve(firestore, approvalDetails) {
+        const extraData = approvalDetails.extra.extraData;
+        const companyId = extraData.companyNameId;
+        const requestId = extraData.requestId;
+        const requestStatus = extraData.approval;
+        const openRequests = await this.fetchOpenReqs(firestore, companyId);
+        const objToProcess = [];
+        openRequests.forEach(async (doc) => {
+            if (doc.eventId === requestId) {
+                objToProcess.push(doc);
+            }
+        });
+        if (objToProcess.length !== 0) {
+            const licenseDoc = await firestore.collection("Licenses")
+                .where("company", "==", objToProcess[0].company)
+                .where("user", "==", `+${objToProcess[0].extraData.phone}`)
+                .get();
+            let license = licenseDoc.docs.map((doc) => {
+                return doc.data();
+            })[0];
+            const updatedLicense = await this.replaceOldDeviceWithNew(license, objToProcess[0]);
+            console.log(updatedLicense);
+            if (updatedLicense) {
+                licenseDoc.forEach(doc => {
+                    doc.ref.set(updatedLicense);
+                });
+            }
+            await this.updateCompanyActionDoc(firestore, requestId, requestStatus);
+        }
+        else {
+            throw new Error("no documents to process");
+        }
+    }
+    static async replaceOldDeviceWithNew(license, objToProcess) {
+        const extraDevices = license.extraDevices;
+        const newDeviceObj = {
+            fromDate: Date.now(),
+            modelName: objToProcess.extraData.model,
+            brandName: objToProcess.extraData.brand,
+            deviceId: objToProcess.extraData.deviceId
+        };
+        const indexToReplace = await this.getIndexToReplace(extraDevices, objToProcess.extraData.oldDeviceId);
+        if (indexToReplace === "not found") {
+            return null;
+        }
+        extraDevices.splice(indexToReplace, 1, newDeviceObj);
+        license.extraDevices = extraDevices;
+        return license;
+    }
+    static async getIndexToReplace(extraDevices, deviceId) {
+        for (let i = 0; i < extraDevices.length; i++) {
+            if (extraDevices[i].deviceId === deviceId) {
+                return i;
+            }
+        }
+        return "not found";
+    }
+    static async updateCompanyActionDoc(firestore, requestId, requestStatus) {
+        const companyId = await company_model_1.Company.getCompanyIdByNickName(firestore, "mobiOffice");
+        const actionName = "requestForm";
+        const actionId = await action_model_1.Action.getActionId(firestore, companyId, actionName);
+        const doc = await firestore.collection("Companies")
+            .doc(companyId)
+            .collection("Actions")
+            .doc(actionId)
+            .collection(actionName)
+            .doc(requestId)
+            .get();
+        await doc.ref.update({
+            isProcessed: true,
+            approval: requestStatus
+        });
+        const supportUsers = await company_model_1.Company.getUsersListbyCompany(firestore, "mobiOffice");
+        for (let user of supportUsers) {
+            const docRef = await firestore.collection("Feeds").doc(user.id).collection(companyId).doc(requestId).get();
+            const docData = docRef.data();
+            const extraData = docData?.extraData;
+            extraData["approval"] = requestStatus;
+            await firestore.collection("Feeds").doc(user.id).collection(companyId).doc(requestId).update({
+                isProcessed: true,
+                extraData: extraData
+            });
+        }
+    }
+}
+exports.DeviceChangeReq = DeviceChangeReq;

package/lib/models/dispatch.model.d.ts

@@ -0,0 +1,14 @@
+import { Post } from "./post.model";
+import * as admin from "firebase-admin";
+declare class Dispatch extends Post {
+    actionEvent: string;
+    actionType: string;
+    actionName: string;
+    customerName: string;
+    static createPostforDispatch(firestore: admin.firestore.Firestore, postInfo: any, uniqueId: string): Promise<unknown>;
+    static createPostForSODispatch(firestore: admin.firestore.Firestore, postInfo: any, status: string): Promise<unknown>;
+    static setIncomingInfoToDispatch(info: any, post: Dispatch): Promise<Dispatch>;
+    static modifyExtraDataForDispatch(info: any): Promise<any>;
+    static getSODesignsByDocId(firestore: admin.firestore.Firestore, uniqueId: string): Promise<any>;
+}
+export { Dispatch };

package/lib/models/dispatch.model.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Dispatch = void 0;
+const post_model_1 = require("./post.model");
+const tempCollection_model_1 = require("./tempCollection.model");
+const user_model_1 = require("./user.model");
+class Dispatch extends post_model_1.Post {
+    actionEvent = "";
+    actionType = "worklog";
+    actionName = "dispatch";
+    customerName = "";
+    static async createPostforDispatch(firestore, postInfo, uniqueId) {
+        let post = new Dispatch();
+        post = await Dispatch.setIncomingInfoToDispatch(postInfo, post);
+        console.log(post);
+        let eventId = await post_model_1.Post.createNewPost(firestore, post);
+        await tempCollection_model_1.TempCollection.deleteTempCollection(firestore, uniqueId);
+        return eventId;
+    }
+    static async createPostForSODispatch(firestore, postInfo, status) {
+        console.log("in create post for dispatch");
+        const userInfo = await user_model_1.User.getUserInfoById(firestore, postInfo.userId, postInfo.companyId);
+        const extraData = postInfo.extra.extraData;
+        extraData.status = status;
+        extraData.time = postInfo.createdAt;
+        extraData.date = new Date(postInfo.createdAt).toLocaleDateString("en-GB");
+        extraData.userName = userInfo.name;
+        console.log(extraData);
+        let post = {
+            ...postInfo,
+            extraData: extraData,
+            actionId: postInfo.extra.actionId,
+            description: postInfo.extra.extraData.customerName,
+            actionType: "worklog"
+        };
+        delete post.extra;
+        console.log(post);
+        console.log("creating post for dispatch");
+        let eventId = await post_model_1.Post.createNewPost(firestore, post);
+        return eventId;
+    }
+    static async setIncomingInfoToDispatch(info, post) {
+        post.actionEvent = info.extra.actionEvent;
+        post.id = info.id;
+        post.customerName = info.customerName;
+        post.actionId = info.extra.actionId;
+        post.companyId = info.extra.companyId;
+        post.createdAt = info.extra.createdAt;
+        post.description = info.description;
+        post.eventId = info.extra.eventId;
+        post.isGeofence = info.extra.isGeofence;
+        post.userId = info.userId;
+        const newExtraData = await this.modifyExtraDataForDispatch(info);
+        post.extraData = newExtraData;
+        post.seen = info.extra.seen;
+        post.startAt = "";
+        post.startLat = info.extra.startLat;
+        post.startLong = info.extra.startLong;
+        post.endAt = "";
+        post.endLat = info.extra.endLat;
+        post.endLong = info.extra.endLong;
+        post.stepValues = info.extra.stepValues;
+        post.time = info.extra.time;
+        post.checkInternet = info.extra.checkInternet;
+        return post;
+    }
+    static async modifyExtraDataForDispatch(info) {
+        const time = info.createdAt;
+        const date = new Date(time).toLocaleDateString("en-GB");
+        const newExtraData = {
+            ...info.extra.extraData,
+            status: "Pending",
+            customerName: info.description.split("--")[0],
+            date: date,
+            time: time
+        };
+        return newExtraData;
+    }
+    static async getSODesignsByDocId(firestore, uniqueId) {
+        try {
+            const storedInfoDoc = await firestore.collection("TempCollection")
+                .doc(uniqueId)
+                .get();
+            const info = storedInfoDoc.data();
+            console.log(info.scannedTakas);
+            return info.scannedTakas;
+        }
+        catch (error) {
+            throw new Error(error.message);
+        }
+    }
+}
+exports.Dispatch = Dispatch;

package/lib/models/feed.models.d.ts

@@ -0,0 +1,8 @@
+import * as admin from 'firebase-admin';
+declare class Feeds {
+    static initFeed(firestore: admin.firestore.Firestore): Promise<string>;
+    static updateFeed(firestore: admin.firestore.Firestore, userId: string, companyId: string, eventId: string, data: any, isError: boolean, lotNo: string): Promise<string>;
+    static updateFeedForUser(firestore: admin.firestore.Firestore, userId: string, companyId: string, eventId: string, data: any, isError: boolean, lotNo: string): Promise<string>;
+    static updateEndMeetingsTimeInFeeds(firestore: admin.firestore.Firestore, userId: string, companyId: string, eventId: string, endTime: number): Promise<"success" | undefined>;
+}
+export { Feeds };

package/lib/models/feed.models.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Feeds = void 0;
+const offline_model_1 = require("./offline.model");
+class Feeds {
+    static async initFeed(firestore) {
+        let document = firestore.collection('Feeds').doc();
+        await document.set({
+            id: document.id,
+        });
+        return "success";
+    }
+    static async updateFeed(firestore, userId, companyId, eventId, data, isError, lotNo) {
+        console.log("going to update cards");
+        await Feeds.updateFeedForUser(firestore, userId, companyId, eventId, data, isError, lotNo);
+        let managersList = await offline_model_1.Offline.getUserManagersList(firestore, companyId, userId);
+        for (let manager of managersList) {
+            await Feeds.updateFeedForUser(firestore, manager, companyId, eventId, data, isError, lotNo);
+        }
+        return "success";
+    }
+    static async updateFeedForUser(firestore, userId, companyId, eventId, data, isError, lotNo) {
+        console.log("received info");
+        let userFeedDoc = await firestore.collection("Feeds").doc(userId).collection(companyId).where("eventId", "==", eventId).get();
+        let description = userFeedDoc.docs[0].data().description || "";
+        let extraData = userFeedDoc.docs[0].data().extraData;
+        const oldUserFeedDoc = userFeedDoc.docs[0].data();
+        delete oldUserFeedDoc.extraData;
+        console.log("deleted extraData from oldUserFeedDoc");
+        extraData = {
+            ...extraData,
+            lotNo,
+            status: data
+        };
+        let newUserFeedDoc = {};
+        if (isError) {
+            console.log("api sent error response");
+            newUserFeedDoc.cardColor = "#FFF44336";
+        }
+        else {
+            console.log("api send success response");
+            if (extraData.toBePrinted) {
+                extraData.print = extraData.toBePrinted;
+                extraData.print["lot_no"] = lotNo;
+                delete extraData.toBePrinted;
+            }
+        }
+        description = `${description}--${data.split(" ").slice(0, 3).join(" ")}`;
+        console.log("updated the description");
+        newUserFeedDoc = {
+            ...oldUserFeedDoc,
+            ...newUserFeedDoc,
+            description: description,
+            extraData: extraData
+        };
+        console.log("going to set the newUserFeedDoc");
+        userFeedDoc.forEach((doc) => {
+            doc.ref.set(newUserFeedDoc);
+        });
+        console.log("done");
+        // userFeedDoc.forEach((doc)=>{
+        //   doc.ref.update({
+        //     description:description,
+        //     extraData:extraData
+        //   })
+        //   if (doc.data().tobePrinted) {
+        //     doc.ref.update({
+        //       print: doc.data().tobePrinted
+        //     })
+        //   }
+        //   if (isError) {
+        //     doc.ref.update({
+        //       cardColor: "#FFF44336"
+        //     })
+        //   }
+        // })
+        return "success";
+    }
+    static async updateEndMeetingsTimeInFeeds(firestore, userId, companyId, eventId, endTime) {
+        let userFeedDoc = await firestore.collection("Feeds").doc(userId).collection(companyId).where("eventId", "==", eventId).get();
+        if (userFeedDoc.docs.length) {
+            let extraData = userFeedDoc.docs[0].data().extraData;
+            extraData = {
+                ...extraData,
+                "End Time": endTime
+            };
+            console.log(extraData);
+            userFeedDoc.forEach((doc) => {
+                doc.ref.update({
+                    extraData: extraData
+                });
+            });
+            return "success";
+        }
+    }
+}
+exports.Feeds = Feeds;

package/lib/models/geofence.model.d.ts

@@ -0,0 +1,7 @@
+import * as admin from "firebase-admin";
+declare class Geofence {
+    static getOrCreateGeoFence(firestore: admin.firestore.Firestore, geofenceDoc: any): Promise<any>;
+    static convertGeofenceDataType(geoFenceDoc: any): Promise<any>;
+    static updateGeofence(firestore: admin.firestore.Firestore, arrayUnion: any, geofenceDoc: any): Promise<string>;
+}
+export { Geofence };