core-services-sdk 1.3.46 → 1.3.47

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "core-services-sdk",
-  "version": "1.3.46",
+  "version": "1.3.47",
   "main": "src/index.js",
   "type": "module",
   "types": "types/index.d.ts",

package/src/instant-messages/message-type.js

@@ -5,12 +5,12 @@ import { MESSAGE_MEDIA_TYPE, MESSAGE_TYPE } from './message-types.js'
  * inside the platform-original message object.
  *
  * @param {string} mediaType - One of MESSAGE_MEDIA_TYPE.*
- * @returns {(params: { originalMessage: any }) => boolean}
+ * @returns {(params: { imMessage: any }) => boolean}
  */
 export const isItMediaType =
   (mediaType) =>
-  ({ originalMessage }) => {
-    const message = originalMessage?.message
+  ({ imMessage }) => {
+    const message = imMessage?.message
     if (!message || typeof message !== 'object') {
       return false
     }
@@ -23,14 +23,14 @@ export const isItMediaType =
  *
  * @function isMessageTypeof
  * @param {string} typeOfMessage - One of the MESSAGE_TYPE.* values.
- * @returns {(params: { originalMessage: any }) => boolean}
- * A function that accepts an object containing `originalMessage`
+ * @returns {(params: { imMessage: any }) => boolean}
+ * A function that accepts an object containing `imMessage`
  * and returns true if its `type` matches the expected type.
  */
 export const isMessageTypeof =
   (typeOfMessage) =>
-  ({ originalMessage }) => {
-    const type = originalMessage?.type
+  ({ imMessage }) => {
+    const type = imMessage?.type
     return type === typeOfMessage
   }
 
@@ -41,11 +41,11 @@ export const isMessageTypeof =
  *
  * @function isCallbackQuery
  * @param {Object} params
- * @param {Object} params.originalMessage - Raw Telegram update
+ * @param {Object} params.imMessage - Raw Telegram update
  * @returns {boolean}
  */
-export const isCallbackQuery = ({ originalMessage }) => {
-  return 'callback_query' in originalMessage
+export const isCallbackQuery = ({ imMessage }) => {
+  return 'callback_query' in imMessage
 }
 
 // Media-type detectors for each supported message detail section.
@@ -77,7 +77,7 @@ export const isItButtonClick = isMessageTypeof(MESSAGE_TYPE.BUTTON_CLICK)
  *
  * @function getTelegramMessageType
  * @param {Object} params
- * @param {Object} params.originalMessage - Raw update object from Telegram or WhatsApp.
+ * @param {Object} params.imMessage - Raw update object from Telegram or WhatsApp.
  *   For Telegram:
  *     - May contain: message, callback_query, poll, etc.
  *   For WhatsApp:
@@ -89,60 +89,60 @@ export const isItButtonClick = isMessageTypeof(MESSAGE_TYPE.BUTTON_CLICK)
  *   - MESSAGE_TYPE.UNKNOWN_MESSAGE_TYPE
  *
  * @example
- * getTelegramMessageType({ originalMessage: telegramUpdate })
+ * getTelegramMessageType({ imMessage: telegramUpdate })
  * // → "text"
  *
  * @example
- * getTelegramMessageType({ originalMessage: whatsappPayload })
+ * getTelegramMessageType({ imMessage: whatsappPayload })
  * // → "image"
  */
-export const getTelegramMessageType = ({ originalMessage }) => {
+export const getTelegramMessageType = ({ imMessage }) => {
   switch (true) {
-    case isCallbackQuery({ originalMessage }): {
+    case isCallbackQuery({ imMessage }): {
       return MESSAGE_TYPE.BUTTON_CLICK
     }
 
-    case isItFreeText({ originalMessage }): {
+    case isItFreeText({ imMessage }): {
       return MESSAGE_MEDIA_TYPE.TEXT
     }
 
-    case isItVideo({ originalMessage }): {
+    case isItVideo({ imMessage }): {
       return MESSAGE_MEDIA_TYPE.VIDEO
     }
 
-    case isItPhoto({ originalMessage }): {
+    case isItPhoto({ imMessage }): {
       return MESSAGE_MEDIA_TYPE.PHOTO
     }
 
-    case isItDocument({ originalMessage }): {
+    case isItDocument({ imMessage }): {
       return MESSAGE_MEDIA_TYPE.DOCUMENT
     }
 
-    case isItLocation({ originalMessage }): {
+    case isItLocation({ imMessage }): {
       return MESSAGE_MEDIA_TYPE.LOCATION
     }
 
-    case isItVoice({ originalMessage }): {
+    case isItVoice({ imMessage }): {
       return MESSAGE_MEDIA_TYPE.VOICE
     }
 
-    case isItVideoNote({ originalMessage }): {
+    case isItVideoNote({ imMessage }): {
       return MESSAGE_MEDIA_TYPE.VIDEO_NOTE
     }
 
-    case isItPoll({ originalMessage }): {
+    case isItPoll({ imMessage }): {
       return MESSAGE_MEDIA_TYPE.POLL
     }
 
-    case isItSticker({ originalMessage }): {
+    case isItSticker({ imMessage }): {
       return MESSAGE_MEDIA_TYPE.STICKER
     }
 
-    case isItMessage({ originalMessage }): {
+    case isItMessage({ imMessage }): {
       return MESSAGE_MEDIA_TYPE.MESSAGE
     }
 
-    case isItContact({ originalMessage }): {
+    case isItContact({ imMessage }): {
       return MESSAGE_MEDIA_TYPE.CONTACT
     }
 

package/src/instant-messages/message-unified-mapper.js

@@ -17,25 +17,25 @@ const INTERACTIVE_MAPPER = {
  * and delegates to the correct internal resolver.
  *
  * @param {Object} params
- * @param {Object} params.originalMessage - Raw message payload
+ * @param {Object} params.imMessage - Raw message payload
  * @returns {string} Unified message type
  */
-export const getMessageType = ({ originalMessage }) => {
-  if (!originalMessage || typeof originalMessage !== 'object') {
+export const getMessageType = ({ imMessage }) => {
+  if (!imMessage || typeof imMessage !== 'object') {
     return MESSAGE_TYPE.UNKNOWN_MESSAGE_TYPE
   }
 
   // Telegram format
   if (
-    'update_id' in originalMessage ||
-    'message' in originalMessage ||
-    'callback_query' in originalMessage
+    'update_id' in imMessage ||
+    'message' in imMessage ||
+    'callback_query' in imMessage
   ) {
-    return getTelegramMessageType({ originalMessage })
+    return getTelegramMessageType({ imMessage })
   }
 
   // WhatsApp format
-  const entry = originalMessage?.entry?.[0]
+  const entry = imMessage?.entry?.[0]
   const change = entry?.changes?.[0]
   const message = change?.value?.messages?.[0]
 
@@ -46,11 +46,11 @@ export const getMessageType = ({ originalMessage }) => {
   return MESSAGE_TYPE.UNKNOWN_MESSAGE_TYPE
 }
 
-export const mapMessageTelegramBase = ({ originalMessage }) => {
-  const { callback_query, message, update_id } = originalMessage
+export const mapMessageTelegramBase = ({ imMessage }) => {
+  const { callback_query, message, update_id } = imMessage
   const messageData = callback_query?.message || message
   const { chat, date, from, message_id } = messageData
-  const type = getTelegramMessageType({ originalMessage })
+  const type = getTelegramMessageType({ imMessage })
   const typeMapped = MESSAGE_MEDIA_TYPE_MAPPER[type] || type
   const { forward_date, forward_from } = messageData
   const itIsForward = !!(forward_date && forward_from)
@@ -115,14 +115,14 @@ export const mapMessageWhatsAppContent = ({ message, type }) => {
   }
 }
 
-export const mapMessageTelegram = ({ originalMessage }) => {
+export const mapMessageTelegram = ({ imMessage }) => {
   const { messageBase, type, message } = mapMessageTelegramBase({
-    originalMessage,
+    imMessage,
   })
   const messageContent = mapMessageTelegramContent({
     type,
     message,
-    originalMessage,
+    imMessage,
   })
   const messageMapped = { ...messageBase, ...messageContent }
   return messageMapped
@@ -140,8 +140,8 @@ export const getWhatsAppMessageType = ({ message }) => {
   }
 }
 
-export const extractReply = ({ originalMessage }) => {
-  const { callback_query } = originalMessage
+export const extractReply = ({ imMessage }) => {
+  const { callback_query } = imMessage
   const { data: id, message } = callback_query
   const {
     reply_markup: { inline_keyboard },
@@ -155,17 +155,17 @@ export const extractReply = ({ originalMessage }) => {
 
   return { id, title }
 }
-export const whatsappBaseExtraction = ({ originalMessage }) => {
+export const whatsappBaseExtraction = ({ imMessage }) => {
   const {
     entry: [{ changes, id }],
-  } = originalMessage
+  } = imMessage
   const [change] = changes
   const { field, value } = change
   return { field, value, wbaid: id }
 }
 
-export const mapMessageWhatsAppBase = ({ originalMessage }) => {
-  const { field, value, wbaid } = whatsappBaseExtraction({ originalMessage })
+export const mapMessageWhatsAppBase = ({ imMessage }) => {
+  const { field, value, wbaid } = whatsappBaseExtraction({ imMessage })
   const { [field]: messages, contacts } = value
   const [message] = messages
   const [contact] = contacts
@@ -190,11 +190,7 @@ export const mapMessageWhatsAppBase = ({ originalMessage }) => {
   return { messageBase, message, contact, context }
 }
 
-export const mapMessageTelegramContent = ({
-  type,
-  message,
-  originalMessage,
-}) => {
+export const mapMessageTelegramContent = ({ type, message, imMessage }) => {
   switch (type) {
     case MESSAGE_MEDIA_TYPE.TEXT:
       return {
@@ -222,7 +218,7 @@ export const mapMessageTelegramContent = ({
         ...(animation ? { attachment: 'animation' } : null),
       }
     case MESSAGE_MEDIA_TYPE.BUTTON_CLICK:
-      const reply = extractReply({ originalMessage })
+      const reply = extractReply({ imMessage })
       return {
         reply,
       }
@@ -231,9 +227,9 @@ export const mapMessageTelegramContent = ({
   }
 }
 
-export const mapMessageWhatsApp = ({ originalMessage }) => {
+export const mapMessageWhatsApp = ({ imMessage }) => {
   const { messageBase, message, context } = mapMessageWhatsAppBase({
-    originalMessage,
+    imMessage,
   })
   const { type } = messageBase
   const messageContent = mapMessageWhatsAppContent({

package/tests/instant-messages/message-type.unit.test.js

@@ -23,18 +23,18 @@ describe('message-type helpers', () => {
     const isPhoto = isItMediaType(MESSAGE_MEDIA_TYPE.PHOTO)
 
     it('returns true when media type exists inside message', () => {
-      const originalMessage = { message: { photo: [{}] } }
-      expect(isPhoto({ originalMessage })).toBe(true)
+      const imMessage = { message: { photo: [{}] } }
+      expect(isPhoto({ imMessage })).toBe(true)
     })
 
     it('returns false when media type does not exist', () => {
-      const originalMessage = { message: { text: 'hi' } }
-      expect(isPhoto({ originalMessage })).toBe(false)
+      const imMessage = { message: { text: 'hi' } }
+      expect(isPhoto({ imMessage })).toBe(false)
     })
 
     it('returns false when message is missing', () => {
-      expect(isPhoto({ originalMessage: {} })).toBe(false)
-      expect(isPhoto({ originalMessage: null })).toBe(false)
+      expect(isPhoto({ imMessage: {} })).toBe(false)
+      expect(isPhoto({ imMessage: null })).toBe(false)
     })
   })
 
@@ -42,150 +42,142 @@ describe('message-type helpers', () => {
     const isButtonClick = isMessageTypeof(MESSAGE_TYPE.BUTTON_CLICK)
 
     it('returns true when type matches', () => {
-      const originalMessage = { type: MESSAGE_TYPE.BUTTON_CLICK }
-      expect(isButtonClick({ originalMessage })).toBe(true)
+      const imMessage = { type: MESSAGE_TYPE.BUTTON_CLICK }
+      expect(isButtonClick({ imMessage })).toBe(true)
     })
 
     it('returns false when type differs', () => {
-      const originalMessage = { type: MESSAGE_MEDIA_TYPE.TEXT }
-      expect(isButtonClick({ originalMessage })).toBe(false)
+      const imMessage = { type: MESSAGE_MEDIA_TYPE.TEXT }
+      expect(isButtonClick({ imMessage })).toBe(false)
     })
 
     it('returns false on missing type', () => {
-      const originalMessage = {}
-      expect(isButtonClick({ originalMessage })).toBe(false)
+      const imMessage = {}
+      expect(isButtonClick({ imMessage })).toBe(false)
     })
   })
 
   describe('isCallbackQuery', () => {
     it('returns true for Telegram callback_query', () => {
-      const originalMessage = { callback_query: { data: '1' } }
-      expect(isCallbackQuery({ originalMessage })).toBe(true)
+      const imMessage = { callback_query: { data: '1' } }
+      expect(isCallbackQuery({ imMessage })).toBe(true)
     })
 
     it('returns false otherwise', () => {
-      expect(isCallbackQuery({ originalMessage: {} })).toBe(false)
+      expect(isCallbackQuery({ imMessage: {} })).toBe(false)
     })
   })
 
   describe('media helpers', () => {
     it('isItFreeText works', () => {
-      expect(
-        isItFreeText({ originalMessage: { message: { text: 'hi' } } }),
-      ).toBe(true)
+      expect(isItFreeText({ imMessage: { message: { text: 'hi' } } })).toBe(
+        true,
+      )
     })
 
     it('isItPhoto works', () => {
-      expect(isItPhoto({ originalMessage: { message: { photo: [{}] } } })).toBe(
-        true,
-      )
+      expect(isItPhoto({ imMessage: { message: { photo: [{}] } } })).toBe(true)
     })
 
     it('isItVideo works', () => {
-      expect(isItVideo({ originalMessage: { message: { video: {} } } })).toBe(
-        true,
-      )
+      expect(isItVideo({ imMessage: { message: { video: {} } } })).toBe(true)
     })
 
     it('isItVoice works', () => {
-      expect(isItVoice({ originalMessage: { message: { voice: {} } } })).toBe(
-        true,
-      )
+      expect(isItVoice({ imMessage: { message: { voice: {} } } })).toBe(true)
     })
 
     it('isItDocument works', () => {
-      expect(
-        isItDocument({ originalMessage: { message: { document: {} } } }),
-      ).toBe(true)
+      expect(isItDocument({ imMessage: { message: { document: {} } } })).toBe(
+        true,
+      )
     })
 
     it('isItContact works', () => {
-      expect(
-        isItContact({ originalMessage: { message: { contact: {} } } }),
-      ).toBe(true)
+      expect(isItContact({ imMessage: { message: { contact: {} } } })).toBe(
+        true,
+      )
     })
 
     it('isItPoll works', () => {
-      expect(isItPoll({ originalMessage: { message: { poll: {} } } })).toBe(
-        true,
-      )
+      expect(isItPoll({ imMessage: { message: { poll: {} } } })).toBe(true)
     })
   })
 
   describe('getTelegramMessageType', () => {
     it('detects callback_query → BUTTON_CLICK', () => {
-      const originalMessage = { callback_query: {} }
-      expect(getTelegramMessageType({ originalMessage })).toBe(
+      const imMessage = { callback_query: {} }
+      expect(getTelegramMessageType({ imMessage })).toBe(
         MESSAGE_TYPE.BUTTON_CLICK,
       )
     })
 
     it('detects text', () => {
-      const originalMessage = { message: { text: 'hello' } }
-      expect(getTelegramMessageType({ originalMessage })).toBe(
+      const imMessage = { message: { text: 'hello' } }
+      expect(getTelegramMessageType({ imMessage })).toBe(
         MESSAGE_MEDIA_TYPE.TEXT,
       )
     })
 
     it('detects photo', () => {
-      const originalMessage = { message: { photo: [{}] } }
-      expect(getTelegramMessageType({ originalMessage })).toBe(
+      const imMessage = { message: { photo: [{}] } }
+      expect(getTelegramMessageType({ imMessage })).toBe(
         MESSAGE_MEDIA_TYPE.PHOTO,
       )
     })
 
     it('detects video', () => {
-      const originalMessage = { message: { video: {} } }
-      expect(getTelegramMessageType({ originalMessage })).toBe(
+      const imMessage = { message: { video: {} } }
+      expect(getTelegramMessageType({ imMessage })).toBe(
         MESSAGE_MEDIA_TYPE.VIDEO,
       )
     })
 
     it('detects document', () => {
-      const originalMessage = { message: { document: {} } }
-      expect(getTelegramMessageType({ originalMessage })).toBe(
+      const imMessage = { message: { document: {} } }
+      expect(getTelegramMessageType({ imMessage })).toBe(
         MESSAGE_MEDIA_TYPE.DOCUMENT,
       )
     })
 
     it('detects location', () => {
-      const originalMessage = { message: { location: {} } }
-      expect(getTelegramMessageType({ originalMessage })).toBe(
+      const imMessage = { message: { location: {} } }
+      expect(getTelegramMessageType({ imMessage })).toBe(
         MESSAGE_MEDIA_TYPE.LOCATION,
       )
     })
 
     it('detects voice', () => {
-      const originalMessage = { message: { voice: {} } }
-      expect(getTelegramMessageType({ originalMessage })).toBe(
+      const imMessage = { message: { voice: {} } }
+      expect(getTelegramMessageType({ imMessage })).toBe(
         MESSAGE_MEDIA_TYPE.VOICE,
       )
     })
 
     it('detects poll', () => {
-      const originalMessage = { message: { poll: {} } }
-      expect(getTelegramMessageType({ originalMessage })).toBe(
+      const imMessage = { message: { poll: {} } }
+      expect(getTelegramMessageType({ imMessage })).toBe(
         MESSAGE_MEDIA_TYPE.POLL,
       )
     })
 
     it('detects sticker', () => {
-      const originalMessage = { message: { sticker: {} } }
-      expect(getTelegramMessageType({ originalMessage })).toBe(
+      const imMessage = { message: { sticker: {} } }
+      expect(getTelegramMessageType({ imMessage })).toBe(
         MESSAGE_MEDIA_TYPE.STICKER,
       )
     })
 
     it('detects contact', () => {
-      const originalMessage = { message: { contact: {} } }
-      expect(getTelegramMessageType({ originalMessage })).toBe(
+      const imMessage = { message: { contact: {} } }
+      expect(getTelegramMessageType({ imMessage })).toBe(
         MESSAGE_MEDIA_TYPE.CONTACT,
       )
     })
 
     it('falls back to UNKNOWN_MESSAGE_TYPE', () => {
-      const originalMessage = { message: { something_else: 'x' } }
-      expect(getTelegramMessageType({ originalMessage })).toBe(
+      const imMessage = { message: { something_else: 'x' } }
+      expect(getTelegramMessageType({ imMessage })).toBe(
         MESSAGE_TYPE.UNKNOWN_MESSAGE_TYPE,
       )
     })

package/tests/instant-messages/message-unified-mapper-telegram.unit.test.js

@@ -31,10 +31,10 @@ describe('Telegram unified message mapper – all mock samples', () => {
 
     describe(`Message mock: ${file}`, () => {
       it('should map type correctly', () => {
-        const unifiedType = getTelegramMessageType({ originalMessage: raw })
+        const unifiedType = getTelegramMessageType({ imMessage: raw })
 
         const unifiedMessage = mapMessageTelegram({
-          originalMessage: raw,
+          imMessage: raw,
         })
 
         expect(unifiedMessage).toBeTypeOf('object')
@@ -48,7 +48,7 @@ describe('Telegram unified message mapper – all mock samples', () => {
       })
 
       it('should include mandatory unified fields', () => {
-        const unified = mapMessageTelegram({ originalMessage: raw })
+        const unified = mapMessageTelegram({ imMessage: raw })
 
         expect(unified).toHaveProperty('id')
         expect(unified).toHaveProperty('chatId')

package/tests/instant-messages/message-unified-mapper-united.unit.test.js

@@ -66,7 +66,7 @@ describe('Unified message mapper – all platforms, all mock samples', () => {
         const mapper = messageUnifiedMapper[application]
         expect(mapper).toBeTypeOf('function')
 
-        const unified = mapper({ originalMessage: raw })
+        const unified = mapper({ imMessage: raw })
 
         expect(unified).toBeTypeOf('object')
         expect(unified).toHaveProperty('id')

package/tests/instant-messages/message-unified-mapper-whatsapp.unit.test.js

@@ -30,10 +30,10 @@ describe('WhatsApp unified message mapper – all mock samples', () => {
     describe(`Message mock: ${file}`, () => {
       it('should map type correctly', () => {
         console.log(file)
-        const unifiedType = getMessageType({ originalMessage: raw })
+        const unifiedType = getMessageType({ imMessage: raw })
 
         const unifiedMessage = mapMessageWhatsApp({
-          originalMessage: raw,
+          imMessage: raw,
         })
 
         expect(unifiedMessage).toBeTypeOf('object')
@@ -47,7 +47,7 @@ describe('WhatsApp unified message mapper – all mock samples', () => {
       })
 
       it('should include mandatory unified fields', () => {
-        const unified = mapMessageWhatsApp({ originalMessage: raw })
+        const unified = mapMessageWhatsApp({ imMessage: raw })
 
         expect(unified).toHaveProperty('id')
         expect(unified).toHaveProperty('chatId')

package/types/ids/generators.d.ts

@@ -28,3 +28,4 @@ export function generateAlertId(): string
 export function generateResourceId(): string
 export function generateIncomingEmailId(): string
 export function generateEmailId(): string
+export function generateImId(): string

package/types/ids/prefixes.d.ts

@@ -71,4 +71,6 @@ export const ID_PREFIXES: Readonly<{
   INCOMING_EMAIL: 'ieml'
   /** Email ID prefix */
   EMAIL: 'eml'
+  /** Instant Message ID prefix */
+  IM: 'im'
 }>

package/types/instant-messages/message-type.d.ts

@@ -1,28 +1,24 @@
 export function isItMediaType(
   mediaType: string,
-): (params: { originalMessage: any }) => boolean
+): (params: { imMessage: any }) => boolean
 export function isMessageTypeof(
   typeOfMessage: string,
-): (params: { originalMessage: any }) => boolean
-export function isCallbackQuery({
-  originalMessage,
-}: {
-  originalMessage: any
-}): boolean
-export const isItPoll: (params: { originalMessage: any }) => boolean
-export const isItMessage: (params: { originalMessage: any }) => boolean
-export const isItVoice: (params: { originalMessage: any }) => boolean
-export const isItVideo: (params: { originalMessage: any }) => boolean
-export const isItPhoto: (params: { originalMessage: any }) => boolean
-export const isItFreeText: (params: { originalMessage: any }) => boolean
-export const isItSticker: (params: { originalMessage: any }) => boolean
-export const isItContact: (params: { originalMessage: any }) => boolean
-export const isItLocation: (params: { originalMessage: any }) => boolean
-export const isItDocument: (params: { originalMessage: any }) => boolean
-export const isItVideoNote: (params: { originalMessage: any }) => boolean
-export const isItButtonClick: (params: { originalMessage: any }) => boolean
+): (params: { imMessage: any }) => boolean
+export function isCallbackQuery({ imMessage }: { imMessage: any }): boolean
+export const isItPoll: (params: { imMessage: any }) => boolean
+export const isItMessage: (params: { imMessage: any }) => boolean
+export const isItVoice: (params: { imMessage: any }) => boolean
+export const isItVideo: (params: { imMessage: any }) => boolean
+export const isItPhoto: (params: { imMessage: any }) => boolean
+export const isItFreeText: (params: { imMessage: any }) => boolean
+export const isItSticker: (params: { imMessage: any }) => boolean
+export const isItContact: (params: { imMessage: any }) => boolean
+export const isItLocation: (params: { imMessage: any }) => boolean
+export const isItDocument: (params: { imMessage: any }) => boolean
+export const isItVideoNote: (params: { imMessage: any }) => boolean
+export const isItButtonClick: (params: { imMessage: any }) => boolean
 export function getTelegramMessageType({
-  originalMessage,
+  imMessage,
 }: {
-  originalMessage: any
+  imMessage: any
 }): string

package/types/instant-messages/message-unified-mapper.d.ts

@@ -1,13 +1,5 @@
-export function getMessageType({
-  originalMessage,
-}: {
-  originalMessage: any
-}): string
-export function mapMessageTelegramBase({
-  originalMessage,
-}: {
-  originalMessage: any
-}): {
+export function getMessageType({ imMessage }: { imMessage: any }): string
+export function mapMessageTelegramBase({ imMessage }: { imMessage: any }): {
   messageBase: {
     timestamp: string
     forwardInfo: {
@@ -46,11 +38,7 @@ export function mapMessageWhatsAppContent({
       reply: any
       text?: undefined
     }
-export function mapMessageTelegram({
-  originalMessage,
-}: {
-  originalMessage: any
-}):
+export function mapMessageTelegram({ imMessage }: { imMessage: any }):
   | {
       text: any
       reply?: undefined
@@ -125,24 +113,16 @@ export function mapMessageTelegram({
       itIsForward: boolean
     }
 export function getWhatsAppMessageType({ message }: { message: any }): any
-export function extractReply({ originalMessage }: { originalMessage: any }): {
+export function extractReply({ imMessage }: { imMessage: any }): {
   id: any
   title: any
 }
-export function whatsappBaseExtraction({
-  originalMessage,
-}: {
-  originalMessage: any
-}): {
+export function whatsappBaseExtraction({ imMessage }: { imMessage: any }): {
   field: any
   value: any
   wbaid: any
 }
-export function mapMessageWhatsAppBase({
-  originalMessage,
-}: {
-  originalMessage: any
-}): {
+export function mapMessageWhatsAppBase({ imMessage }: { imMessage: any }): {
   messageBase: {
     id: any
     chatId: any
@@ -165,11 +145,11 @@ export function mapMessageWhatsAppBase({
 export function mapMessageTelegramContent({
   type,
   message,
-  originalMessage,
+  imMessage,
 }: {
   type: any
   message: any
-  originalMessage: any
+  imMessage: any
 }):
   | {
       text: any
@@ -193,11 +173,7 @@ export function mapMessageTelegramContent({
       }
       text?: undefined
     }
-export function mapMessageWhatsApp({
-  originalMessage,
-}: {
-  originalMessage: any
-}):
+export function mapMessageWhatsApp({ imMessage }: { imMessage: any }):
   | {
       text: any
       reply?: undefined
@@ -250,7 +226,7 @@ export function mapMessageWhatsApp({
       timestamp: any
     }
 export const messageUnifiedMapper: {
-  [IM_PLATFORM.TELEGRAM]: ({ originalMessage }: { originalMessage: any }) =>
+  [IM_PLATFORM.TELEGRAM]: ({ imMessage }: { imMessage: any }) =>
     | {
         text: any
         reply?: undefined
@@ -324,7 +300,7 @@ export const messageUnifiedMapper: {
         chatter: any
         itIsForward: boolean
       }
-  [IM_PLATFORM.WHATSAPP]: ({ originalMessage }: { originalMessage: any }) =>
+  [IM_PLATFORM.WHATSAPP]: ({ imMessage }: { imMessage: any }) =>
     | {
         text: any
         reply?: undefined