@optimiser/common 1.0.243 → 1.0.247

package/dist/index.d.ts

@@ -8,6 +8,7 @@ export * as helperLib from "./lib/helper";
 export * as _activity from "./lib/activity";
 export * as _operaUtilCommon from "./lib/operautilitycommon";
 export * as taskutils from "./lib/taskutils";
+export { MemoryDBConnect } from "./lib/memoryserverclient";
 export * from "./modals/connection.modal";
 export * from "./modals/redisconfig.modal";
 export * from "./modals/notificationData.modal";

package/dist/index.js

@@ -38,6 +38,8 @@ exports.helperLib = __importStar(require("./lib/helper"));
 exports._activity = __importStar(require("./lib/activity"));
 exports._operaUtilCommon = __importStar(require("./lib/operautilitycommon"));
 exports.taskutils = __importStar(require("./lib/taskutils"));
+var memoryserverclient_1 = require("./lib/memoryserverclient");
+Object.defineProperty(exports, "MemoryDBConnect", { enumerable: true, get: function () { return memoryserverclient_1.MemoryDBConnect; } });
 // Interface Exports
 __exportStar(require("./modals/connection.modal"), exports);
 __exportStar(require("./modals/redisconfig.modal"), exports);

package/dist/lib/connection.d.ts

@@ -1,4 +1,4 @@
-import { Db } from "mongodb";
+import { Db, MongoClient, ClientSession } from "mongodb";
 import { NextFunction, Response } from "express";
 import IORedis from "ioredis";
 import { Sequelize } from "sequelize";
@@ -100,5 +100,17 @@ declare class Connection {
      * @description Helper function to send response
      */
     ReturnJsonResponse: (req: OPT_Request, res: Response, params: ResponseStructure) => void;
+    /**
+     * @param DBName
+     * @returns Promise
+     * @description return session from client
+     */
+    GetDBSession(dbName: string, dbAddress: string): Promise<[Error?, ClientSession?]>;
+    /**
+    * @param DBName
+    * @returns Promise
+    * @description return session from client
+    */
+    GetDBClient(dbName: string, dbAddress: string): Promise<[Error?, MongoClient?]>;
 }
 export { Connection };

package/dist/lib/connection.js

@@ -458,6 +458,102 @@ var Connection = /** @class */ (function () {
     Connection.prototype.GetActiveDBConnections = function () {
         return Object.keys(this.connections);
     };
+    /**
+     * @param DBName
+     * @returns Promise
+     * @description return session from client
+     */
+    Connection.prototype.GetDBSession = function (dbName, dbAddress) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                return [2 /*return*/, new Promise(function (resolve, reject) {
+                        try {
+                            // if (this.connections && this.connections[Buffer.from(this.masterConfig.MASTER_CONNECTION_STRING).toString('base64')]) {
+                            //return this.FindAndReturnDBConnection(DBName, DBAddress)
+                            // if (dbName == this.masterConfig.MASTER_DB_NAME) {
+                            //     resolve([undefined, this.connections[Buffer.from(this.masterConfig.MASTER_CONNECTION_STRING).toString('base64')].startSession()]);
+                            // }
+                            if (_this.connections[Buffer.from(dbAddress).toString('base64')]) {
+                                resolve([undefined, _this.connections[Buffer.from(_this.masterConfig.MASTER_CONNECTION_STRING).toString('base64')].startSession()]);
+                            }
+                            else {
+                                _this.ConnectToDb({
+                                    DBAddress: dbAddress,
+                                    DBName: dbName
+                                }).then(function (success) {
+                                    if (_this.connections[Buffer.from(dbAddress).toString('base64')]) {
+                                        resolve([undefined, _this.connections[Buffer.from(dbAddress).toString('base64')].startSession()]);
+                                    }
+                                    else {
+                                        resolve([undefined, undefined]);
+                                    }
+                                });
+                            }
+                            // } else {
+                            //     let masterdb = await this.ConnectToDb({
+                            //         DBAddress: this.masterConfig.MASTER_CONNECTION_STRING,
+                            //         DBName: this.masterConfig.MASTER_DB_NAME
+                            //     })
+                            //     return this.FindAndReturnDBConnection(DBName, DBAddress)
+                            // }
+                        }
+                        catch (ex) {
+                            //To Do: Error pass properly
+                            resolve([new Error('Error in Get db session'), undefined]);
+                        }
+                    })];
+            });
+        });
+    };
+    /**
+    * @param DBName
+    * @returns Promise
+    * @description return session from client
+    */
+    Connection.prototype.GetDBClient = function (dbName, dbAddress) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                return [2 /*return*/, new Promise(function (resolve, reject) {
+                        try {
+                            // if (this.connections && this.connections[Buffer.from(this.masterConfig.MASTER_CONNECTION_STRING).toString('base64')]) {
+                            //return this.FindAndReturnDBConnection(DBName, DBAddress)
+                            // if (dbName == this.masterConfig.MASTER_DB_NAME) {
+                            //     resolve([undefined, this.connections[Buffer.from(this.masterConfig.MASTER_CONNECTION_STRING).toString('base64')].startSession()]);
+                            // }
+                            if (_this.connections[Buffer.from(dbAddress).toString('base64')]) {
+                                resolve([undefined, _this.connections[Buffer.from(_this.masterConfig.MASTER_CONNECTION_STRING).toString('base64')]]);
+                            }
+                            else {
+                                _this.ConnectToDb({
+                                    DBAddress: dbAddress,
+                                    DBName: dbName
+                                }).then(function (success) {
+                                    if (_this.connections[Buffer.from(dbAddress).toString('base64')]) {
+                                        resolve([undefined, _this.connections[Buffer.from(dbAddress).toString('base64')]]);
+                                    }
+                                    else {
+                                        resolve([undefined, undefined]);
+                                    }
+                                });
+                            }
+                            // } else {
+                            //     let masterdb = await this.ConnectToDb({
+                            //         DBAddress: this.masterConfig.MASTER_CONNECTION_STRING,
+                            //         DBName: this.masterConfig.MASTER_DB_NAME
+                            //     })
+                            //     return this.FindAndReturnDBConnection(DBName, DBAddress)
+                            // }
+                        }
+                        catch (ex) {
+                            //To Do: Error pass properly
+                            resolve([new Error('Error in Get db session'), undefined]);
+                        }
+                    })];
+            });
+        });
+    };
     return Connection;
 }());
 exports.Connection = Connection;

package/dist/lib/helper.d.ts

@@ -47,8 +47,10 @@ declare const GetEmailSubscribeStatus: (db: Db, email: string) => Promise<Error
  * @param {isSubscribe} boolean
  * @param {companyID} mongodb object id, comany id of email
  * @param {comment} string , to add comment
+ * @param {mongodbQueryOptions} object, params to pass on db queries
+ * @returns resolve success | error object
  */
-declare const SubscribeEmailForAllDomains: (db: Db, email: string, isSubscribe: boolean, companyID: ObjectID, comment?: string) => Promise<unknown>;
+declare const SubscribeEmailForAllDomains: (db: Db, email: string, isSubscribe: boolean, companyID: ObjectID, comment?: string, mongodbQueryOptions?: any) => Promise<unknown>;
 /**
  * checking phone number is valid and has dialing code
  * if it has dialing code then get country code, get its optimiser country phone code

package/dist/lib/helper.js

@@ -687,18 +687,25 @@ exports.GetEmailSubscribeStatus = GetEmailSubscribeStatus;
  * @param {isSubscribe} boolean
  * @param {companyID} mongodb object id, comany id of email
  * @param {comment} string , to add comment
+ * @param {mongodbQueryOptions} object, params to pass on db queries
+ * @returns resolve success | error object
  */
-var SubscribeEmailForAllDomains = function (db, email, isSubscribe, companyID, comment) {
+var SubscribeEmailForAllDomains = function (db, email, isSubscribe, companyID, comment, mongodbQueryOptions) {
     if (comment === void 0) { comment = ""; }
+    if (mongodbQueryOptions === void 0) { mongodbQueryOptions = null; }
     return new Promise(function (resolve, reject) {
         return __awaiter(this, void 0, void 0, function () {
-            var marketingSettingDetail, marketingCategoryKeys, domainIds_1, domainDetail, existEmailSub, isRequireUpdate, marketingCategoryData, _loop_2, i, error_2;
+            var mongodbQueryOpts, marketingSettingDetail, marketingCategoryKeys, domainIds_1, domainDetail, existEmailSub, isRequireUpdate, marketingCategoryData, _loop_2, i, error_2;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         _a.trys.push([0, 7, , 8]);
+                        mongodbQueryOpts = {};
+                        if (mongodbQueryOptions) {
+                            mongodbQueryOpts = mongodbQueryOptions;
+                        }
                         if (!email) return [3 /*break*/, 6];
-                        return [4 /*yield*/, db.collection('Company').findOne({ IsActive: true }, { projection: { "Setting.MarketingSetting": 1 } })];
+                        return [4 /*yield*/, db.collection('Company').findOne({ IsActive: true }, { projection: { "Setting.MarketingSetting": 1 } }, mongodbQueryOpts)];
                     case 1:
                         marketingSettingDetail = _a.sent();
                         marketingCategoryKeys = [], domainIds_1 = [];
@@ -714,7 +721,7 @@ var SubscribeEmailForAllDomains = function (db, email, isSubscribe, companyID, c
                         }
                         existEmailSub = {}, isRequireUpdate = false;
                         if (!(domainIds_1 && domainIds_1.length > 0)) return [3 /*break*/, 4];
-                        return [4 /*yield*/, db.collection('EmailStatus').findOne({ 'EmailID': new RegExp("^" + email + "$", "i"), CompanyID: companyID }, { projection: { "Domains": 1 } })];
+                        return [4 /*yield*/, db.collection('EmailStatus').findOne({ 'EmailID': new RegExp("^" + email + "$", "i"), CompanyID: companyID }, { projection: { "Domains": 1 } }, mongodbQueryOpts)];
                     case 2:
                         existEmailSub = _a.sent();
                         isRequireUpdate = true;
@@ -725,7 +732,7 @@ var SubscribeEmailForAllDomains = function (db, email, isSubscribe, companyID, c
                                 Domains: []
                             };
                         }
-                        return [4 /*yield*/, db.collection('ListSchema').findOne({ Name: "CampaignCategory", "Data": { "$elemMatch": { "DomainID": { $in: domainIds_1 } } } }, { projection: { "Data.DomainID": 1, "Data.Key": 1, "Data.IsActive": 1 } })];
+                        return [4 /*yield*/, db.collection('ListSchema').findOne({ Name: "CampaignCategory", "Data": { "$elemMatch": { "DomainID": { $in: domainIds_1 } } } }, { projection: { "Data.DomainID": 1, "Data.Key": 1, "Data.IsActive": 1 } }, mongodbQueryOpts)];
                     case 3:
                         marketingCategoryData = _a.sent();
                         _loop_2 = function (i) {
@@ -791,9 +798,12 @@ var SubscribeEmailForAllDomains = function (db, email, isSubscribe, companyID, c
                         }
                         _a.label = 4;
                     case 4:
+                        mongodbQueryOpts["upsert"] = true;
                         if (!isRequireUpdate) return [3 /*break*/, 6];
-                        return [4 /*yield*/, db.collection('EmailStatus').updateOne({ 'EmailID': email, CompanyID: companyID }, { $set: { Domains: existEmailSub.Domains } }, { upsert: true })];
+                        //await db.collection('EmailStatus').updateOne({ 'EmailID': email, CompanyID: companyID }, { $set: { Domains: existEmailSub.Domains } }, { upsert: true })
+                        return [4 /*yield*/, db.collection('EmailStatus').updateOne({ 'EmailID': email, CompanyID: companyID }, { $set: { Domains: existEmailSub.Domains } }, mongodbQueryOpts)];
                     case 5:
+                        //await db.collection('EmailStatus').updateOne({ 'EmailID': email, CompanyID: companyID }, { $set: { Domains: existEmailSub.Domains } }, { upsert: true })
                         _a.sent();
                         _a.label = 6;
                     case 6:

package/dist/lib/memoryserverclient.d.ts

@@ -0,0 +1,39 @@
+/// <reference types="node" />
+import * as net from 'net';
+import { AnyObjectInterface } from '../modals/utility.modal';
+declare class MemoryDBConnect {
+    private client?;
+    private portNo;
+    private host;
+    private isConnected;
+    private messages;
+    /**
+     * @param masterConfig Master Connectivity Object
+     * @param redisClient Redisclient
+     * @description connect to master database and maintain master config and redis client for furture ref
+     */
+    constructor(portNumber: number, hostName: string);
+    /**
+     * @description connect to memory server on specified port and host
+     * @returns Promise with error first approach and success | failed.
+     */
+    Initialize(): Promise<[Error?, string?]>;
+    /**
+     * @param method  specifies the function of memory server which needs to execute
+     * @param data  an object which has data for memory server
+     * @param data.CompanyID
+     * @param data.DataSet      name of dataset to refer the data in memory server
+     * @param data.findQuery    query by data need to retrieve from memory server
+     * @param data.FullDoc      data to add, update and delete in memeory server
+     * @description write to server stream of memory server and data data from memory server by specific message id
+     * LOV:
+     * method : search | execute | insertInDataSet | updateInDataSet | deleteInDataSet
+     */
+    Fetch(method: string, data: AnyObjectInterface): Promise<[any?, AnyObjectInterface?]>;
+    /**
+   * @description get connection object of memory server if already created other wise create and provide.
+   * @returns null | socket client
+   */
+    Connect(): Promise<net.Socket | undefined>;
+}
+export { MemoryDBConnect };

package/dist/lib/memoryserverclient.js

@@ -0,0 +1,203 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryDBConnect = void 0;
+//var net = require('net');
+var net = __importStar(require("net"));
+var crypto = __importStar(require("crypto"));
+var MemoryDBConnect = /** @class */ (function () {
+    /**
+     * @param masterConfig Master Connectivity Object
+     * @param redisClient Redisclient
+     * @description connect to master database and maintain master config and redis client for furture ref
+     */
+    function MemoryDBConnect(portNumber, hostName) {
+        this.client = undefined;
+        this.portNo = 0;
+        this.host = "";
+        this.isConnected = false;
+        this.messages = {};
+        this.portNo = portNumber;
+        this.host = hostName;
+        // this.Initialize().then(([error, result]) => {
+        //     if (result == 'failed') {
+        //         console.log('connection to memory server failed');
+        //     }
+        // })
+    }
+    /**
+     * @description connect to memory server on specified port and host
+     * @returns Promise with error first approach and success | failed.
+     */
+    MemoryDBConnect.prototype.Initialize = function () {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            var newConnectRequest = true;
+            _this.client = new net.Socket();
+            _this.client.connect(_this.portNo, _this.host, function () {
+                _this.isConnected = true;
+                console.log("client connected to " + _this.portNo + ":" + _this.host);
+                if (newConnectRequest) {
+                    resolve([undefined, 'success']);
+                    newConnectRequest = false;
+                }
+            });
+            _this.client.on('data', function (data) {
+                console.log("Data from MemServer", (data || "").toString());
+                //console.log("")
+                var message = null;
+                try {
+                    data = JSON.parse(data);
+                    message = _this.messages[data.id];
+                    if (message) {
+                        delete _this.messages[data.id];
+                        message(data);
+                    }
+                }
+                catch (error) {
+                    console.log("Error in parsing MemServer data", error);
+                }
+            });
+            _this.client.on('close', function () {
+                _this.isConnected = false;
+                console.log("Client closed for port:host - " + _this.portNo + ":" + _this.host);
+                if (newConnectRequest) {
+                    resolve([undefined, 'failed']);
+                    newConnectRequest = false;
+                }
+            });
+            _this.client.on('error', function (err) {
+                console.error('Error in Memory server socket', err);
+            });
+        });
+    };
+    /**
+     * @param method  specifies the function of memory server which needs to execute
+     * @param data  an object which has data for memory server
+     * @param data.CompanyID
+     * @param data.DataSet      name of dataset to refer the data in memory server
+     * @param data.findQuery    query by data need to retrieve from memory server
+     * @param data.FullDoc      data to add, update and delete in memeory server
+     * @description write to server stream of memory server and data data from memory server by specific message id
+     * LOV:
+     * method : search | execute | insertInDataSet | updateInDataSet | deleteInDataSet
+     */
+    MemoryDBConnect.prototype.Fetch = function (method, data) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            var _a;
+            try {
+                console.log('socket connected==>', (_a = _this.client) === null || _a === void 0 ? void 0 : _a.connect);
+                var id = crypto.randomBytes(16).toString("hex");
+                var message_1 = { id: id, method: method, data: data, status: "0" };
+                _this.messages[id] = function (res) {
+                    if (message_1.status == "0") {
+                        resolve([undefined, res]);
+                        message_1.status = "1";
+                    }
+                };
+                //timeout event binding : after 30seconds request willbe timeout
+                setTimeout(function () {
+                    if (message_1.status == "0") {
+                        console.log("memory server request timed out");
+                        resolve([new Error("REQUEST_TIMEDOUT"), undefined]);
+                        message_1.status = "-1";
+                    }
+                }, 30000);
+                if (_this.client && _this.isConnected) {
+                    _this.client.write(JSON.stringify(message_1));
+                }
+                else {
+                    //to avoid again resolve by set timeout
+                    message_1.status = "-1";
+                    resolve([new Error('CLIENT_NOT_CONNECTED'), undefined]);
+                }
+            }
+            catch (err) {
+                resolve([err, undefined]);
+            }
+        });
+    };
+    /**
+   * @description get connection object of memory server if already created other wise create and provide.
+   * @returns null | socket client
+   */
+    MemoryDBConnect.prototype.Connect = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, error, result;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(this.client == null || this.isConnected == false)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.Initialize()];
+                    case 1:
+                        _a = _b.sent(), error = _a[0], result = _a[1];
+                        if (result != 'success') {
+                            console.log('memory server socket connection not initialized');
+                            //To Do : add code for handling this situation after getting some clarity on work.
+                        }
+                        _b.label = 2;
+                    case 2: 
+                    //check client connected code : to do list by satyam
+                    return [2 /*return*/, this.client];
+                }
+            });
+        });
+    };
+    return MemoryDBConnect;
+}());
+exports.MemoryDBConnect = MemoryDBConnect;

package/dist/lib/operautilitycommon.d.ts

@@ -3,4 +3,63 @@ import { AnyObjectInterface } from "../modals/utility.modal";
 declare const GetIntegrationSettings: (db: Db, hotelCode: string) => Promise<Error | AnyObjectInterface | null>;
 declare const SyncContactWithOperaOnEmailUnsubscribe: (db: Db, email: string) => void;
 declare const OperaErrorHandler: (db: Db, ex: Error) => void;
-export { GetIntegrationSettings, SyncContactWithOperaOnEmailUnsubscribe, OperaErrorHandler };
+/**
+ * This function is used to search profiles by dynamics fields in both Memory server and db.
+ * If data found in memory server then it search data by _id in db the return data.
+ *
+ * @param params.ModuleName  Name of Module either Account | Contact.
+ * @param params.MappingFields      fields which is used for searching
+ * @param params.ModuleData     Data of fields
+ * @param params.db     database objects
+ * @param params.MongodbTransactionQueryOptions     Mongodb query option, it may have transaction as well.
+ * @param params.SelectedFields     to get only selected fields
+ * @param params.AllowInactive     to search data without IsActive field.
+ * @param params.SearchFromMemoryServer     to indicate searcing is to do from memory server
+ * @param params.MemoryServerClient     memory server client object to get data from memory server
+ * @param params.CompanyId     to indicate searcing is to do from memory server
+ * @param params.DataSet     to indicate searcing is to do from memory server
+ *
+ * @returns [error,ResultData]
+ */
+declare const GetProfileDetailByDynamicFields: (params: AnyObjectInterface) => Promise<any[]>;
+/**
+ * This function is used to update  data.
+ * @param params.ModuleName  Name of Module either Account | Contact.
+ * @param params.Collection  Name of Collection
+ * @param params.Id      which doucment has to update
+ * @param params.db     database objects
+ * @param params.MongodbTransactionQueryOptions     Mongodb query option object , it may have transaction as well.
+ * @param params.UpdateObj    to update data in collection.
+ 
+ * @returns
+ */
+declare const UpdateInitialSyncData: (params: AnyObjectInterface) => Promise<unknown>;
+/**
+ * This function is used to stop unnecessary databse hits for checking any data available send to opera.
+ * this flag will be in reddis
+ * @param params.RedisClient  reddis client
+ * @param params.CompanyId      to create/check opera key with company id
+ * @param params.Mode      GET/SET operation to perform on reddis
+ * @param params.db     database objects
+ * @param params.isAvailable     value to set in reddis
+ 
+ * @returns
+ */
+declare const AddToQueueForOpera: (params: AnyObjectInterface) => Promise<any[] | undefined>;
+/**
+ * This function is used to search data in case of contact from memory server using email
+ * @param params.db     database objects
+ * @param params.ProfileType     profile type account/contact
+ * @param params.PrimaryEmail     primary email
+ * @param params.SecondaryEmail     secondary email
+ * @param params.MongodbTransactionQueryOptions     Mongodb query option, it may have transaction as well.
+ * @param params.SelectedFields     to get only selected fields
+ * @param params.SearchFromMemoryServer     to indicate searcing is to do from memory server
+ * @param params.MemoryServerClient     memory server client object to get data from memory server
+ * @param params.CompanyId     to indicate searcing is to do from memory server
+ * @param params.DataSet     to indicate searcing is to do from memory server
+ *
+ * @returns
+ */
+declare const EmailPrioritySearch: (params: AnyObjectInterface) => Promise<unknown>;
+export { GetIntegrationSettings, SyncContactWithOperaOnEmailUnsubscribe, OperaErrorHandler, GetProfileDetailByDynamicFields, UpdateInitialSyncData, AddToQueueForOpera, EmailPrioritySearch };