ping-openmls-sdk-react-native-macos 0.7.10 → 0.7.12

package/ios/Generated.swift

@@ -2520,6 +2520,184 @@ public func FfiConverterTypeDiscoveredDevice_lower(_ value: DiscoveredDevice) ->
     return FfiConverterTypeDiscoveredDevice.lower(value)
 }
 
+public struct HistoryAppEvent {
+    public var eventId: Data
+    public var wallMs: UInt64
+    public var payload: Data
+    public var author: String
+
+    /// Default memberwise initializers are never public by default, so we
+    /// declare one manually.
+    public init(eventId: Data, wallMs: UInt64, payload: Data, author: String) {
+        self.eventId = eventId
+        self.wallMs = wallMs
+        self.payload = payload
+        self.author = author
+    }
+}
+
+extension HistoryAppEvent: Equatable, Hashable {
+    public static func == (lhs: HistoryAppEvent, rhs: HistoryAppEvent) -> Bool {
+        if lhs.eventId != rhs.eventId {
+            return false
+        }
+        if lhs.wallMs != rhs.wallMs {
+            return false
+        }
+        if lhs.payload != rhs.payload {
+            return false
+        }
+        if lhs.author != rhs.author {
+            return false
+        }
+        return true
+    }
+
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(eventId)
+        hasher.combine(wallMs)
+        hasher.combine(payload)
+        hasher.combine(author)
+    }
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeHistoryAppEvent: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> HistoryAppEvent {
+        return
+            try HistoryAppEvent(
+                eventId: FfiConverterData.read(from: &buf),
+                wallMs: FfiConverterUInt64.read(from: &buf),
+                payload: FfiConverterData.read(from: &buf),
+                author: FfiConverterString.read(from: &buf)
+            )
+    }
+
+    public static func write(_ value: HistoryAppEvent, into buf: inout [UInt8]) {
+        FfiConverterData.write(value.eventId, into: &buf)
+        FfiConverterUInt64.write(value.wallMs, into: &buf)
+        FfiConverterData.write(value.payload, into: &buf)
+        FfiConverterString.write(value.author, into: &buf)
+    }
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public func FfiConverterTypeHistoryAppEvent_lift(_ buf: RustBuffer) throws -> HistoryAppEvent {
+    return try FfiConverterTypeHistoryAppEvent.lift(buf)
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public func FfiConverterTypeHistoryAppEvent_lower(_ value: HistoryAppEvent) -> RustBuffer {
+    return FfiConverterTypeHistoryAppEvent.lower(value)
+}
+
+public struct HistoryBundleView {
+    public var v: UInt8
+    public var senderDeviceId: Data
+    public var recipientDeviceId: Data
+    public var conversationId: Data
+    public var windowStartMs: UInt64
+    public var windowEndMs: UInt64
+    public var events: [HistoryAppEvent]
+
+    /// Default memberwise initializers are never public by default, so we
+    /// declare one manually.
+    public init(v: UInt8, senderDeviceId: Data, recipientDeviceId: Data, conversationId: Data, windowStartMs: UInt64, windowEndMs: UInt64, events: [HistoryAppEvent]) {
+        self.v = v
+        self.senderDeviceId = senderDeviceId
+        self.recipientDeviceId = recipientDeviceId
+        self.conversationId = conversationId
+        self.windowStartMs = windowStartMs
+        self.windowEndMs = windowEndMs
+        self.events = events
+    }
+}
+
+extension HistoryBundleView: Equatable, Hashable {
+    public static func == (lhs: HistoryBundleView, rhs: HistoryBundleView) -> Bool {
+        if lhs.v != rhs.v {
+            return false
+        }
+        if lhs.senderDeviceId != rhs.senderDeviceId {
+            return false
+        }
+        if lhs.recipientDeviceId != rhs.recipientDeviceId {
+            return false
+        }
+        if lhs.conversationId != rhs.conversationId {
+            return false
+        }
+        if lhs.windowStartMs != rhs.windowStartMs {
+            return false
+        }
+        if lhs.windowEndMs != rhs.windowEndMs {
+            return false
+        }
+        if lhs.events != rhs.events {
+            return false
+        }
+        return true
+    }
+
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(v)
+        hasher.combine(senderDeviceId)
+        hasher.combine(recipientDeviceId)
+        hasher.combine(conversationId)
+        hasher.combine(windowStartMs)
+        hasher.combine(windowEndMs)
+        hasher.combine(events)
+    }
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeHistoryBundleView: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> HistoryBundleView {
+        return
+            try HistoryBundleView(
+                v: FfiConverterUInt8.read(from: &buf),
+                senderDeviceId: FfiConverterData.read(from: &buf),
+                recipientDeviceId: FfiConverterData.read(from: &buf),
+                conversationId: FfiConverterData.read(from: &buf),
+                windowStartMs: FfiConverterUInt64.read(from: &buf),
+                windowEndMs: FfiConverterUInt64.read(from: &buf),
+                events: FfiConverterSequenceTypeHistoryAppEvent.read(from: &buf)
+            )
+    }
+
+    public static func write(_ value: HistoryBundleView, into buf: inout [UInt8]) {
+        FfiConverterUInt8.write(value.v, into: &buf)
+        FfiConverterData.write(value.senderDeviceId, into: &buf)
+        FfiConverterData.write(value.recipientDeviceId, into: &buf)
+        FfiConverterData.write(value.conversationId, into: &buf)
+        FfiConverterUInt64.write(value.windowStartMs, into: &buf)
+        FfiConverterUInt64.write(value.windowEndMs, into: &buf)
+        FfiConverterSequenceTypeHistoryAppEvent.write(value.events, into: &buf)
+    }
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public func FfiConverterTypeHistoryBundleView_lift(_ buf: RustBuffer) throws -> HistoryBundleView {
+    return try FfiConverterTypeHistoryBundleView.lift(buf)
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public func FfiConverterTypeHistoryBundleView_lower(_ value: HistoryBundleView) -> RustBuffer {
+    return FfiConverterTypeHistoryBundleView.lower(value)
+}
+
 public struct Hlc {
     public var wallMs: UInt64
     public var logical: UInt32
@@ -3694,6 +3872,31 @@ private struct FfiConverterSequenceTypeDiscoveredDevice: FfiConverterRustBuffer
     }
 }
 
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+private struct FfiConverterSequenceTypeHistoryAppEvent: FfiConverterRustBuffer {
+    typealias SwiftType = [HistoryAppEvent]
+
+    static func write(_ value: [HistoryAppEvent], into buf: inout [UInt8]) {
+        let len = Int32(value.count)
+        writeInt(&buf, len)
+        for item in value {
+            FfiConverterTypeHistoryAppEvent.write(item, into: &buf)
+        }
+    }
+
+    static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [HistoryAppEvent] {
+        let len: Int32 = try readInt(&buf)
+        var seq = [HistoryAppEvent]()
+        seq.reserveCapacity(Int(len))
+        for _ in 0 ..< len {
+            try seq.append(FfiConverterTypeHistoryAppEvent.read(from: &buf))
+        }
+        return seq
+    }
+}
+
 #if swift(>=5.8)
     @_documentation(visibility: private)
 #endif
@@ -3957,6 +4160,16 @@ public func normalizeMnemonicPhrase(phrase: String) throws -> String {
     })
 }
 
+public func openHistoryBundle(sealed: Data, recipientPriv: Data, senderIdentityPub: Data) throws -> HistoryBundleView {
+    return try FfiConverterTypeHistoryBundleView.lift(rustCallWithError(FfiConverterTypePingError.lift) {
+        uniffi_ping_ffi_fn_func_open_history_bundle(
+            FfiConverterData.lower(sealed),
+            FfiConverterData.lower(recipientPriv),
+            FfiConverterData.lower(senderIdentityPub), $0
+        )
+    })
+}
+
 public func openLinkingTicket(sealed: Data, newDevicePriv: Data) throws -> LinkingTicket {
     return try FfiConverterTypeLinkingTicket.lift(rustCallWithError(FfiConverterTypePingError.lift) {
         uniffi_ping_ffi_fn_func_open_linking_ticket(
@@ -3966,6 +4179,16 @@ public func openLinkingTicket(sealed: Data, newDevicePriv: Data) throws -> Linki
     })
 }
 
+public func sealHistoryBundle(bundle: HistoryBundleView, recipientPub: Data, senderIdentitySecret: Data) throws -> Data {
+    return try FfiConverterData.lift(rustCallWithError(FfiConverterTypePingError.lift) {
+        uniffi_ping_ffi_fn_func_seal_history_bundle(
+            FfiConverterTypeHistoryBundleView.lower(bundle),
+            FfiConverterData.lower(recipientPub),
+            FfiConverterData.lower(senderIdentitySecret), $0
+        )
+    })
+}
+
 public func sealLinkingTicket(ticket: LinkingTicket, newDevicePub: Data) throws -> Data {
     return try FfiConverterData.lift(rustCallWithError(FfiConverterTypePingError.lift) {
         uniffi_ping_ffi_fn_func_seal_linking_ticket(
@@ -4009,9 +4232,15 @@ private var initializationResult: InitializationResult = {
     if uniffi_ping_ffi_checksum_func_normalize_mnemonic_phrase() != 55353 {
         return InitializationResult.apiChecksumMismatch
     }
+    if uniffi_ping_ffi_checksum_func_open_history_bundle() != 29021 {
+        return InitializationResult.apiChecksumMismatch
+    }
     if uniffi_ping_ffi_checksum_func_open_linking_ticket() != 64091 {
         return InitializationResult.apiChecksumMismatch
     }
+    if uniffi_ping_ffi_checksum_func_seal_history_bundle() != 21178 {
+        return InitializationResult.apiChecksumMismatch
+    }
     if uniffi_ping_ffi_checksum_func_seal_linking_ticket() != 37263 {
         return InitializationResult.apiChecksumMismatch
     }

package/ios/pingFFI.h

@@ -579,11 +579,21 @@ RustBuffer uniffi_ping_ffi_fn_func_generate_mnemonic_phrase(RustCallStatus *_Non
 RustBuffer uniffi_ping_ffi_fn_func_normalize_mnemonic_phrase(RustBuffer phrase, RustCallStatus *_Nonnull out_status
 );
 #endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_PING_FFI_FN_FUNC_OPEN_HISTORY_BUNDLE
+#define UNIFFI_FFIDEF_UNIFFI_PING_FFI_FN_FUNC_OPEN_HISTORY_BUNDLE
+RustBuffer uniffi_ping_ffi_fn_func_open_history_bundle(RustBuffer sealed, RustBuffer recipient_priv, RustBuffer sender_identity_pub, RustCallStatus *_Nonnull out_status
+);
+#endif
 #ifndef UNIFFI_FFIDEF_UNIFFI_PING_FFI_FN_FUNC_OPEN_LINKING_TICKET
 #define UNIFFI_FFIDEF_UNIFFI_PING_FFI_FN_FUNC_OPEN_LINKING_TICKET
 RustBuffer uniffi_ping_ffi_fn_func_open_linking_ticket(RustBuffer sealed, RustBuffer new_device_priv, RustCallStatus *_Nonnull out_status
 );
 #endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_PING_FFI_FN_FUNC_SEAL_HISTORY_BUNDLE
+#define UNIFFI_FFIDEF_UNIFFI_PING_FFI_FN_FUNC_SEAL_HISTORY_BUNDLE
+RustBuffer uniffi_ping_ffi_fn_func_seal_history_bundle(RustBuffer bundle, RustBuffer recipient_pub, RustBuffer sender_identity_secret, RustCallStatus *_Nonnull out_status
+);
+#endif
 #ifndef UNIFFI_FFIDEF_UNIFFI_PING_FFI_FN_FUNC_SEAL_LINKING_TICKET
 #define UNIFFI_FFIDEF_UNIFFI_PING_FFI_FN_FUNC_SEAL_LINKING_TICKET
 RustBuffer uniffi_ping_ffi_fn_func_seal_linking_ticket(RustBuffer ticket, RustBuffer new_device_pub, RustCallStatus *_Nonnull out_status
@@ -903,12 +913,24 @@ uint16_t uniffi_ping_ffi_checksum_func_generate_mnemonic_phrase(void
 #define UNIFFI_FFIDEF_UNIFFI_PING_FFI_CHECKSUM_FUNC_NORMALIZE_MNEMONIC_PHRASE
 uint16_t uniffi_ping_ffi_checksum_func_normalize_mnemonic_phrase(void
     
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_PING_FFI_CHECKSUM_FUNC_OPEN_HISTORY_BUNDLE
+#define UNIFFI_FFIDEF_UNIFFI_PING_FFI_CHECKSUM_FUNC_OPEN_HISTORY_BUNDLE
+uint16_t uniffi_ping_ffi_checksum_func_open_history_bundle(void
+    
 );
 #endif
 #ifndef UNIFFI_FFIDEF_UNIFFI_PING_FFI_CHECKSUM_FUNC_OPEN_LINKING_TICKET
 #define UNIFFI_FFIDEF_UNIFFI_PING_FFI_CHECKSUM_FUNC_OPEN_LINKING_TICKET
 uint16_t uniffi_ping_ffi_checksum_func_open_linking_ticket(void
     
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_PING_FFI_CHECKSUM_FUNC_SEAL_HISTORY_BUNDLE
+#define UNIFFI_FFIDEF_UNIFFI_PING_FFI_CHECKSUM_FUNC_SEAL_HISTORY_BUNDLE
+uint16_t uniffi_ping_ffi_checksum_func_seal_history_bundle(void
+    
 );
 #endif
 #ifndef UNIFFI_FFIDEF_UNIFFI_PING_FFI_CHECKSUM_FUNC_SEAL_LINKING_TICKET

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ping-openmls-sdk-react-native-macos",
-  "version": "0.7.10",
+  "version": "0.7.12",
   "description": "Real MLS for React Native macOS apps — wraps the ping-openmls-sdk Rust core via UniFFI.",
   "homepage": "https://github.com/AMP-Media-Development/ping-openmls-sdk",
   "license": "Apache-2.0",