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

package/ios/vendor/swift/ZellioChatCore/Timeline.swift

@@ -0,0 +1,157 @@
+import Foundation
+
+/// The messages of one conversation, oldest first, plus the cursors. Merges by `clientMessageId`.
+public struct Timeline: Codable, Equatable, Sendable {
+    public static let maxStored = 200
+
+    public var messages: [ChatMessage]
+    public var nextBefore: String?
+    public var latest: String?
+
+    public init(messages: [ChatMessage] = [], nextBefore: String? = nil, latest: String? = nil) {
+        self.messages = messages
+        self.nextBefore = nextBefore
+        self.latest = latest
+    }
+
+    public var hasOlder: Bool { nextBefore != nil }
+
+    /// Adds or replaces one message. Returns true when the list changed.
+    ///
+    /// A server message with the same `clientMessageId` replaces the local one in place, so the row keeps its
+    /// position and its `stableId`: no scroll jump and no flash. Otherwise a message with the same server id is
+    /// replaced in place. A new message goes in by time, after the last message with the same or an earlier time.
+    @discardableResult
+    public mutating func upsert(_ message: ChatMessage) -> Bool {
+        if let cid = message.clientMessageId, let index = messages.firstIndex(where: { $0.clientMessageId == cid }) {
+            return replace(at: index, with: message)
+        }
+        if let sid = message.serverId, let index = messages.firstIndex(where: { $0.serverId == sid }) {
+            return replace(at: index, with: message)
+        }
+        let date = message.date
+        var position = 0
+        var index = messages.count - 1
+        while index >= 0 {
+            if messages[index].date <= date { position = index + 1; break }
+            index -= 1
+        }
+        messages.insert(message, at: position)
+        return true
+    }
+
+    private mutating func replace(at index: Int, with message: ChatMessage) -> Bool {
+        var next = message
+        // A server copy never goes back to a local state, and keeps the local identity.
+        if next.clientMessageId == nil { next.clientMessageId = messages[index].clientMessageId }
+        if next == messages[index] { return false }
+        messages[index] = next
+        return true
+    }
+
+    /// Applies a page from the server. `older` pages move the `nextBefore` cursor; newer pages move `latest`.
+    public mutating func apply(page: MessagesPage, older: Bool, initial: Bool = false) {
+        for message in page.messages { upsert(message) }
+        if older || initial { nextBefore = page.nextBefore }
+        if !older, let latest = page.latest { self.latest = latest }
+        if initial, let latest = page.latest { self.latest = latest }
+    }
+
+    public mutating func setDelivery(clientMessageId: String, _ delivery: DeliveryState, reason: String? = nil) {
+        guard let index = messages.firstIndex(where: { $0.clientMessageId == clientMessageId }) else { return }
+        guard messages[index].serverId == nil else { return }
+        messages[index].delivery = delivery
+        messages[index].failureReason = reason
+    }
+
+    /// Keeps the newest `limit` messages. Cuts the older cursor off when anything was dropped, so paging stays honest.
+    public mutating func trim(limit: Int = Timeline.maxStored) {
+        guard messages.count > limit else { return }
+        messages.removeFirst(messages.count - limit)
+    }
+
+    /// What is saved to disk: server-confirmed messages only, newest 200. Queued messages live in the queue.
+    public func persisted() -> Timeline {
+        var copy = self
+        copy.messages = messages.filter { $0.serverId != nil }
+        copy.trim()
+        return copy
+    }
+}
+
+public enum ThreadRow: Equatable, Sendable, Identifiable {
+    case date(key: String, label: String)
+    case message(MessageRow)
+    case typing(agentName: String?)
+
+    public var id: String {
+        switch self {
+        case .date(let key, _): return "date-" + key
+        case .message(let row): return "msg-" + row.message.stableId
+        case .typing: return "typing"
+        }
+    }
+}
+
+public struct MessageRow: Equatable, Sendable {
+    public var message: ChatMessage
+    /// First message of a group: the larger gap above it.
+    public var startsGroup: Bool
+    /// Last message of a group: it has the tail and the avatar.
+    public var endsGroup: Bool
+    /// The agent name shows above the first agent message of a group.
+    public var showsName: Bool
+    /// The delivery line shows under the newest visitor message only. Failed messages always show theirs.
+    public var showsDelivery: Bool
+    public var timeLabel: String
+}
+
+public enum ThreadLayout {
+    /// Builds the rows: date separators, grouping within 5 minutes by the same sender, delivery lines.
+    public static func rows(messages: [ChatMessage], typing: Bool, typingName: String?, now: Date, locale: ChatLocale, timeZone: TimeZone = .current) -> [ThreadRow] {
+        var rows: [ThreadRow] = []
+        var calendar = Calendar(identifier: .gregorian)
+        calendar.timeZone = timeZone
+        let newestVisitor = messages.lastIndex { $0.from == .visitor }
+        var previous: ChatMessage?
+        for (index, message) in messages.enumerated() {
+            let date = message.date
+            let newDay = previous.map { !calendar.isDate($0.date, inSameDayAs: date) } ?? true
+            if newDay {
+                let comps = calendar.dateComponents([.year, .month, .day], from: date)
+                let key = "\(comps.year ?? 0)-\(comps.month ?? 0)-\(comps.day ?? 0)"
+                rows.append(.date(key: key, label: ChatFormat.daySeparator(date, now: now, locale: locale, timeZone: timeZone)))
+            }
+            let sameGroupAsPrevious = !newDay && previous.map { isSameGroup($0, message) } ?? false
+            var endsGroup = true
+            if index + 1 < messages.count {
+                let next = messages[index + 1]
+                endsGroup = !(calendar.isDate(next.date, inSameDayAs: date) && isSameGroup(message, next))
+            }
+            let showsName = message.from == .agent && !sameGroupAsPrevious && !(message.agentName ?? "").isEmpty
+            let showsDelivery = message.from == .visitor && (index == newestVisitor || message.delivery == .failed)
+            rows.append(.message(MessageRow(message: message, startsGroup: !sameGroupAsPrevious, endsGroup: endsGroup,
+                                            showsName: showsName, showsDelivery: showsDelivery,
+                                            timeLabel: ChatFormat.time(date, locale: locale, timeZone: timeZone))))
+            previous = message
+        }
+        if typing { rows.append(.typing(agentName: typingName)) }
+        return rows
+    }
+
+    public static func isSameGroup(_ a: ChatMessage, _ b: ChatMessage) -> Bool {
+        guard a.from == b.from else { return false }
+        if a.from == .agent && a.agentName != b.agentName && a.agentName != nil && b.agentName != nil { return false }
+        return abs(b.date.timeIntervalSince(a.date)) <= Metrics.groupWindowSeconds
+    }
+
+    /// The delivery text under a visitor message. Nil when nothing shows.
+    public static func deliveryText(_ message: ChatMessage, strings: ChatStrings) -> String? {
+        switch message.delivery {
+        case .sending: return strings.string("delivery.sending")
+        case .waiting: return strings.string("delivery.waiting")
+        case .failed: return strings.string("delivery.failed")
+        case .sent: return strings.string("delivery.sent")
+        }
+    }
+}

package/ios/vendor/swift/ZellioChatCore/Transport.swift

@@ -0,0 +1,236 @@
+import Foundation
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+
+public struct HTTPRequest: Sendable {
+    public var method: String
+    public var url: URL
+    public var headers: [String: String]
+    public var body: Data?
+    public var timeout: TimeInterval
+
+    public init(method: String, url: URL, headers: [String: String] = [:], body: Data? = nil, timeout: TimeInterval = 30) {
+        self.method = method
+        self.url = url
+        self.headers = headers
+        self.body = body
+        self.timeout = timeout
+    }
+}
+
+public struct HTTPResponse: Sendable {
+    public var status: Int
+    public var headers: [String: String]
+    public var body: Data
+
+    public init(status: Int, headers: [String: String] = [:], body: Data = Data()) {
+        self.status = status
+        self.headers = headers
+        self.body = body
+    }
+
+    public func header(_ name: String) -> String? {
+        let wanted = name.lowercased()
+        return headers.first { $0.key.lowercased() == wanted }?.value
+    }
+}
+
+public enum StreamChunk: Sendable, Equatable {
+    case opened
+    case data(Data)
+}
+
+/// The network seam. The app target has a URLSession version; tests and demo mode use fakes.
+public protocol HTTPTransport: Sendable {
+    /// A normal request. Throws `ChatAPIError.network` or `.timeout`.
+    func send(_ request: HTTPRequest) async throws -> HTTPResponse
+    /// A request with a body that reports progress from 0 to 1. Cancelling the task cancels the upload.
+    func upload(_ request: HTTPRequest, progress: @escaping @Sendable (Double) -> Void) async throws -> HTTPResponse
+    /// An SSE stream. Yields `.opened` for a 2xx response, then bytes. Throws `ChatAPIError.http` for other statuses.
+    func stream(_ request: HTTPRequest) -> AsyncThrowingStream<StreamChunk, Error>
+}
+
+public struct ChatAPIConfig: Sendable {
+    public var baseURL: URL
+    public var appKey: String
+    public var platform: String
+    public var sdkVersion: String
+    public var wrapper: String?
+
+    public init(baseURL: URL, appKey: String, platform: String = SDKInfo.platform, sdkVersion: String = SDKInfo.version, wrapper: String? = nil) {
+        self.baseURL = baseURL
+        self.appKey = appKey
+        self.platform = platform
+        self.sdkVersion = sdkVersion
+        self.wrapper = wrapper
+    }
+}
+
+/// Typed calls to contract v1. The session token comes in per call.
+public final class ChatAPI: @unchecked Sendable {
+    public let config: ChatAPIConfig
+    private let transport: HTTPTransport
+
+    public static let connectTimeout: TimeInterval = 10
+    public static let readTimeout: TimeInterval = 30
+    public static let uploadTimeout: TimeInterval = 120
+
+    public init(config: ChatAPIConfig, transport: HTTPTransport) {
+        self.config = config
+        self.transport = transport
+    }
+
+    // MARK: Request building
+
+    func makeRequest(_ method: String, _ path: String, query: [(String, String)] = [], body: Data? = nil, token: String?, timeout: TimeInterval = ChatAPI.readTimeout, contentType: String? = nil) -> HTTPRequest {
+        var base = config.baseURL.absoluteString
+        while base.hasSuffix("/") { base.removeLast() }
+        var text = base + SDKInfo.apiPath + path
+        if !query.isEmpty {
+            var components = URLComponents()
+            components.queryItems = query.map { URLQueryItem(name: $0.0, value: $0.1) }
+            if let encoded = components.percentEncodedQuery { text += "?" + encoded }
+        }
+        let url = URL(string: text) ?? config.baseURL
+        var headers: [String: String] = [
+            "x-zee-app-key": config.appKey,
+            "x-zee-sdk": "\(config.platform)/\(config.sdkVersion)",
+            "accept": "application/json",
+        ]
+        if let wrapper = config.wrapper { headers["x-zee-sdk-wrapper"] = wrapper }
+        if let token = token { headers["x-zee-session-token"] = token }
+        if body != nil { headers["content-type"] = contentType ?? "application/json" }
+        return HTTPRequest(method: method, url: url, headers: headers, body: body, timeout: timeout)
+    }
+
+    private func json(_ object: [String: Any?]) -> Data? {
+        var clean: [String: Any] = [:]
+        for (key, value) in object { if let value = value { clean[key] = value } }
+        return try? JSONSerialization.data(withJSONObject: clean)
+    }
+
+    // MARK: Response handling
+
+    static func checked(_ response: HTTPResponse) throws -> Data {
+        if (200..<300).contains(response.status) { return response.body }
+        let retry = response.header("retry-after").flatMap { TimeInterval($0.trimmingCharacters(in: .whitespaces)) }
+        throw ChatAPIError.http(status: response.status, code: ErrorPolicy.parseCode(from: response.body), retryAfter: retry)
+    }
+
+    private struct Envelope<T: Decodable>: Decodable { let data: T }
+
+    static func unwrap<T: Decodable>(_ type: T.Type, _ body: Data) throws -> T {
+        do { return try JSONDecoder().decode(Envelope<T>.self, from: body).data } catch { throw ChatAPIError.decoding }
+    }
+
+    private func call<T: Decodable>(_ type: T.Type, _ request: HTTPRequest) async throws -> T {
+        let response = try await transport.send(request)
+        return try ChatAPI.unwrap(type, try ChatAPI.checked(response))
+    }
+
+    // MARK: Endpoints
+
+    public func fetchConfig() async throws -> ChatConfig {
+        let response = try await transport.send(makeRequest("GET", "/config", token: nil))
+        return try ChatConfig.parse(try ChatAPI.checked(response))
+    }
+
+    /// The raw body of GET /config, for the cache.
+    public func fetchConfigBody() async throws -> Data {
+        let response = try await transport.send(makeRequest("GET", "/config", token: nil))
+        return try ChatAPI.checked(response)
+    }
+
+    public func createSession(installId: String, locale: ChatLocale, identityToken: String?) async throws -> SessionInfo {
+        let body = json(["installId": installId, "platform": config.platform, "locale": locale.rawValue, "identityToken": identityToken])
+        return try await call(SessionInfo.self, makeRequest("POST", "/session", body: body, token: nil))
+    }
+
+    public func identify(identityToken: String, token: String) async throws -> SessionInfo {
+        try await call(SessionInfo.self, makeRequest("POST", "/session/identify", body: json(["identityToken": identityToken]), token: token))
+    }
+
+    public func logout(token: String) async throws {
+        let response = try await transport.send(makeRequest("POST", "/session/logout", body: Data("{}".utf8), token: token))
+        _ = try ChatAPI.checked(response)
+    }
+
+    public func conversations(cursor: String?, limit: Int = 20, token: String) async throws -> ConversationsPage {
+        var query: [(String, String)] = [("limit", String(min(50, max(1, limit))))]
+        if let cursor = cursor { query.append(("cursor", cursor)) }
+        return try await call(ConversationsPage.self, makeRequest("GET", "/conversations", query: query, token: token))
+    }
+
+    public func messages(conversationId: String, before: String? = nil, after: String? = nil, limit: Int = 50, token: String) async throws -> MessagesPage {
+        var query: [(String, String)] = [("limit", String(min(100, max(1, limit))))]
+        // Never both cursors.
+        if let before = before, after == nil { query.append(("before", before)) }
+        if let after = after { query.append(("after", after)) }
+        let encodedId = conversationId.addingPercentEncoding(withAllowedCharacters: .urlPathAllowed) ?? conversationId
+        return try await call(MessagesPage.self, makeRequest("GET", "/conversations/\(encodedId)/messages", query: query, token: token))
+    }
+
+    public func sendMessage(text: String, clientMessageId: String, attachmentIds: [String], context: ChatContext?, token: String) async throws -> SendReceipt {
+        var object: [String: Any] = ["text": text.clipped(toUTF16: 4000), "clientMessageId": clientMessageId]
+        if !attachmentIds.isEmpty { object["attachmentIds"] = attachmentIds }
+        if let context = context?.sanitized(), let data = try? JSONEncoder().encode(context),
+           let dictionary = (try? JSONSerialization.jsonObject(with: data)) as? [String: Any] {
+            object["context"] = dictionary
+        }
+        let body = try? JSONSerialization.data(withJSONObject: object)
+        return try await call(SendReceipt.self, makeRequest("POST", "/messages", body: body, token: token))
+    }
+
+    public func uploadAttachment(data: Data, fileName: String, mimeType: String, token: String, progress: @escaping @Sendable (Double) -> Void) async throws -> Attachment {
+        let boundary = "zee-" + UUID().uuidString
+        var body = Data()
+        func add(_ text: String) { body.append(Data(text.utf8)) }
+        let safeName = fileName.replacingOccurrences(of: "\"", with: "_").replacingOccurrences(of: "\r", with: "").replacingOccurrences(of: "\n", with: "")
+        add("--\(boundary)\r\nContent-Disposition: form-data; name=\"file\"; filename=\"\(safeName)\"\r\nContent-Type: \(mimeType)\r\n\r\n")
+        body.append(data)
+        add("\r\n--\(boundary)--\r\n")
+        let request = makeRequest("POST", "/attachments", body: body, token: token, timeout: ChatAPI.uploadTimeout, contentType: "multipart/form-data; boundary=\(boundary)")
+        let response = try await transport.upload(request, progress: progress)
+        return try ChatAPI.unwrap(Attachment.self, try ChatAPI.checked(response))
+    }
+
+    public func markRead(conversationId: String, upTo: String, token: String) async throws -> Int {
+        let body = json(["conversationId": conversationId, "upTo": upTo])
+        return try await call(UnreadBody.self, makeRequest("POST", "/read", body: body, token: token)).unreadTotal
+    }
+
+    public func unread(token: String) async throws -> Int {
+        try await call(UnreadBody.self, makeRequest("GET", "/unread", token: token)).unreadTotal
+    }
+
+    public func registerDevice(provider: String, pushToken: String, environment: String?, locale: ChatLocale, appVersion: String?, token: String) async throws {
+        let body = json(["provider": provider, "pushToken": pushToken, "environment": environment, "locale": locale.rawValue, "appVersion": appVersion])
+        let response = try await transport.send(makeRequest("PUT", "/device", body: body, token: token))
+        _ = try ChatAPI.checked(response)
+    }
+
+    public func deleteDevice(token: String) async throws {
+        let response = try await transport.send(makeRequest("DELETE", "/device", token: token))
+        _ = try ChatAPI.checked(response)
+    }
+
+    public func eventsRequest(token: String) -> HTTPRequest {
+        var request = makeRequest("GET", "/events", token: token, timeout: 0)
+        request.headers["accept"] = "text/event-stream"
+        return request
+    }
+
+    public func openStream(token: String) -> AsyncThrowingStream<StreamChunk, Error> {
+        transport.stream(eventsRequest(token: token))
+    }
+}
+
+private struct UnreadBody: Decodable {
+    let unreadTotal: Int
+    private enum CodingKeys: String, CodingKey { case unreadTotal }
+    init(from decoder: Decoder) throws {
+        let c = try decoder.container(keyedBy: CodingKeys.self)
+        unreadTotal = c.lenient(Int.self, .unreadTotal) ?? 0
+    }
+}

package/ios/vendor/swift/ZellioChatCore/Util.swift

@@ -0,0 +1,137 @@
+import Foundation
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+
+/// SDK constants.
+public enum SDKInfo {
+    public static let version = "1.0.0"
+    public static let platform = "ios"
+    public static let defaultBaseURL = "https://app.zellio.ai"
+    public static let apiPath = "/api/v1/zeechat/mobile"
+}
+
+/// A small lock around a value. Used where an actor would be too heavy.
+public final class Locked<Value>: @unchecked Sendable {
+    private let lock = NSLock()
+    private var value: Value
+
+    public init(_ value: Value) { self.value = value }
+
+    @discardableResult
+    public func with<R>(_ body: (inout Value) -> R) -> R {
+        lock.lock()
+        defer { lock.unlock() }
+        return body(&value)
+    }
+
+    public var snapshot: Value { with { $0 } }
+}
+
+/// Time and sleeping, injectable so tests never wait.
+public protocol ChatClock: Sendable {
+    func now() -> Date
+    func sleep(seconds: Double) async throws
+}
+
+public struct SystemClock: ChatClock {
+    public init() {}
+    public func now() -> Date { Date() }
+    public func sleep(seconds: Double) async throws {
+        if seconds <= 0 { return }
+        try await Task.sleep(nanoseconds: UInt64(min(seconds, 3600) * 1_000_000_000))
+    }
+}
+
+/// Random source, injectable for jitter tests.
+public protocol RandomSource: Sendable {
+    /// A value in 0..<1.
+    func unit() -> Double
+}
+
+public struct SystemRandom: RandomSource {
+    public init() {}
+    public func unit() -> Double { Double.random(in: 0..<1) }
+}
+
+public enum ISODate {
+    private static let withFraction: ISO8601DateFormatter = {
+        let formatter = ISO8601DateFormatter()
+        formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+        return formatter
+    }()
+    private static let plain: ISO8601DateFormatter = {
+        let formatter = ISO8601DateFormatter()
+        formatter.formatOptions = [.withInternetDateTime]
+        return formatter
+    }()
+    private static let lock = NSLock()
+
+    public static func parse(_ text: String) -> Date? {
+        lock.lock()
+        defer { lock.unlock() }
+        return withFraction.date(from: text) ?? plain.date(from: text)
+    }
+
+    public static func string(_ date: Date) -> String {
+        lock.lock()
+        defer { lock.unlock() }
+        return withFraction.string(from: date)
+    }
+}
+
+public enum SemVer {
+    /// Compares dotted numeric versions. Missing parts count as 0. Returns -1, 0 or 1.
+    public static func compare(_ a: String, _ b: String) -> Int {
+        let left = parts(a)
+        let right = parts(b)
+        let count = max(left.count, right.count)
+        for index in 0..<count {
+            let x = index < left.count ? left[index] : 0
+            let y = index < right.count ? right[index] : 0
+            if x != y { return x < y ? -1 : 1 }
+        }
+        return 0
+    }
+
+    private static func parts(_ text: String) -> [Int] {
+        let core = text.split(separator: "-").first.map(String.init) ?? text
+        return core.split(separator: ".").map { Int($0.filter { $0.isNumber }) ?? 0 }
+    }
+}
+
+/// Decodes a JSON value of any shape without keeping it. Used to step over a bad array element.
+struct SkipValue: Decodable {
+    init(from decoder: Decoder) throws {}
+}
+
+/// An array that skips elements that do not decode.
+struct LossyArray<Element: Decodable>: Decodable {
+    let items: [Element]
+
+    init(from decoder: Decoder) throws {
+        var container = try decoder.unkeyedContainer()
+        var result: [Element] = []
+        while !container.isAtEnd {
+            if let item = try? container.decode(Element.self) {
+                result.append(item)
+            } else {
+                _ = try? container.decode(SkipValue.self)
+            }
+        }
+        items = result
+    }
+}
+
+extension KeyedDecodingContainer {
+    /// Decodes a value, or nil when the key is missing or has the wrong type.
+    func lenient<T: Decodable>(_ type: T.Type, _ key: Key) -> T? {
+        guard let value = try? decodeIfPresent(type, forKey: key) else { return nil }
+        return value
+    }
+}
+
+enum JSON {
+    static func decoder() -> JSONDecoder { JSONDecoder() }
+    static func encoder() -> JSONEncoder { JSONEncoder() }
+}

package/lib/NativeZellioChat.d.ts

@@ -0,0 +1,34 @@
+import type { CodegenTypes, TurboModule } from 'react-native';
+/**
+ * Codegen spec. Do not import this file from app code: use the typed API in `index.ts`.
+ * Options travel as plain objects so the generated native code stays small; `index.ts` types them.
+ */
+export interface Spec extends TurboModule {
+    configure(appKey: string, options: CodegenTypes.UnsafeObject): void;
+    /** Registers the token provider on the native side. Native then asks JS through `onTokenRequest`. */
+    identify(): void;
+    /** Answers one `onTokenRequest`. Exactly one of `token` and `errorCode` is set. */
+    resolveToken(requestId: string, token: string | null, errorCode: string | null): void;
+    logout(): void;
+    present(): void;
+    presentConversation(conversationId: string | null): void;
+    dismiss(): void;
+    setContext(context: CodegenTypes.UnsafeObject | null): void;
+    getUnreadCount(): Promise<number>;
+    setPushToken(token: string, environment: string | null): void;
+    isZellioPush(payloadJson: string): boolean;
+    handlePush(payloadJson: string): Promise<boolean>;
+    handleNotificationTap(payloadJson: string): Promise<boolean>;
+    readonly onUnread: CodegenTypes.EventEmitter<{
+        count: number;
+    }>;
+    readonly onEvent: CodegenTypes.EventEmitter<{
+        name: string;
+        code?: string;
+    }>;
+    readonly onTokenRequest: CodegenTypes.EventEmitter<{
+        requestId: string;
+    }>;
+}
+declare const _default: Spec;
+export default _default;

package/lib/NativeZellioChat.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_native_1 = require("react-native");
+exports.default = react_native_1.TurboModuleRegistry.getEnforcing('RNZellioChat');

package/lib/index.d.ts

@@ -0,0 +1,37 @@
+import type { ZellioChatConfig, ZellioChatEvent, ZellioContext, ZellioPushEnvironment, ZellioPushPayload, ZellioSubscription, ZellioTokenProvider } from './types';
+export type * from './types';
+export { VERSION } from './version';
+/** Native asks for a token at most this long before it gives up. */
+export declare const TOKEN_TIMEOUT_MS = 15000;
+/** Call once at app start. Cheap: no network on the calling thread, no UI. */
+export declare function configure(config: ZellioChatConfig): void;
+/**
+ * Marks a signed-in customer. `tokenProvider` returns a JWT from your server. The SDK calls it when it needs a
+ * session and again if the server rejects the token. The token is never logged. Calling `identify` again
+ * replaces the provider.
+ */
+export declare function identify(provider: ZellioTokenProvider): void;
+/** Ends the session, deletes all local chat data and removes the push token from the server. */
+export declare function logout(): void;
+/** Shows chat on top of the app. */
+export declare function present(): void;
+/** Opens one conversation, or a new one when `conversationId` is omitted. */
+export declare function presentConversation(conversationId?: string | null): void;
+/** Closes chat. */
+export declare function dismiss(): void;
+/** Tells agents what the customer looks at. It is sent with the next messages. `null` clears it. */
+export declare function setContext(context: ZellioContext | null): void;
+/** The number of unread agent messages, across all conversations. Resolves 0 if the SDK is not ready. */
+export declare function getUnreadCount(): Promise<number>;
+/** Calls back now with the current count and on every change. Call `remove()` to stop. */
+export declare function addUnreadListener(callback: (count: number) => void): ZellioSubscription;
+/** Chat events for your own analytics. Call `remove()` to stop. */
+export declare function addEventListener(callback: (event: ZellioChatEvent) => void): ZellioSubscription;
+/** Gives the SDK the push token: the APNs token as a hex string on iOS, the FCM token on Android. */
+export declare function setPushToken(token: string, environment?: ZellioPushEnvironment): void;
+/** True only if the payload has the `zellio` key. */
+export declare function isZellioPush(payload: ZellioPushPayload | null | undefined): boolean;
+/** Refreshes the unread state. Resolves true if the push was ours. */
+export declare function handlePush(payload: ZellioPushPayload | null | undefined): Promise<boolean>;
+/** Opens the conversation that the push names. Resolves true if the push was ours. */
+export declare function handleNotificationTap(payload: ZellioPushPayload | null | undefined): Promise<boolean>;