@zellio/chat-react-native 0.0.0-stage → 1.0.0

package/ios/vendor/swift/ZellioChatCore/Engine.swift

@@ -0,0 +1,325 @@
+import Foundation
+
+public struct EngineOptions: Sendable {
+    public var baseURL: URL
+    public var appKey: String
+    /// nil follows the device.
+    public var localeOption: ChatLocale?
+    public var deviceLanguageCode: String?
+    public var wrapper: String?
+    public var appVersion: String?
+
+    public init(baseURL: URL, appKey: String, localeOption: ChatLocale? = nil, deviceLanguageCode: String? = nil, wrapper: String? = nil, appVersion: String? = nil) {
+        self.baseURL = baseURL
+        self.appKey = appKey
+        self.localeOption = localeOption
+        self.deviceLanguageCode = deviceLanguageCode
+        self.wrapper = wrapper
+        self.appVersion = appVersion
+    }
+}
+
+public enum HubEvent: Sendable {
+    case realtime(RealtimeEvent)
+    case reconnected
+    case outbox(Outbox.Update)
+    /// Logout or a customer switch removed the local data. Caches outside the storage must go too.
+    case localDataWiped
+}
+
+/// Ties the parts together: config, consent, session, conversations, outbox, stream, push, logout.
+/// Every method is safe from any thread. Nothing here blocks the caller.
+public final class ChatEngine: @unchecked Sendable {
+    public let options: EngineOptions
+    public let api: ChatAPI
+    public let storage: StorageBackend
+    public let secrets: SecretStore
+    public let clock: ChatClock
+    public let installId: String
+    public let queue: OfflineQueue
+    public let outbox: Outbox
+    public let session: SessionCoordinator
+    public let unread = UnreadTracker()
+    public let consentStore: ConsentStore
+    public let drafts: DraftStore
+    private let configCache: ConfigCache
+
+    private struct State {
+        var config: ChatConfig?
+        var freshConfig = false
+        var context: ChatContext?
+        var localeOption: ChatLocale?
+        var listeners: [Int: @Sendable (HubEvent) -> Void] = [:]
+        var nextListener = 0
+        var streamConversationId: String?
+        var realtime: RealtimeClient?
+        var pushToken: PushRegistration?
+    }
+    private let state = Locked(State())
+
+    public struct PushRegistration: Codable, Equatable, Sendable {
+        public var token: String
+        public var environment: String?
+    }
+
+    public init(options: EngineOptions, transport: HTTPTransport, secrets: SecretStore, storage: StorageBackend, clock: ChatClock = SystemClock(), random: RandomSource = SystemRandom()) {
+        let install = InstallId.load(storage)
+        let api = ChatAPI(config: ChatAPIConfig(baseURL: options.baseURL, appKey: options.appKey, wrapper: options.wrapper), transport: transport)
+        let queue = OfflineQueue(storage: storage, clock: clock)
+        let box = Locked<ChatEngine?>(nil)
+        let sessionRef = Locked<SessionCoordinator?>(nil)
+        let outbox = Outbox(queue: queue, clock: clock, random: random) { item in
+            guard let coordinator = sessionRef.snapshot else { throw ChatError.network }
+            return try await coordinator.perform { token in
+                try await api.sendMessage(text: item.text, clientMessageId: item.clientMessageId, attachmentIds: item.attachmentIds, context: item.context, token: token)
+            }
+        }
+        let session = SessionCoordinator(
+            api: api, secrets: secrets, storage: storage, clock: clock, installId: install,
+            locale: { box.snapshot?.locale() ?? .en },
+            allowed: { try await box.snapshot?.requireSessionAllowed() },
+            onWipe: { box.snapshot?.didWipe() },
+            onSessionStarted: {
+                guard let engine = box.snapshot else { return }
+                Task { await engine.registerPushIfPossible() }
+            }
+        )
+        self.options = options
+        self.storage = storage
+        self.secrets = secrets
+        self.clock = clock
+        self.installId = install
+        self.api = api
+        self.queue = queue
+        self.outbox = outbox
+        self.session = session
+        self.consentStore = ConsentStore(storage: storage)
+        self.drafts = DraftStore(storage: storage)
+        self.configCache = ConfigCache(storage: storage)
+        sessionRef.with { $0 = session }
+        box.with { $0 = self }
+        state.with { s in
+            s.localeOption = options.localeOption
+            s.config = self.configCache.load()
+            s.pushToken = storage.load(PushRegistration.self, StorageName.push)
+        }
+        let engine = self
+        Task { await engine.outbox.setListener { [weak engine] update in engine?.emit(.outbox(update)) } }
+    }
+
+    // MARK: Config, locale, consent
+
+    public var cachedConfig: ChatConfig? { state.with { $0.config } }
+    public var isConfigFresh: Bool { state.with { $0.freshConfig } }
+
+    /// Reads the config again. On success the new one is saved. Offline keeps the saved one.
+    @discardableResult
+    public func refreshConfig() async throws -> ChatConfig {
+        do {
+            let body = try await api.fetchConfigBody()
+            let config = try ChatConfig.parse(body)
+            if config.sdkTooOld { throw ChatError.unavailable }
+            configCache.save(body: body)
+            state.with { s in
+                s.config = config
+                s.freshConfig = true
+            }
+            return config
+        } catch {
+            throw ErrorPolicy.map(error)
+        }
+    }
+
+    public func locale() -> ChatLocale {
+        let (config, option) = state.with { ($0.config, $0.localeOption) }
+        return LocaleChoice.choose(option: option, policy: config?.snapshot.language, deviceLanguageCode: options.deviceLanguageCode)
+    }
+
+    public func setLocaleOption(_ locale: ChatLocale?) { state.with { $0.localeOption = locale } }
+
+    public func consentState() -> ConsentState? {
+        guard let config = cachedConfig else { return nil }
+        return ConsentGate.state(config: config, store: consentStore)
+    }
+
+    public func acceptConsent() {
+        guard let config = cachedConfig else { return }
+        consentStore.accept(ConsentTerms(behavior: config.snapshot.behavior))
+    }
+
+    /// A session is never started from a saved config alone: the config is read fresh first, then consent is checked.
+    func requireSessionAllowed() async throws {
+        if !isConfigFresh { try await refreshConfig() }
+        guard let config = cachedConfig else { throw ChatError.network }
+        if config.sdkTooOld { throw ChatError.unavailable }
+        if !ConsentGate.allowsSession(config: config, store: consentStore) { throw ChatError.consentRequired }
+    }
+
+    func didWipe() {
+        unread.set(0)
+        state.with { s in
+            s.streamConversationId = nil
+        }
+        emit(.localDataWiped)
+    }
+
+    // MARK: Context
+
+    public func setContext(_ context: ChatContext?) { state.with { $0.context = context?.sanitized() } }
+    public var context: ChatContext? { state.with { $0.context } }
+
+    // MARK: Identity
+
+    public func identify(_ provider: @escaping IdentityTokenProvider) {
+        let engine = self
+        Task {
+            await engine.session.setProvider(provider)
+            // Only when a session exists already. Otherwise the token is used when the session is made.
+            try? await engine.session.identifyCurrentSession()
+        }
+    }
+
+    public func logout() async {
+        await stopRealtime()
+        await outbox.cancelAll()
+        // Tell the server which push token to forget, then end the session. Local data goes in both cases.
+        if let token = await session.token { try? await api.deleteDevice(token: token) }
+        await session.logout()
+        queue.clear()
+        state.with { s in
+            // The device token stays: the next session on this phone registers it again.
+            s.context = nil
+        }
+        unread.set(0)
+    }
+
+    // MARK: Conversations, unread
+
+    public func cachedConversations() -> ConversationsPage? { storage.load(ConversationsPage.self, StorageName.conversations) }
+
+    public func loadConversations(cursor: String? = nil) async throws -> ConversationsPage {
+        do {
+            let page = try await session.perform { token in try await self.api.conversations(cursor: cursor, token: token) }
+            if cursor == nil { storage.save(page, StorageName.conversations) }
+            unread.set(page.unreadTotal)
+            return page
+        } catch {
+            throw ErrorPolicy.map(error)
+        }
+    }
+
+    public func refreshUnread() async {
+        guard ConsentGate.allowsSession(config: cachedConfig, store: consentStore), await session.token != nil else { return }
+        if let total = try? await session.perform({ token in try await self.api.unread(token: token) }) { unread.set(total) }
+    }
+
+    public func markRead(conversationId: String, upTo: String) async {
+        if let total = try? await session.perform({ token in try await self.api.markRead(conversationId: conversationId, upTo: upTo, token: token) }) {
+            unread.set(total)
+        }
+    }
+
+    // MARK: Attachments
+
+    public func upload(data: Data, fileName: String, mimeType: String, progress: @escaping @Sendable (Double) -> Void) async throws -> Attachment {
+        do {
+            return try await session.perform { token in
+                try await self.api.uploadAttachment(data: data, fileName: fileName, mimeType: mimeType, token: token, progress: progress)
+            }
+        } catch {
+            throw ErrorPolicy.map(error)
+        }
+    }
+
+    // MARK: Push
+
+    public func setPushToken(_ token: String, environment: String?) {
+        let registration = PushRegistration(token: token, environment: environment)
+        state.with { $0.pushToken = registration }
+        storage.save(registration, StorageName.push)
+        let engine = self
+        Task { await engine.registerPushIfPossible() }
+    }
+
+    /// Sends the stored token when a session exists. It never creates a session by itself.
+    public func registerPushIfPossible() async {
+        guard let registration = state.with({ $0.pushToken }), await session.token != nil else { return }
+        let locale = self.locale()
+        _ = try? await session.perform { token in
+            try await self.api.registerDevice(provider: "apns", pushToken: registration.token, environment: registration.environment, locale: locale, appVersion: self.options.appVersion, token: token)
+        }
+    }
+
+    // MARK: Events hub
+
+    @discardableResult
+    public func addListener(_ listener: @escaping @Sendable (HubEvent) -> Void) -> Int {
+        state.with { s in
+            s.nextListener += 1
+            s.listeners[s.nextListener] = listener
+            return s.nextListener
+        }
+    }
+
+    public func removeListener(_ token: Int) { state.with { $0.listeners[token] = nil } }
+
+    func emit(_ event: HubEvent) {
+        let listeners: [@Sendable (HubEvent) -> Void] = state.with { s in
+            if case .realtime(let inner) = event {
+                if case .ready(let id) = inner { s.streamConversationId = id }
+            }
+            return Array(s.listeners.values)
+        }
+        if case .realtime(let inner) = event, case .unread(let total) = inner { unread.set(total) }
+        for listener in listeners { listener(event) }
+    }
+
+    public var streamConversationId: String? { state.with { $0.streamConversationId } }
+
+    // MARK: Realtime and lifecycle
+
+    public func startRealtime() async {
+        let existing = state.with { $0.realtime }
+        if let existing = existing { await existing.start(); return }
+        let client = RealtimeClient(
+            api: api, clock: clock,
+            tokenSource: { [weak self] in
+                guard let self = self else { throw ChatError.cancelled }
+                return try await self.session.ensureSession()
+            },
+            onEvent: { [weak self] event in self?.emit(.realtime(event)) },
+            catchUp: { [weak self] in
+                guard let self = self else { return }
+                await self.refreshUnread()
+                self.emit(.reconnected)
+            },
+            onFailure: { [weak self] error in
+                guard let self = self else { return }
+                if ErrorPolicy.reaction(for: error) == .recreateSessionThenRetry { await self.session.invalidateToken() }
+            }
+        )
+        state.with { $0.realtime = client }
+        await client.start()
+    }
+
+    public func stopRealtime() async {
+        if let client = state.with({ $0.realtime }) { await client.stop() }
+    }
+
+    /// The app went to the background: close the stream.
+    public func enteredBackground() async {
+        if let client = state.with({ $0.realtime }) { await client.enteredBackground() }
+    }
+
+    /// The app came back: read unread, read newer messages, reopen the stream. Also sends the queue.
+    public func enteredForeground() async {
+        if let client = state.with({ $0.realtime }) { await client.enteredForeground() } else { await refreshUnread() }
+        await outbox.kick()
+    }
+
+    public func networkReturned() async { await outbox.networkReturned() }
+
+    public func makeThread(conversationId: String?) -> ThreadController {
+        ThreadController(engine: self, conversationId: conversationId)
+    }
+}

package/ios/vendor/swift/ZellioChatCore/Errors.swift

@@ -0,0 +1,158 @@
+import Foundation
+
+/// The stable error codes of contract v1.
+public enum ChatErrorCode: String, Equatable, Sendable {
+    case appKeyInvalid = "CHAT_APP_KEY_INVALID"
+    case appDisabled = "CHAT_APP_DISABLED"
+    case entitlementDenied = "CHAT_ENTITLEMENT_DENIED"
+    case sessionInvalid = "CHAT_SESSION_INVALID"
+    case sessionRequired = "CHAT_SESSION_REQUIRED"
+    case identityInvalid = "CHAT_IDENTITY_INVALID"
+    case guestsDisabled = "CHAT_GUESTS_DISABLED"
+    case conversationNotFound = "CHAT_CONVERSATION_NOT_FOUND"
+    case fileTooLarge = "CHAT_FILE_TOO_LARGE"
+    case fileTypeDenied = "CHAT_FILE_TYPE_DENIED"
+    case filesDisabled = "CHAT_FILES_DISABLED"
+    case attachmentNotFound = "CHAT_ATTACHMENT_NOT_FOUND"
+    case rateLimited = "CHAT_RATE_LIMITED"
+    case sdkTooOld = "CHAT_SDK_TOO_OLD"
+    case siteNotFound = "CHAT_SITE_NOT_FOUND"
+}
+
+/// What the SDK does for an error code.
+public enum ErrorReaction: Equatable, Sendable {
+    case stopUnavailable
+    case recreateSessionThenRetry
+    case refreshIdentityOnce
+    case showLoginNeeded
+    case reloadConversationList
+    case showFileTooLarge
+    case showFileTypeDenied
+    case hideAttach
+    case backOff
+    case none
+}
+
+/// A failure of one API call.
+public enum ChatAPIError: Error, Equatable, Sendable {
+    case http(status: Int, code: String?, retryAfter: TimeInterval?)
+    case network
+    case timeout
+    case decoding
+    case cancelled
+
+    public var status: Int? {
+        if case .http(let status, _, _) = self { return status }
+        return nil
+    }
+
+    public var errorCode: ChatErrorCode? {
+        if case .http(_, let code, _) = self, let code = code { return ChatErrorCode(rawValue: code) }
+        return nil
+    }
+}
+
+/// The error the app-facing layers see. Mapped to a screen state.
+public enum ChatError: Error, Equatable, Sendable {
+    case unavailable
+    case loginNeeded
+    case rateLimited(retryAfter: TimeInterval?)
+    case fileTooLarge
+    case fileTypeDenied
+    case filesDisabled
+    case conversationNotFound
+    case consentRequired
+    case network
+    case server(status: Int)
+    case decoding
+    case cancelled
+
+    /// A short code for the public `error(code)` event. No message text.
+    public var eventCode: String {
+        switch self {
+        case .unavailable: return "unavailable"
+        case .loginNeeded: return "login_needed"
+        case .rateLimited: return "rate_limited"
+        case .fileTooLarge: return "file_too_large"
+        case .fileTypeDenied: return "file_type_denied"
+        case .filesDisabled: return "files_disabled"
+        case .conversationNotFound: return "conversation_not_found"
+        case .consentRequired: return "consent_required"
+        case .network: return "network"
+        case .server: return "server"
+        case .decoding: return "decoding"
+        case .cancelled: return "cancelled"
+        }
+    }
+}
+
+public enum ErrorPolicy {
+    /// Reads the code from `{ "code": ... }` or `{ "error": { "code": ... } }`.
+    public static func parseCode(from body: Data?) -> String? {
+        guard let body = body, !body.isEmpty,
+              let root = (try? JSONSerialization.jsonObject(with: body)) as? [String: Any] else { return nil }
+        if let code = root["code"] as? String { return code }
+        if let error = root["error"] as? [String: Any], let code = error["code"] as? String { return code }
+        return nil
+    }
+
+    public static func reaction(forCode code: String?) -> ErrorReaction {
+        guard let code = code, let known = ChatErrorCode(rawValue: code) else { return .none }
+        switch known {
+        case .appKeyInvalid, .appDisabled, .entitlementDenied, .sdkTooOld, .siteNotFound: return .stopUnavailable
+        case .sessionInvalid, .sessionRequired: return .recreateSessionThenRetry
+        case .identityInvalid: return .refreshIdentityOnce
+        case .guestsDisabled: return .showLoginNeeded
+        case .conversationNotFound: return .reloadConversationList
+        case .fileTooLarge: return .showFileTooLarge
+        case .fileTypeDenied: return .showFileTypeDenied
+        case .filesDisabled: return .hideAttach
+        // The message fails for good. The customer attaches the file again.
+        case .attachmentNotFound: return .none
+        case .rateLimited: return .backOff
+        }
+    }
+
+    /// A known code decides. An unknown code falls back to the HTTP status. No code (a proxy, for example) gives `.none`, except a 429.
+    public static func reaction(status: Int, code: String?) -> ErrorReaction {
+        guard let code = code else { return status == 429 ? .backOff : .none }
+        if ChatErrorCode(rawValue: code) != nil { return reaction(forCode: code) }
+        switch status {
+        case 401: return .recreateSessionThenRetry
+        case 403: return .stopUnavailable
+        case 429: return .backOff
+        default: return .none
+        }
+    }
+
+    public static func reaction(for error: Error) -> ErrorReaction {
+        guard let api = error as? ChatAPIError, case .http(let status, let code, _) = api else { return .none }
+        return reaction(status: status, code: code)
+    }
+
+    /// Maps any error to the app-facing error.
+    public static func map(_ error: Error) -> ChatError {
+        if let chat = error as? ChatError { return chat }
+        if error is CancellationError { return .cancelled }
+        guard let api = error as? ChatAPIError else { return .network }
+        switch api {
+        case .network, .timeout: return .network
+        case .decoding: return .decoding
+        case .cancelled: return .cancelled
+        case .http(let status, let code, let retryAfter):
+            switch reaction(status: status, code: code) {
+            case .stopUnavailable: return .unavailable
+            case .showLoginNeeded, .refreshIdentityOnce: return .loginNeeded
+            case .reloadConversationList: return .conversationNotFound
+            case .showFileTooLarge: return .fileTooLarge
+            case .showFileTypeDenied: return .fileTypeDenied
+            case .hideAttach: return .filesDisabled
+            case .backOff: return .rateLimited(retryAfter: retryAfter)
+            case .recreateSessionThenRetry: return .loginNeeded
+            case .none:
+                if status == 429 { return .rateLimited(retryAfter: retryAfter) }
+                return .server(status: status)
+            }
+        }
+    }
+}

package/ios/vendor/swift/ZellioChatCore/Generated/ChatStringTable.swift

@@ -0,0 +1,125 @@
+// GENERATED by scripts/generate-strings.mjs from sdks/design/strings.json. Do not edit by hand.
+
+enum ChatStringTable {
+    static let en: [String: String] = [
+        "a11y.team": "Support team",
+        "a11y.unread": "Unread",
+        "a11y.you": "You",
+        "attachment.cancel": "Cancel upload",
+        "attachment.close": "Close",
+        "attachment.failed": "We could not upload this file. Try again.",
+        "attachment.file": "File",
+        "attachment.photo": "Photo",
+        "attachment.tooLarge": "This file is too large. The limit is 10 MB.",
+        "attachment.typeDenied": "You can send photos and PDF files only.",
+        "banner.offline": "We are away right now. Leave a message and we will reply when we are back.",
+        "banner.online": "Our team is here to help",
+        "banner.outsideHours": "Outside support hours",
+        "banner.reconnecting": "Reconnecting…",
+        "common.back": "Back",
+        "common.close": "Close chat",
+        "common.copied": "Copied",
+        "common.copy": "Copy",
+        "common.poweredBy": "Powered by Zellio",
+        "composer.attach": "Attach a file",
+        "composer.camera": "Camera",
+        "composer.cameraDenied": "Allow camera access in Settings to take a photo.",
+        "composer.files": "File",
+        "composer.openSettings": "Open Settings",
+        "composer.photos": "Photo library",
+        "composer.placeholder": "Write your message…",
+        "composer.send": "Send",
+        "consent.accept": "Accept and start",
+        "consent.decline": "Not now",
+        "consent.default": "To help you, we store your messages and share them with our support team.",
+        "consent.privacy": "Privacy policy",
+        "delivery.failed": "Not sent",
+        "delivery.retry": "Try again",
+        "delivery.sending": "Sending…",
+        "delivery.sent": "Sent",
+        "delivery.waiting": "Sends when you are back online",
+        "home.fallbackHeading": "How can we help?",
+        "home.recent": "Recent conversations",
+        "home.seeAll": "See all",
+        "home.talkToTeam": "Talk to our team",
+        "list.empty": "You have no conversations yet.",
+        "list.new": "New conversation",
+        "list.title": "Conversations",
+        "push.newMessage": "New message",
+        "state.loadFailed": "We could not load your conversation. Try again.",
+        "state.loading": "Loading…",
+        "state.loginNeeded": "Log in to the app to chat with us.",
+        "state.rateLimited": "You are sending messages too fast. Please wait a few minutes, then try again.",
+        "state.retry": "Try again",
+        "state.sendFailed": "We could not send your message. Try again.",
+        "state.unavailable": "Chat is not available right now.",
+        "thread.greeting": "Hi! Tell us what you need help with.",
+        "thread.loadingOlder": "Loading earlier messages…",
+        "thread.newMessage": "New message",
+        "thread.title": "Your conversation",
+        "thread.today": "Today",
+        "thread.typing": "Our team is typing…",
+        "thread.yesterday": "Yesterday",
+    ]
+
+    static let ar: [String: String] = [
+        "a11y.team": "فريق الدعم",
+        "a11y.unread": "مش مقروءة",
+        "a11y.you": "إنت",
+        "attachment.cancel": "إلغاء الرفع",
+        "attachment.close": "إغلاق",
+        "attachment.failed": "معرفناش نرفع الملف. جرّب تاني.",
+        "attachment.file": "ملف",
+        "attachment.photo": "صورة",
+        "attachment.tooLarge": "الملف كبير أوي. الحد الأقصى 10 ميجا.",
+        "attachment.typeDenied": "تقدر تبعت صور وملفات PDF بس.",
+        "banner.offline": "إحنا مش متاحين دلوقتي. سيب رسالتك وهنرد عليك أول ما نرجع.",
+        "banner.online": "فريقنا موجود عشان يساعدك",
+        "banner.outsideHours": "خارج مواعيد العمل",
+        "banner.reconnecting": "بنحاول نرجّع الاتصال…",
+        "common.back": "رجوع",
+        "common.close": "إغلاق الشات",
+        "common.copied": "اتنسخ",
+        "common.copy": "نسخ",
+        "common.poweredBy": "بدعم من Zellio",
+        "composer.attach": "إرفاق ملف",
+        "composer.camera": "الكاميرا",
+        "composer.cameraDenied": "اسمح باستخدام الكاميرا من الإعدادات عشان تصوّر.",
+        "composer.files": "ملف",
+        "composer.openSettings": "افتح الإعدادات",
+        "composer.photos": "الصور",
+        "composer.placeholder": "اكتب رسالتك…",
+        "composer.send": "إرسال",
+        "consent.accept": "موافق، يلا نبدأ",
+        "consent.decline": "مش دلوقتي",
+        "consent.default": "عشان نقدر نساعدك، هنحفظ رسايلك ونشاركها مع فريق الدعم.",
+        "consent.privacy": "سياسة الخصوصية",
+        "delivery.failed": "ماتبعتتش",
+        "delivery.retry": "جرّب تاني",
+        "delivery.sending": "جارٍ الإرسال…",
+        "delivery.sent": "اتبعتت",
+        "delivery.waiting": "هتتبعت أول ما النت يرجع",
+        "home.fallbackHeading": "إزاي نقدر نساعدك؟",
+        "home.recent": "آخر المحادثات",
+        "home.seeAll": "شوف الكل",
+        "home.talkToTeam": "كلّم فريقنا",
+        "list.empty": "لسه مفيش محادثات.",
+        "list.new": "محادثة جديدة",
+        "list.title": "المحادثات",
+        "push.newMessage": "رسالة جديدة",
+        "state.loadFailed": "معرفناش نحمّل المحادثة. جرّب تاني.",
+        "state.loading": "جارٍ التحميل…",
+        "state.loginNeeded": "سجّل دخولك في التطبيق عشان تكلّمنا.",
+        "state.rateLimited": "بعت رسايل كتير ورا بعض. استنى كام دقيقة وجرّب تاني.",
+        "state.retry": "جرّب تاني",
+        "state.sendFailed": "معرفناش نبعت الرسالة. جرّب تاني.",
+        "state.unavailable": "الشات مش متاح دلوقتي.",
+        "thread.greeting": "أهلاً! قولّنا محتاج إيه وهنساعدك.",
+        "thread.loadingOlder": "بنحمّل الرسايل القديمة…",
+        "thread.newMessage": "رسالة جديدة",
+        "thread.title": "محادثتك",
+        "thread.today": "النهاردة",
+        "thread.typing": "الفريق بيكتب…",
+        "thread.yesterday": "إمبارح",
+    ]
+}