core-services-sdk 1.3.45 → 1.3.47

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

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

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

@@ -0,0 +1,93 @@
+import { describe, it, expect } from 'vitest'
+import {
+  MESSAGE_TYPE,
+  MESSAGE_MEDIA_TYPE,
+  MESSAGE_MEDIA_TYPE_MAPPER,
+} from '../../src/instant-messages/message-types.js'
+
+describe('MESSAGE_MEDIA_TYPE', () => {
+  it('should contain all required media type keys', () => {
+    expect(MESSAGE_MEDIA_TYPE).toHaveProperty('TEXT')
+    expect(MESSAGE_MEDIA_TYPE).toHaveProperty('POLL')
+    expect(MESSAGE_MEDIA_TYPE).toHaveProperty('VIDEO')
+    expect(MESSAGE_MEDIA_TYPE).toHaveProperty('PHOTO')
+    expect(MESSAGE_MEDIA_TYPE).toHaveProperty('IMAGE')
+    expect(MESSAGE_MEDIA_TYPE).toHaveProperty('VOICE')
+    expect(MESSAGE_MEDIA_TYPE).toHaveProperty('AUDIO')
+    expect(MESSAGE_MEDIA_TYPE).toHaveProperty('STICKER')
+    expect(MESSAGE_MEDIA_TYPE).toHaveProperty('CONTACT')
+    expect(MESSAGE_MEDIA_TYPE).toHaveProperty('MESSAGE')
+    expect(MESSAGE_MEDIA_TYPE).toHaveProperty('REACTION')
+    expect(MESSAGE_MEDIA_TYPE).toHaveProperty('DOCUMENT')
+    expect(MESSAGE_MEDIA_TYPE).toHaveProperty('LOCATION')
+    expect(MESSAGE_MEDIA_TYPE).toHaveProperty('CONTACTS')
+    expect(MESSAGE_MEDIA_TYPE).toHaveProperty('VIDEO_NOTE')
+    expect(MESSAGE_MEDIA_TYPE).toHaveProperty('BUTTON_CLICK')
+    expect(MESSAGE_MEDIA_TYPE).toHaveProperty('BUTTON_CLICK_MULTIPLE')
+  })
+
+  it('should have correct string values', () => {
+    expect(MESSAGE_MEDIA_TYPE.TEXT).toBe('text')
+    expect(MESSAGE_MEDIA_TYPE.POLL).toBe('poll')
+    expect(MESSAGE_MEDIA_TYPE.VIDEO).toBe('video')
+    expect(MESSAGE_MEDIA_TYPE.PHOTO).toBe('photo')
+    expect(MESSAGE_MEDIA_TYPE.IMAGE).toBe('image')
+    expect(MESSAGE_MEDIA_TYPE.VOICE).toBe('voice')
+    expect(MESSAGE_MEDIA_TYPE.AUDIO).toBe('audio')
+    expect(MESSAGE_MEDIA_TYPE.STICKER).toBe('sticker')
+    expect(MESSAGE_MEDIA_TYPE.CONTACT).toBe('contact')
+    expect(MESSAGE_MEDIA_TYPE.MESSAGE).toBe('message')
+    expect(MESSAGE_MEDIA_TYPE.REACTION).toBe('reaction')
+    expect(MESSAGE_MEDIA_TYPE.DOCUMENT).toBe('document')
+    expect(MESSAGE_MEDIA_TYPE.LOCATION).toBe('location')
+    expect(MESSAGE_MEDIA_TYPE.CONTACTS).toBe('contacts')
+    expect(MESSAGE_MEDIA_TYPE.VIDEO_NOTE).toBe('video_note')
+    expect(MESSAGE_MEDIA_TYPE.BUTTON_CLICK).toBe('button_click')
+    expect(MESSAGE_MEDIA_TYPE.BUTTON_CLICK_MULTIPLE).toBe(
+      'button_click_multiple',
+    )
+  })
+})
+
+describe('MESSAGE_TYPE', () => {
+  it('should contain all expected keys', () => {
+    expect(MESSAGE_TYPE).toHaveProperty('MESSAGE')
+    expect(MESSAGE_TYPE).toHaveProperty('BUTTON_CLICK')
+    expect(MESSAGE_TYPE).toHaveProperty('BUTTON_CLICK_MULTIPLE')
+    expect(MESSAGE_TYPE).toHaveProperty('UNKNOWN_MESSAGE_TYPE')
+  })
+
+  it('should correctly reuse MEDIA_TYPE for interactive types', () => {
+    expect(MESSAGE_TYPE.BUTTON_CLICK).toBe('button_click')
+    expect(MESSAGE_TYPE.BUTTON_CLICK_MULTIPLE).toBe('button_click_multiple')
+  })
+
+  it('should correctly define fallback unknown type', () => {
+    expect(MESSAGE_TYPE.UNKNOWN_MESSAGE_TYPE).toBe('unknown_message_type')
+  })
+})
+
+describe('MESSAGE_MEDIA_TYPE_MAPPER', () => {
+  it('should correctly map Telegram voice → audio', () => {
+    expect(MESSAGE_MEDIA_TYPE_MAPPER[MESSAGE_MEDIA_TYPE.VOICE]).toBe(
+      MESSAGE_MEDIA_TYPE.AUDIO,
+    )
+  })
+
+  it('should correctly map Telegram photo → image', () => {
+    expect(MESSAGE_MEDIA_TYPE_MAPPER[MESSAGE_MEDIA_TYPE.PHOTO]).toBe(
+      MESSAGE_MEDIA_TYPE.IMAGE,
+    )
+  })
+
+  it('should correctly map WhatsApp contacts → contact', () => {
+    expect(MESSAGE_MEDIA_TYPE_MAPPER[MESSAGE_MEDIA_TYPE.CONTACTS]).toBe(
+      MESSAGE_MEDIA_TYPE.CONTACT,
+    )
+  })
+
+  it('should not map unrelated keys', () => {
+    expect(MESSAGE_MEDIA_TYPE_MAPPER[MESSAGE_MEDIA_TYPE.VIDEO]).toBeUndefined()
+    expect(MESSAGE_MEDIA_TYPE_MAPPER[MESSAGE_MEDIA_TYPE.TEXT]).toBeUndefined()
+  })
+})

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

@@ -0,0 +1,66 @@
+import { describe, it, expect } from 'vitest'
+import { readFileSync, readdirSync } from 'fs'
+import { join, extname } from 'path'
+import { fileURLToPath } from 'url'
+import { dirname } from 'path'
+import { mapMessageTelegram } from '../../src/instant-messages/message-unified-mapper.js'
+
+import { getTelegramMessageType } from '../../src/instant-messages/message-type.js'
+
+import {
+  MESSAGE_MEDIA_TYPE,
+  MESSAGE_MEDIA_TYPE_MAPPER,
+} from '../../src/instant-messages/message-types.js'
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+
+const MOCK_DIR_TELEGRAM = join(__dirname, './mock-messages/telegram')
+
+describe('Telegram unified message mapper – all mock samples', () => {
+  const files = readdirSync(MOCK_DIR_TELEGRAM).filter(
+    (f) => extname(f) === '.json',
+  )
+
+  if (files.length === 0) {
+    throw new Error('No Telegram mock message files found in directory.')
+  }
+
+  for (const file of files) {
+    const filePath = join(MOCK_DIR_TELEGRAM, file)
+    const raw = JSON.parse(readFileSync(filePath, 'utf8'))
+
+    describe(`Message mock: ${file}`, () => {
+      it('should map type correctly', () => {
+        const unifiedType = getTelegramMessageType({ imMessage: raw })
+
+        const unifiedMessage = mapMessageTelegram({
+          imMessage: raw,
+        })
+
+        expect(unifiedMessage).toBeTypeOf('object')
+        expect(unifiedType).toBeTypeOf('string')
+
+        expect(unifiedMessage.type).toBe(
+          MESSAGE_MEDIA_TYPE_MAPPER[unifiedType] || unifiedType,
+        )
+
+        expect(Object.values(MESSAGE_MEDIA_TYPE)).toContain(unifiedType)
+      })
+
+      it('should include mandatory unified fields', () => {
+        const unified = mapMessageTelegram({ imMessage: raw })
+
+        expect(unified).toHaveProperty('id')
+        expect(unified).toHaveProperty('chatId')
+        expect(unified).toHaveProperty('type')
+        expect(unified).toHaveProperty('timestamp')
+        expect(unified).toHaveProperty('chatter')
+        expect(unified).toHaveProperty('imExtraInfo')
+
+        expect(unified.chatter).toHaveProperty('id')
+        expect(unified.chatter).toHaveProperty('name')
+        expect(unified.imExtraInfo).toHaveProperty('tmId')
+      })
+    })
+  }
+})

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

@@ -0,0 +1,94 @@
+import { describe, it, expect } from 'vitest'
+import { readFileSync, readdirSync } from 'fs'
+import { join, extname } from 'path'
+import { fileURLToPath } from 'url'
+import { dirname } from 'path'
+
+import { messageUnifiedMapper } from '../../src/instant-messages/message-unified-mapper.js'
+
+import { MESSAGE_MEDIA_TYPE } from '../../src/instant-messages/message-types.js'
+import { IM_PLATFORM } from '../../src/instant-messages/im-platform.js'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+
+const MOCK_DIR_WHATSAPP = join(__dirname, './mock-messages/whatsapp')
+const MOCK_DIR_TELEGRAM = join(__dirname, './mock-messages/telegram')
+
+/**
+ * Loads all mock JSON files from directory and returns:
+ * [
+ *   { application: 'whatsapp', file: 'x.json', json: {...} }
+ * ]
+ */
+function loadMocks() {
+  const list = []
+
+  const whatsappFiles = readdirSync(MOCK_DIR_WHATSAPP).filter(
+    (f) => extname(f) === '.json',
+  )
+  for (const file of whatsappFiles) {
+    const raw = JSON.parse(readFileSync(join(MOCK_DIR_WHATSAPP, file), 'utf8'))
+    list.push({
+      application: IM_PLATFORM.WHATSAPP,
+      file,
+      raw,
+    })
+  }
+
+  const telegramFiles = readdirSync(MOCK_DIR_TELEGRAM).filter(
+    (f) => extname(f) === '.json',
+  )
+  for (const file of telegramFiles) {
+    const raw = JSON.parse(readFileSync(join(MOCK_DIR_TELEGRAM, file), 'utf8'))
+    list.push({
+      application: IM_PLATFORM.TELEGRAM,
+      file,
+      raw,
+    })
+  }
+
+  return list
+}
+
+describe('Unified message mapper – all platforms, all mock samples', () => {
+  const samples = loadMocks()
+
+  if (samples.length === 0) {
+    throw new Error('No mock message files for unified mapper test.')
+  }
+
+  for (const sample of samples) {
+    const { application, file, raw } = sample
+
+    describe(`${application} – ${file}`, () => {
+      it('should map unified message correctly', () => {
+        const mapper = messageUnifiedMapper[application]
+        expect(mapper).toBeTypeOf('function')
+
+        const unified = mapper({ imMessage: raw })
+
+        expect(unified).toBeTypeOf('object')
+        expect(unified).toHaveProperty('id')
+        expect(unified).toHaveProperty('chatId')
+        expect(unified).toHaveProperty('type')
+        expect(unified).toHaveProperty('timestamp')
+        expect(unified).toHaveProperty('chatter')
+        expect(unified).toHaveProperty('imExtraInfo')
+
+        expect(Object.values(MESSAGE_MEDIA_TYPE)).toContain(unified.type)
+
+        expect(unified.chatter).toHaveProperty('id')
+        expect(unified.chatter).toHaveProperty('name')
+
+        if (application === IM_PLATFORM.WHATSAPP) {
+          expect(unified.imExtraInfo).toHaveProperty('wbaid')
+        }
+
+        if (application === IM_PLATFORM.TELEGRAM) {
+          expect(unified.imExtraInfo).toHaveProperty('tmId')
+        }
+      })
+    })
+  }
+})

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

@@ -0,0 +1,65 @@
+import { describe, it, expect } from 'vitest'
+import { readFileSync, readdirSync } from 'fs'
+import { join, extname } from 'path'
+import { fileURLToPath } from 'url'
+import { dirname } from 'path'
+import {
+  getMessageType,
+  mapMessageWhatsApp,
+} from '../../src/instant-messages/message-unified-mapper.js'
+
+import { MESSAGE_MEDIA_TYPE } from '../../src/instant-messages/message-types.js'
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+
+const MOCK_DIR_WHATSAPP = join(__dirname, './mock-messages/whatsapp')
+
+describe('WhatsApp unified message mapper – all mock samples', () => {
+  const files = readdirSync(MOCK_DIR_WHATSAPP).filter(
+    (f) => extname(f) === '.json',
+  )
+
+  if (files.length === 0) {
+    throw new Error('No WhatsApp mock message files found in directory.')
+  }
+
+  for (const file of files) {
+    const filePath = join(MOCK_DIR_WHATSAPP, file)
+    const raw = JSON.parse(readFileSync(filePath, 'utf8'))
+
+    describe(`Message mock: ${file}`, () => {
+      it('should map type correctly', () => {
+        console.log(file)
+        const unifiedType = getMessageType({ imMessage: raw })
+
+        const unifiedMessage = mapMessageWhatsApp({
+          imMessage: raw,
+        })
+
+        expect(unifiedMessage).toBeTypeOf('object')
+        expect(unifiedType).toBeTypeOf('string')
+
+        // Type must match mapper result
+        expect(unifiedMessage.type).toBe(unifiedType)
+
+        // All unified types must be supported values
+        expect(Object.values(MESSAGE_MEDIA_TYPE)).toContain(unifiedType)
+      })
+
+      it('should include mandatory unified fields', () => {
+        const unified = mapMessageWhatsApp({ imMessage: raw })
+
+        expect(unified).toHaveProperty('id')
+        expect(unified).toHaveProperty('chatId')
+        expect(unified).toHaveProperty('type')
+        expect(unified).toHaveProperty('timestamp')
+        expect(unified).toHaveProperty('chatter')
+        expect(unified).toHaveProperty('imExtraInfo')
+
+        expect(unified.chatter).toHaveProperty('id')
+        expect(unified.chatter).toHaveProperty('name')
+        expect(unified.imExtraInfo).toHaveProperty('wbaid')
+      })
+    })
+  }
+})

package/tests/instant-messages/mock-messages/telegram/contact.json

@@ -0,0 +1,27 @@
+{
+  "update_id": 895013314,
+  "message": {
+    "message_id": 18,
+    "from": {
+      "id": 59627707,
+      "is_bot": false,
+      "first_name": "Haim",
+      "last_name": "Rubin",
+      "username": "haimrubin",
+      "language_code": "en"
+    },
+    "chat": {
+      "id": 59627707,
+      "first_name": "Haim",
+      "last_name": "Rubin",
+      "username": "haimrubin",
+      "type": "private"
+    },
+    "date": 1763789905,
+    "contact": {
+      "phone_number": "31625129658",
+      "first_name": "Ahmad",
+      "user_id": 1594286144
+    }
+  }
+}

package/tests/instant-messages/mock-messages/telegram/document.json

@@ -0,0 +1,43 @@
+{
+  "update_id": 895013311,
+  "message": {
+    "message_id": 15,
+    "from": {
+      "id": 59627707,
+      "is_bot": false,
+      "first_name": "Haim",
+      "last_name": "Rubin",
+      "username": "haimrubin",
+      "language_code": "en"
+    },
+    "chat": {
+      "id": 59627707,
+      "first_name": "Haim",
+      "last_name": "Rubin",
+      "username": "haimrubin",
+      "type": "private"
+    },
+    "date": 1763789772,
+    "document": {
+      "file_name": "View PDF Statement_2024-12-31.pdf",
+      "mime_type": "application/pdf",
+      "thumbnail": {
+        "file_id": "AAMCBAADGQEAAw9pIUvMD7oscJOFf765U00bgAk_6AACsBkAAn3bmVCXCOv2H3Zr0wEAB20AAzYE",
+        "file_unique_id": "AQADsBkAAn3bmVBy",
+        "file_size": 13015,
+        "width": 247,
+        "height": 320
+      },
+      "thumb": {
+        "file_id": "AAMCBAADGQEAAw9pIUvMD7oscJOFf765U00bgAk_6AACsBkAAn3bmVCXCOv2H3Zr0wEAB20AAzYE",
+        "file_unique_id": "AQADsBkAAn3bmVBy",
+        "file_size": 13015,
+        "width": 247,
+        "height": 320
+      },
+      "file_id": "BQACAgQAAxkBAAMPaSFLzA-6LHCThX--uVNNG4AJP-gAArAZAAJ925lQlwjr9h92a9M2BA",
+      "file_unique_id": "AgADsBkAAn3bmVA",
+      "file_size": 934888
+    }
+  }
+}

package/tests/instant-messages/mock-messages/telegram/location.json

@@ -0,0 +1,26 @@
+{
+  "update_id": 895013312,
+  "message": {
+    "message_id": 16,
+    "from": {
+      "id": 59627707,
+      "is_bot": false,
+      "first_name": "Haim",
+      "last_name": "Rubin",
+      "username": "haimrubin",
+      "language_code": "en"
+    },
+    "chat": {
+      "id": 59627707,
+      "first_name": "Haim",
+      "last_name": "Rubin",
+      "username": "haimrubin",
+      "type": "private"
+    },
+    "date": 1763789784,
+    "location": {
+      "latitude": 32.040577,
+      "longitude": 34.857177
+    }
+  }
+}

package/tests/instant-messages/mock-messages/telegram/photo.json

@@ -0,0 +1,52 @@
+{
+  "update_id": 895013309,
+  "message": {
+    "message_id": 13,
+    "from": {
+      "id": 59627707,
+      "is_bot": false,
+      "first_name": "Haim",
+      "last_name": "Rubin",
+      "username": "haimrubin",
+      "language_code": "en"
+    },
+    "chat": {
+      "id": 59627707,
+      "first_name": "Haim",
+      "last_name": "Rubin",
+      "username": "haimrubin",
+      "type": "private"
+    },
+    "date": 1763789720,
+    "photo": [
+      {
+        "file_id": "AgACAgQAAxkBAAMNaSFLmGK4vl2nmLRj5OlaSWYcxvMAAgkLaxtNXxFRI0N7hce2i0IBAAMCAANzAAM2BA",
+        "file_unique_id": "AQADCQtrG01fEVF4",
+        "file_size": 1418,
+        "width": 51,
+        "height": 90
+      },
+      {
+        "file_id": "AgACAgQAAxkBAAMNaSFLmGK4vl2nmLRj5OlaSWYcxvMAAgkLaxtNXxFRI0N7hce2i0IBAAMCAANtAAM2BA",
+        "file_unique_id": "AQADCQtrG01fEVFy",
+        "file_size": 19936,
+        "width": 180,
+        "height": 320
+      },
+      {
+        "file_id": "AgACAgQAAxkBAAMNaSFLmGK4vl2nmLRj5OlaSWYcxvMAAgkLaxtNXxFRI0N7hce2i0IBAAMCAAN4AAM2BA",
+        "file_unique_id": "AQADCQtrG01fEVF9",
+        "file_size": 91531,
+        "width": 450,
+        "height": 800
+      },
+      {
+        "file_id": "AgACAgQAAxkBAAMNaSFLmGK4vl2nmLRj5OlaSWYcxvMAAgkLaxtNXxFRI0N7hce2i0IBAAMCAAN5AAM2BA",
+        "file_unique_id": "AQADCQtrG01fEVF-",
+        "file_size": 127439,
+        "width": 720,
+        "height": 1280
+      }
+    ]
+  }
+}