@apollohg/react-native-rich-text-editor 2.0.0

package/ios/Generated_editor_core.swift

@@ -0,0 +1,2378 @@
+// This file was autogenerated by some hot garbage in the `uniffi` crate.
+// Trust me, you don't want to mess with it!
+
+// swiftlint:disable all
+import Foundation
+
+// Depending on the consumer's build setup, the low-level FFI code
+// might be in a separate module, or it might be compiled inline into
+// this module. This is a bit of light hackery to work with both.
+#if canImport(editor_coreFFI)
+import editor_coreFFI
+#endif
+
+fileprivate extension RustBuffer {
+    // Allocate a new buffer, copying the contents of a `UInt8` array.
+    init(bytes: [UInt8]) {
+        let rbuf = bytes.withUnsafeBufferPointer { ptr in
+            RustBuffer.from(ptr)
+        }
+        self.init(capacity: rbuf.capacity, len: rbuf.len, data: rbuf.data)
+    }
+
+    static func empty() -> RustBuffer {
+        RustBuffer(capacity: 0, len:0, data: nil)
+    }
+
+    static func from(_ ptr: UnsafeBufferPointer<UInt8>) -> RustBuffer {
+        try! rustCall { ffi_editor_core_rustbuffer_from_bytes(ForeignBytes(bufferPointer: ptr), $0) }
+    }
+
+    // Frees the buffer in place.
+    // The buffer must not be used after this is called.
+    func deallocate() {
+        try! rustCall { ffi_editor_core_rustbuffer_free(self, $0) }
+    }
+}
+
+fileprivate extension ForeignBytes {
+    init(bufferPointer: UnsafeBufferPointer<UInt8>) {
+        self.init(len: Int32(bufferPointer.count), data: bufferPointer.baseAddress)
+    }
+}
+
+// For every type used in the interface, we provide helper methods for conveniently
+// lifting and lowering that type from C-compatible data, and for reading and writing
+// values of that type in a buffer.
+
+// Helper classes/extensions that don't change.
+// Someday, this will be in a library of its own.
+
+fileprivate extension Data {
+    init(rustBuffer: RustBuffer) {
+        self.init(
+            bytesNoCopy: rustBuffer.data!,
+            count: Int(rustBuffer.len),
+            deallocator: .none
+        )
+    }
+}
+
+// Define reader functionality.  Normally this would be defined in a class or
+// struct, but we use standalone functions instead in order to make external
+// types work.
+//
+// With external types, one swift source file needs to be able to call the read
+// method on another source file's FfiConverter, but then what visibility
+// should Reader have?
+// - If Reader is fileprivate, then this means the read() must also
+//   be fileprivate, which doesn't work with external types.
+// - If Reader is internal/public, we'll get compile errors since both source
+//   files will try define the same type.
+//
+// Instead, the read() method and these helper functions input a tuple of data
+
+fileprivate func createReader(data: Data) -> (data: Data, offset: Data.Index) {
+    (data: data, offset: 0)
+}
+
+// Reads an integer at the current offset, in big-endian order, and advances
+// the offset on success. Throws if reading the integer would move the
+// offset past the end of the buffer.
+fileprivate func readInt<T: FixedWidthInteger>(_ reader: inout (data: Data, offset: Data.Index)) throws -> T {
+    let range = reader.offset..<reader.offset + MemoryLayout<T>.size
+    guard reader.data.count >= range.upperBound else {
+        throw UniffiInternalError.bufferOverflow
+    }
+    if T.self == UInt8.self {
+        let value = reader.data[reader.offset]
+        reader.offset += 1
+        return value as! T
+    }
+    var value: T = 0
+    let _ = withUnsafeMutableBytes(of: &value, { reader.data.copyBytes(to: $0, from: range)})
+    reader.offset = range.upperBound
+    return value.bigEndian
+}
+
+// Reads an arbitrary number of bytes, to be used to read
+// raw bytes, this is useful when lifting strings
+fileprivate func readBytes(_ reader: inout (data: Data, offset: Data.Index), count: Int) throws -> Array<UInt8> {
+    let range = reader.offset..<(reader.offset+count)
+    guard reader.data.count >= range.upperBound else {
+        throw UniffiInternalError.bufferOverflow
+    }
+    var value = [UInt8](repeating: 0, count: count)
+    value.withUnsafeMutableBufferPointer({ buffer in
+        reader.data.copyBytes(to: buffer, from: range)
+    })
+    reader.offset = range.upperBound
+    return value
+}
+
+// Reads a float at the current offset.
+fileprivate func readFloat(_ reader: inout (data: Data, offset: Data.Index)) throws -> Float {
+    return Float(bitPattern: try readInt(&reader))
+}
+
+// Reads a float at the current offset.
+fileprivate func readDouble(_ reader: inout (data: Data, offset: Data.Index)) throws -> Double {
+    return Double(bitPattern: try readInt(&reader))
+}
+
+// Indicates if the offset has reached the end of the buffer.
+fileprivate func hasRemaining(_ reader: (data: Data, offset: Data.Index)) -> Bool {
+    return reader.offset < reader.data.count
+}
+
+// Define writer functionality.  Normally this would be defined in a class or
+// struct, but we use standalone functions instead in order to make external
+// types work.  See the above discussion on Readers for details.
+
+fileprivate func createWriter() -> [UInt8] {
+    return []
+}
+
+fileprivate func writeBytes<S>(_ writer: inout [UInt8], _ byteArr: S) where S: Sequence, S.Element == UInt8 {
+    writer.append(contentsOf: byteArr)
+}
+
+// Writes an integer in big-endian order.
+//
+// Warning: make sure what you are trying to write
+// is in the correct type!
+fileprivate func writeInt<T: FixedWidthInteger>(_ writer: inout [UInt8], _ value: T) {
+    var value = value.bigEndian
+    withUnsafeBytes(of: &value) { writer.append(contentsOf: $0) }
+}
+
+fileprivate func writeFloat(_ writer: inout [UInt8], _ value: Float) {
+    writeInt(&writer, value.bitPattern)
+}
+
+fileprivate func writeDouble(_ writer: inout [UInt8], _ value: Double) {
+    writeInt(&writer, value.bitPattern)
+}
+
+// Protocol for types that transfer other types across the FFI. This is
+// analogous to the Rust trait of the same name.
+fileprivate protocol FfiConverter {
+    associatedtype FfiType
+    associatedtype SwiftType
+
+    static func lift(_ value: FfiType) throws -> SwiftType
+    static func lower(_ value: SwiftType) -> FfiType
+    static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType
+    static func write(_ value: SwiftType, into buf: inout [UInt8])
+}
+
+// Types conforming to `Primitive` pass themselves directly over the FFI.
+fileprivate protocol FfiConverterPrimitive: FfiConverter where FfiType == SwiftType { }
+
+extension FfiConverterPrimitive {
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+    public static func lift(_ value: FfiType) throws -> SwiftType {
+        return value
+    }
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+    public static func lower(_ value: SwiftType) -> FfiType {
+        return value
+    }
+}
+
+// Types conforming to `FfiConverterRustBuffer` lift and lower into a `RustBuffer`.
+// Used for complex types where it's hard to write a custom lift/lower.
+fileprivate protocol FfiConverterRustBuffer: FfiConverter where FfiType == RustBuffer {}
+
+extension FfiConverterRustBuffer {
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+    public static func lift(_ buf: RustBuffer) throws -> SwiftType {
+        var reader = createReader(data: Data(rustBuffer: buf))
+        let value = try read(from: &reader)
+        if hasRemaining(reader) {
+            throw UniffiInternalError.incompleteData
+        }
+        buf.deallocate()
+        return value
+    }
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+    public static func lower(_ value: SwiftType) -> RustBuffer {
+          var writer = createWriter()
+          write(value, into: &writer)
+          return RustBuffer(bytes: writer)
+    }
+}
+// An error type for FFI errors. These errors occur at the UniFFI level, not
+// the library level.
+fileprivate enum UniffiInternalError: LocalizedError {
+    case bufferOverflow
+    case incompleteData
+    case unexpectedOptionalTag
+    case unexpectedEnumCase
+    case unexpectedNullPointer
+    case unexpectedRustCallStatusCode
+    case unexpectedRustCallError
+    case unexpectedStaleHandle
+    case rustPanic(_ message: String)
+
+    public var errorDescription: String? {
+        switch self {
+        case .bufferOverflow: return "Reading the requested value would read past the end of the buffer"
+        case .incompleteData: return "The buffer still has data after lifting its containing value"
+        case .unexpectedOptionalTag: return "Unexpected optional tag; should be 0 or 1"
+        case .unexpectedEnumCase: return "Raw enum value doesn't match any cases"
+        case .unexpectedNullPointer: return "Raw pointer value was null"
+        case .unexpectedRustCallStatusCode: return "Unexpected RustCallStatus code"
+        case .unexpectedRustCallError: return "CALL_ERROR but no errorClass specified"
+        case .unexpectedStaleHandle: return "The object in the handle map has been dropped already"
+        case let .rustPanic(message): return message
+        }
+    }
+}
+
+fileprivate extension NSLock {
+    func withLock<T>(f: () throws -> T) rethrows -> T {
+        self.lock()
+        defer { self.unlock() }
+        return try f()
+    }
+}
+
+fileprivate let CALL_SUCCESS: Int8 = 0
+fileprivate let CALL_ERROR: Int8 = 1
+fileprivate let CALL_UNEXPECTED_ERROR: Int8 = 2
+fileprivate let CALL_CANCELLED: Int8 = 3
+
+fileprivate extension RustCallStatus {
+    init() {
+        self.init(
+            code: CALL_SUCCESS,
+            errorBuf: RustBuffer.init(
+                capacity: 0,
+                len: 0,
+                data: nil
+            )
+        )
+    }
+}
+
+private func rustCall<T>(_ callback: (UnsafeMutablePointer<RustCallStatus>) -> T) throws -> T {
+    let neverThrow: ((RustBuffer) throws -> Never)? = nil
+    return try makeRustCall(callback, errorHandler: neverThrow)
+}
+
+private func rustCallWithError<T, E: Swift.Error>(
+    _ errorHandler: @escaping (RustBuffer) throws -> E,
+    _ callback: (UnsafeMutablePointer<RustCallStatus>) -> T) throws -> T {
+    try makeRustCall(callback, errorHandler: errorHandler)
+}
+
+private func makeRustCall<T, E: Swift.Error>(
+    _ callback: (UnsafeMutablePointer<RustCallStatus>) -> T,
+    errorHandler: ((RustBuffer) throws -> E)?
+) throws -> T {
+    uniffiEnsureEditorCoreInitialized()
+    var callStatus = RustCallStatus.init()
+    let returnedVal = callback(&callStatus)
+    try uniffiCheckCallStatus(callStatus: callStatus, errorHandler: errorHandler)
+    return returnedVal
+}
+
+private func uniffiCheckCallStatus<E: Swift.Error>(
+    callStatus: RustCallStatus,
+    errorHandler: ((RustBuffer) throws -> E)?
+) throws {
+    switch callStatus.code {
+        case CALL_SUCCESS:
+            return
+
+        case CALL_ERROR:
+            if let errorHandler = errorHandler {
+                throw try errorHandler(callStatus.errorBuf)
+            } else {
+                callStatus.errorBuf.deallocate()
+                throw UniffiInternalError.unexpectedRustCallError
+            }
+
+        case CALL_UNEXPECTED_ERROR:
+            // When the rust code sees a panic, it tries to construct a RustBuffer
+            // with the message.  But if that code panics, then it just sends back
+            // an empty buffer.
+            if callStatus.errorBuf.len > 0 {
+                throw UniffiInternalError.rustPanic(try FfiConverterString.lift(callStatus.errorBuf))
+            } else {
+                callStatus.errorBuf.deallocate()
+                throw UniffiInternalError.rustPanic("Rust panic")
+            }
+
+        case CALL_CANCELLED:
+            fatalError("Cancellation not supported yet")
+
+        default:
+            throw UniffiInternalError.unexpectedRustCallStatusCode
+    }
+}
+
+private func uniffiTraitInterfaceCall<T>(
+    callStatus: UnsafeMutablePointer<RustCallStatus>,
+    makeCall: () throws -> T,
+    writeReturn: (T) -> ()
+) {
+    do {
+        try writeReturn(makeCall())
+    } catch let error {
+        callStatus.pointee.code = CALL_UNEXPECTED_ERROR
+        callStatus.pointee.errorBuf = FfiConverterString.lower(String(describing: error))
+    }
+}
+
+private func uniffiTraitInterfaceCallWithError<T, E>(
+    callStatus: UnsafeMutablePointer<RustCallStatus>,
+    makeCall: () throws -> T,
+    writeReturn: (T) -> (),
+    lowerError: (E) -> RustBuffer
+) {
+    do {
+        try writeReturn(makeCall())
+    } catch let error as E {
+        callStatus.pointee.code = CALL_ERROR
+        callStatus.pointee.errorBuf = lowerError(error)
+    } catch {
+        callStatus.pointee.code = CALL_UNEXPECTED_ERROR
+        callStatus.pointee.errorBuf = FfiConverterString.lower(String(describing: error))
+    }
+}
+fileprivate final class UniffiHandleMap<T>: @unchecked Sendable {
+    // All mutation happens with this lock held, which is why we implement @unchecked Sendable.
+    private let lock = NSLock()
+    private var map: [UInt64: T] = [:]
+    private var currentHandle: UInt64 = 1
+
+    func insert(obj: T) -> UInt64 {
+        lock.withLock {
+            let handle = currentHandle
+            currentHandle += 1
+            map[handle] = obj
+            return handle
+        }
+    }
+
+     func get(handle: UInt64) throws -> T {
+        try lock.withLock {
+            guard let obj = map[handle] else {
+                throw UniffiInternalError.unexpectedStaleHandle
+            }
+            return obj
+        }
+    }
+
+    @discardableResult
+    func remove(handle: UInt64) throws -> T {
+        try lock.withLock {
+            guard let obj = map.removeValue(forKey: handle) else {
+                throw UniffiInternalError.unexpectedStaleHandle
+            }
+            return obj
+        }
+    }
+
+    var count: Int {
+        get {
+            map.count
+        }
+    }
+}
+
+
+// Public interface members begin here.
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterUInt16: FfiConverterPrimitive {
+    typealias FfiType = UInt16
+    typealias SwiftType = UInt16
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> UInt16 {
+        return try lift(readInt(&buf))
+    }
+
+    public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
+        writeInt(&buf, lower(value))
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterUInt32: FfiConverterPrimitive {
+    typealias FfiType = UInt32
+    typealias SwiftType = UInt32
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> UInt32 {
+        return try lift(readInt(&buf))
+    }
+
+    public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
+        writeInt(&buf, lower(value))
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterBool : FfiConverter {
+    typealias FfiType = Int8
+    typealias SwiftType = Bool
+
+    public static func lift(_ value: Int8) throws -> Bool {
+        return value != 0
+    }
+
+    public static func lower(_ value: Bool) -> Int8 {
+        return value ? 1 : 0
+    }
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Bool {
+        return try lift(readInt(&buf))
+    }
+
+    public static func write(_ value: Bool, into buf: inout [UInt8]) {
+        writeInt(&buf, lower(value))
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterString: FfiConverter {
+    typealias SwiftType = String
+    typealias FfiType = RustBuffer
+
+    public static func lift(_ value: RustBuffer) throws -> String {
+        defer {
+            value.deallocate()
+        }
+        if value.data == nil {
+            return String()
+        }
+        let bytes = UnsafeBufferPointer<UInt8>(start: value.data!, count: Int(value.len))
+        return String(bytes: bytes, encoding: String.Encoding.utf8)!
+    }
+
+    public static func lower(_ value: String) -> RustBuffer {
+        return value.utf8CString.withUnsafeBufferPointer { ptr in
+            // The swift string gives us int8_t, we want uint8_t.
+            ptr.withMemoryRebound(to: UInt8.self) { ptr in
+                // The swift string gives us a trailing null byte, we don't want it.
+                let buf = UnsafeBufferPointer(rebasing: ptr.prefix(upTo: ptr.count - 1))
+                return RustBuffer.from(buf)
+            }
+        }
+    }
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> String {
+        let len: Int32 = try readInt(&buf)
+        return String(bytes: try readBytes(&buf, count: Int(len)), encoding: String.Encoding.utf8)!
+    }
+
+    public static func write(_ value: String, into buf: inout [UInt8]) {
+        let len = Int32(value.utf8.count)
+        writeInt(&buf, len)
+        writeBytes(&buf, value.utf8)
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterData: FfiConverterRustBuffer {
+    typealias SwiftType = Data
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Data {
+        let len: Int32 = try readInt(&buf)
+        return Data(try readBytes(&buf, count: Int(len)))
+    }
+
+    public static func write(_ value: Data, into buf: inout [UInt8]) {
+        let len = Int32(value.count)
+        writeInt(&buf, len)
+        writeBytes(&buf, value)
+    }
+}
+
+
+
+
+public protocol ViewerCompiledDocumentProtocol: AnyObject, Sendable {
+
+    func elements()  -> [FfiViewerElement]
+
+    func isEmpty()  -> Bool
+
+    func preferredTextBlockName()  -> String
+
+    func retainedBytesDecimal()  -> String
+
+    func semanticKey()  -> String
+
+    func trailingEmptyTextBlockCount()  -> UInt32
+
+}
+open class ViewerCompiledDocument: ViewerCompiledDocumentProtocol, @unchecked Sendable {
+    fileprivate let pointer: UnsafeMutableRawPointer!
+
+    /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly.
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+    public struct NoPointer {
+        public init() {}
+    }
+
+    // TODO: We'd like this to be `private` but for Swifty reasons,
+    // we can't implement `FfiConverter` without making this `required` and we can't
+    // make it `required` without making it `public`.
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+    required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) {
+        self.pointer = pointer
+    }
+
+    // This constructor can be used to instantiate a fake object.
+    // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject].
+    //
+    // - Warning:
+    //     Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash.
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+    public init(noPointer: NoPointer) {
+        self.pointer = nil
+    }
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+    public func uniffiClonePointer() -> UnsafeMutableRawPointer {
+        return try! rustCall { uniffi_editor_core_fn_clone_viewercompileddocument(self.pointer, $0) }
+    }
+    // No primary constructor declared for this class.
+
+    deinit {
+        guard let pointer = pointer else {
+            return
+        }
+
+        try! rustCall { uniffi_editor_core_fn_free_viewercompileddocument(pointer, $0) }
+    }
+
+
+
+
+open func elements() -> [FfiViewerElement]  {
+    return try!  FfiConverterSequenceTypeFfiViewerElement.lift(try! rustCall() {
+    uniffi_editor_core_fn_method_viewercompileddocument_elements(self.uniffiClonePointer(),$0
+    )
+})
+}
+
+open func isEmpty() -> Bool  {
+    return try!  FfiConverterBool.lift(try! rustCall() {
+    uniffi_editor_core_fn_method_viewercompileddocument_is_empty(self.uniffiClonePointer(),$0
+    )
+})
+}
+
+open func preferredTextBlockName() -> String  {
+    return try!  FfiConverterString.lift(try! rustCall() {
+    uniffi_editor_core_fn_method_viewercompileddocument_preferred_text_block_name(self.uniffiClonePointer(),$0
+    )
+})
+}
+
+open func retainedBytesDecimal() -> String  {
+    return try!  FfiConverterString.lift(try! rustCall() {
+    uniffi_editor_core_fn_method_viewercompileddocument_retained_bytes_decimal(self.uniffiClonePointer(),$0
+    )
+})
+}
+
+open func semanticKey() -> String  {
+    return try!  FfiConverterString.lift(try! rustCall() {
+    uniffi_editor_core_fn_method_viewercompileddocument_semantic_key(self.uniffiClonePointer(),$0
+    )
+})
+}
+
+open func trailingEmptyTextBlockCount() -> UInt32  {
+    return try!  FfiConverterUInt32.lift(try! rustCall() {
+    uniffi_editor_core_fn_method_viewercompileddocument_trailing_empty_text_block_count(self.uniffiClonePointer(),$0
+    )
+})
+}
+
+
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeViewerCompiledDocument: FfiConverter {
+
+    typealias FfiType = UnsafeMutableRawPointer
+    typealias SwiftType = ViewerCompiledDocument
+
+    public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> ViewerCompiledDocument {
+        return ViewerCompiledDocument(unsafeFromRawPointer: pointer)
+    }
+
+    public static func lower(_ value: ViewerCompiledDocument) -> UnsafeMutableRawPointer {
+        return value.uniffiClonePointer()
+    }
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ViewerCompiledDocument {
+        let v: UInt64 = try readInt(&buf)
+        // The Rust code won't compile if a pointer won't fit in a UInt64.
+        // We have to go via `UInt` because that's the thing that's the size of a pointer.
+        let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v))
+        if (ptr == nil) {
+            throw UniffiInternalError.unexpectedNullPointer
+        }
+        return try lift(ptr!)
+    }
+
+    public static func write(_ value: ViewerCompiledDocument, into buf: inout [UInt8]) {
+        // This fiddling is because `Int` is the thing that's the same size as a pointer.
+        // The Rust code won't compile if a pointer won't fit in a `UInt64`.
+        writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value)))))
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeViewerCompiledDocument_lift(_ pointer: UnsafeMutableRawPointer) throws -> ViewerCompiledDocument {
+    return try FfiConverterTypeViewerCompiledDocument.lift(pointer)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeViewerCompiledDocument_lower(_ value: ViewerCompiledDocument) -> UnsafeMutableRawPointer {
+    return FfiConverterTypeViewerCompiledDocument.lower(value)
+}
+
+
+
+
+public struct FfiError {
+    public var domain: String
+    public var code: String
+    public var message: String
+    public var requestId: String?
+    public var operationIndex: String?
+    public var limit: String?
+    public var actual: String?
+    public var detailsJson: String?
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(domain: String, code: String, message: String, requestId: String?, operationIndex: String?, limit: String?, actual: String?, detailsJson: String?) {
+        self.domain = domain
+        self.code = code
+        self.message = message
+        self.requestId = requestId
+        self.operationIndex = operationIndex
+        self.limit = limit
+        self.actual = actual
+        self.detailsJson = detailsJson
+    }
+}
+
+#if compiler(>=6)
+extension FfiError: Sendable {}
+#endif
+
+
+extension FfiError: Equatable, Hashable {
+    public static func ==(lhs: FfiError, rhs: FfiError) -> Bool {
+        if lhs.domain != rhs.domain {
+            return false
+        }
+        if lhs.code != rhs.code {
+            return false
+        }
+        if lhs.message != rhs.message {
+            return false
+        }
+        if lhs.requestId != rhs.requestId {
+            return false
+        }
+        if lhs.operationIndex != rhs.operationIndex {
+            return false
+        }
+        if lhs.limit != rhs.limit {
+            return false
+        }
+        if lhs.actual != rhs.actual {
+            return false
+        }
+        if lhs.detailsJson != rhs.detailsJson {
+            return false
+        }
+        return true
+    }
+
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(domain)
+        hasher.combine(code)
+        hasher.combine(message)
+        hasher.combine(requestId)
+        hasher.combine(operationIndex)
+        hasher.combine(limit)
+        hasher.combine(actual)
+        hasher.combine(detailsJson)
+    }
+}
+
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeFfiError: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> FfiError {
+        return
+            try FfiError(
+                domain: FfiConverterString.read(from: &buf),
+                code: FfiConverterString.read(from: &buf),
+                message: FfiConverterString.read(from: &buf),
+                requestId: FfiConverterOptionString.read(from: &buf),
+                operationIndex: FfiConverterOptionString.read(from: &buf),
+                limit: FfiConverterOptionString.read(from: &buf),
+                actual: FfiConverterOptionString.read(from: &buf),
+                detailsJson: FfiConverterOptionString.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: FfiError, into buf: inout [UInt8]) {
+        FfiConverterString.write(value.domain, into: &buf)
+        FfiConverterString.write(value.code, into: &buf)
+        FfiConverterString.write(value.message, into: &buf)
+        FfiConverterOptionString.write(value.requestId, into: &buf)
+        FfiConverterOptionString.write(value.operationIndex, into: &buf)
+        FfiConverterOptionString.write(value.limit, into: &buf)
+        FfiConverterOptionString.write(value.actual, into: &buf)
+        FfiConverterOptionString.write(value.detailsJson, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeFfiError_lift(_ buf: RustBuffer) throws -> FfiError {
+    return try FfiConverterTypeFfiError.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeFfiError_lower(_ value: FfiError) -> RustBuffer {
+    return FfiConverterTypeFfiError.lower(value)
+}
+
+
+public struct FfiJsonResult {
+    public var value: String?
+    public var error: FfiError?
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(value: String?, error: FfiError?) {
+        self.value = value
+        self.error = error
+    }
+}
+
+#if compiler(>=6)
+extension FfiJsonResult: Sendable {}
+#endif
+
+
+extension FfiJsonResult: Equatable, Hashable {
+    public static func ==(lhs: FfiJsonResult, rhs: FfiJsonResult) -> Bool {
+        if lhs.value != rhs.value {
+            return false
+        }
+        if lhs.error != rhs.error {
+            return false
+        }
+        return true
+    }
+
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(value)
+        hasher.combine(error)
+    }
+}
+
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeFfiJsonResult: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> FfiJsonResult {
+        return
+            try FfiJsonResult(
+                value: FfiConverterOptionString.read(from: &buf),
+                error: FfiConverterOptionTypeFfiError.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: FfiJsonResult, into buf: inout [UInt8]) {
+        FfiConverterOptionString.write(value.value, into: &buf)
+        FfiConverterOptionTypeFfiError.write(value.error, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeFfiJsonResult_lift(_ buf: RustBuffer) throws -> FfiJsonResult {
+    return try FfiConverterTypeFfiJsonResult.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeFfiJsonResult_lower(_ value: FfiJsonResult) -> RustBuffer {
+    return FfiConverterTypeFfiJsonResult.lower(value)
+}
+
+
+/**
+ * One active outbound transport lease. The identifier stays canonical
+ * decimal text while the y-protocols frame remains binary end-to-end.
+ */
+public struct FfiOutboundLease {
+    public var leaseId: String
+    public var frame: Data
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(leaseId: String, frame: Data) {
+        self.leaseId = leaseId
+        self.frame = frame
+    }
+}
+
+#if compiler(>=6)
+extension FfiOutboundLease: Sendable {}
+#endif
+
+
+extension FfiOutboundLease: Equatable, Hashable {
+    public static func ==(lhs: FfiOutboundLease, rhs: FfiOutboundLease) -> Bool {
+        if lhs.leaseId != rhs.leaseId {
+            return false
+        }
+        if lhs.frame != rhs.frame {
+            return false
+        }
+        return true
+    }
+
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(leaseId)
+        hasher.combine(frame)
+    }
+}
+
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeFfiOutboundLease: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> FfiOutboundLease {
+        return
+            try FfiOutboundLease(
+                leaseId: FfiConverterString.read(from: &buf),
+                frame: FfiConverterData.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: FfiOutboundLease, into buf: inout [UInt8]) {
+        FfiConverterString.write(value.leaseId, into: &buf)
+        FfiConverterData.write(value.frame, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeFfiOutboundLease_lift(_ buf: RustBuffer) throws -> FfiOutboundLease {
+    return try FfiConverterTypeFfiOutboundLease.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeFfiOutboundLease_lower(_ value: FfiOutboundLease) -> RustBuffer {
+    return FfiConverterTypeFfiOutboundLease.lower(value)
+}
+
+
+/**
+ * Explicit three-way lease result: exactly one of a retained value, a
+ * queue-empty marker, or an error is selected. Empty is not encoded as an
+ * empty binary frame, which keeps it distinct from valid protocol bytes.
+ */
+public struct FfiOutboundLeaseResult {
+    public var value: FfiOutboundLease?
+    public var empty: Bool
+    public var error: FfiError?
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(value: FfiOutboundLease?, empty: Bool, error: FfiError?) {
+        self.value = value
+        self.empty = empty
+        self.error = error
+    }
+}
+
+#if compiler(>=6)
+extension FfiOutboundLeaseResult: Sendable {}
+#endif
+
+
+extension FfiOutboundLeaseResult: Equatable, Hashable {
+    public static func ==(lhs: FfiOutboundLeaseResult, rhs: FfiOutboundLeaseResult) -> Bool {
+        if lhs.value != rhs.value {
+            return false
+        }
+        if lhs.empty != rhs.empty {
+            return false
+        }
+        if lhs.error != rhs.error {
+            return false
+        }
+        return true
+    }
+
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(value)
+        hasher.combine(empty)
+        hasher.combine(error)
+    }
+}
+
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeFfiOutboundLeaseResult: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> FfiOutboundLeaseResult {
+        return
+            try FfiOutboundLeaseResult(
+                value: FfiConverterOptionTypeFfiOutboundLease.read(from: &buf),
+                empty: FfiConverterBool.read(from: &buf),
+                error: FfiConverterOptionTypeFfiError.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: FfiOutboundLeaseResult, into buf: inout [UInt8]) {
+        FfiConverterOptionTypeFfiOutboundLease.write(value.value, into: &buf)
+        FfiConverterBool.write(value.empty, into: &buf)
+        FfiConverterOptionTypeFfiError.write(value.error, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeFfiOutboundLeaseResult_lift(_ buf: RustBuffer) throws -> FfiOutboundLeaseResult {
+    return try FfiConverterTypeFfiOutboundLeaseResult.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeFfiOutboundLeaseResult_lower(_ value: FfiOutboundLeaseResult) -> RustBuffer {
+    return FfiConverterTypeFfiOutboundLeaseResult.lower(value)
+}
+
+
+/**
+ * One exported document snapshot: the five-field manifest as JSON plus the
+ * encoded state as direct bytes (never a JSON number array).
+ */
+public struct FfiSnapshotExport {
+    public var metadataJson: String
+    public var encodedState: Data
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(metadataJson: String, encodedState: Data) {
+        self.metadataJson = metadataJson
+        self.encodedState = encodedState
+    }
+}
+
+#if compiler(>=6)
+extension FfiSnapshotExport: Sendable {}
+#endif
+
+
+extension FfiSnapshotExport: Equatable, Hashable {
+    public static func ==(lhs: FfiSnapshotExport, rhs: FfiSnapshotExport) -> Bool {
+        if lhs.metadataJson != rhs.metadataJson {
+            return false
+        }
+        if lhs.encodedState != rhs.encodedState {
+            return false
+        }
+        return true
+    }
+
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(metadataJson)
+        hasher.combine(encodedState)
+    }
+}
+
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeFfiSnapshotExport: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> FfiSnapshotExport {
+        return
+            try FfiSnapshotExport(
+                metadataJson: FfiConverterString.read(from: &buf),
+                encodedState: FfiConverterData.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: FfiSnapshotExport, into buf: inout [UInt8]) {
+        FfiConverterString.write(value.metadataJson, into: &buf)
+        FfiConverterData.write(value.encodedState, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeFfiSnapshotExport_lift(_ buf: RustBuffer) throws -> FfiSnapshotExport {
+    return try FfiConverterTypeFfiSnapshotExport.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeFfiSnapshotExport_lower(_ value: FfiSnapshotExport) -> RustBuffer {
+    return FfiConverterTypeFfiSnapshotExport.lower(value)
+}
+
+
+public struct FfiSnapshotExportResult {
+    public var value: FfiSnapshotExport?
+    public var error: FfiError?
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(value: FfiSnapshotExport?, error: FfiError?) {
+        self.value = value
+        self.error = error
+    }
+}
+
+#if compiler(>=6)
+extension FfiSnapshotExportResult: Sendable {}
+#endif
+
+
+extension FfiSnapshotExportResult: Equatable, Hashable {
+    public static func ==(lhs: FfiSnapshotExportResult, rhs: FfiSnapshotExportResult) -> Bool {
+        if lhs.value != rhs.value {
+            return false
+        }
+        if lhs.error != rhs.error {
+            return false
+        }
+        return true
+    }
+
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(value)
+        hasher.combine(error)
+    }
+}
+
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeFfiSnapshotExportResult: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> FfiSnapshotExportResult {
+        return
+            try FfiSnapshotExportResult(
+                value: FfiConverterOptionTypeFfiSnapshotExport.read(from: &buf),
+                error: FfiConverterOptionTypeFfiError.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: FfiSnapshotExportResult, into buf: inout [UInt8]) {
+        FfiConverterOptionTypeFfiSnapshotExport.write(value.value, into: &buf)
+        FfiConverterOptionTypeFfiError.write(value.error, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeFfiSnapshotExportResult_lift(_ buf: RustBuffer) throws -> FfiSnapshotExportResult {
+    return try FfiConverterTypeFfiSnapshotExportResult.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeFfiSnapshotExportResult_lower(_ value: FfiSnapshotExportResult) -> RustBuffer {
+    return FfiConverterTypeFfiSnapshotExportResult.lower(value)
+}
+
+
+public struct FfiUnitResult {
+    public var value: Bool?
+    public var error: FfiError?
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(value: Bool?, error: FfiError?) {
+        self.value = value
+        self.error = error
+    }
+}
+
+#if compiler(>=6)
+extension FfiUnitResult: Sendable {}
+#endif
+
+
+extension FfiUnitResult: Equatable, Hashable {
+    public static func ==(lhs: FfiUnitResult, rhs: FfiUnitResult) -> Bool {
+        if lhs.value != rhs.value {
+            return false
+        }
+        if lhs.error != rhs.error {
+            return false
+        }
+        return true
+    }
+
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(value)
+        hasher.combine(error)
+    }
+}
+
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeFfiUnitResult: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> FfiUnitResult {
+        return
+            try FfiUnitResult(
+                value: FfiConverterOptionBool.read(from: &buf),
+                error: FfiConverterOptionTypeFfiError.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: FfiUnitResult, into buf: inout [UInt8]) {
+        FfiConverterOptionBool.write(value.value, into: &buf)
+        FfiConverterOptionTypeFfiError.write(value.error, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeFfiUnitResult_lift(_ buf: RustBuffer) throws -> FfiUnitResult {
+    return try FfiConverterTypeFfiUnitResult.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeFfiUnitResult_lower(_ value: FfiUnitResult) -> RustBuffer {
+    return FfiConverterTypeFfiUnitResult.lower(value)
+}
+
+
+public struct FfiViewerCompileRequest {
+    public var sourceKind: FfiViewerSourceKind
+    public var source: String
+    public var configJson: String
+    public var imagesEnabled: Bool
+    public var mentionPrefix: String?
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(sourceKind: FfiViewerSourceKind, source: String, configJson: String, imagesEnabled: Bool, mentionPrefix: String?) {
+        self.sourceKind = sourceKind
+        self.source = source
+        self.configJson = configJson
+        self.imagesEnabled = imagesEnabled
+        self.mentionPrefix = mentionPrefix
+    }
+}
+
+#if compiler(>=6)
+extension FfiViewerCompileRequest: Sendable {}
+#endif
+
+
+extension FfiViewerCompileRequest: Equatable, Hashable {
+    public static func ==(lhs: FfiViewerCompileRequest, rhs: FfiViewerCompileRequest) -> Bool {
+        if lhs.sourceKind != rhs.sourceKind {
+            return false
+        }
+        if lhs.source != rhs.source {
+            return false
+        }
+        if lhs.configJson != rhs.configJson {
+            return false
+        }
+        if lhs.imagesEnabled != rhs.imagesEnabled {
+            return false
+        }
+        if lhs.mentionPrefix != rhs.mentionPrefix {
+            return false
+        }
+        return true
+    }
+
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(sourceKind)
+        hasher.combine(source)
+        hasher.combine(configJson)
+        hasher.combine(imagesEnabled)
+        hasher.combine(mentionPrefix)
+    }
+}
+
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeFfiViewerCompileRequest: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> FfiViewerCompileRequest {
+        return
+            try FfiViewerCompileRequest(
+                sourceKind: FfiConverterTypeFfiViewerSourceKind.read(from: &buf),
+                source: FfiConverterString.read(from: &buf),
+                configJson: FfiConverterString.read(from: &buf),
+                imagesEnabled: FfiConverterBool.read(from: &buf),
+                mentionPrefix: FfiConverterOptionString.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: FfiViewerCompileRequest, into buf: inout [UInt8]) {
+        FfiConverterTypeFfiViewerSourceKind.write(value.sourceKind, into: &buf)
+        FfiConverterString.write(value.source, into: &buf)
+        FfiConverterString.write(value.configJson, into: &buf)
+        FfiConverterBool.write(value.imagesEnabled, into: &buf)
+        FfiConverterOptionString.write(value.mentionPrefix, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeFfiViewerCompileRequest_lift(_ buf: RustBuffer) throws -> FfiViewerCompileRequest {
+    return try FfiConverterTypeFfiViewerCompileRequest.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeFfiViewerCompileRequest_lower(_ value: FfiViewerCompileRequest) -> RustBuffer {
+    return FfiConverterTypeFfiViewerCompileRequest.lower(value)
+}
+
+
+public struct FfiViewerCompileResult {
+    public var value: ViewerCompiledDocument?
+    public var error: FfiError?
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(value: ViewerCompiledDocument?, error: FfiError?) {
+        self.value = value
+        self.error = error
+    }
+}
+
+#if compiler(>=6)
+extension FfiViewerCompileResult: Sendable {}
+#endif
+
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeFfiViewerCompileResult: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> FfiViewerCompileResult {
+        return
+            try FfiViewerCompileResult(
+                value: FfiConverterOptionTypeViewerCompiledDocument.read(from: &buf),
+                error: FfiConverterOptionTypeFfiError.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: FfiViewerCompileResult, into buf: inout [UInt8]) {
+        FfiConverterOptionTypeViewerCompiledDocument.write(value.value, into: &buf)
+        FfiConverterOptionTypeFfiError.write(value.error, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeFfiViewerCompileResult_lift(_ buf: RustBuffer) throws -> FfiViewerCompileResult {
+    return try FfiConverterTypeFfiViewerCompileResult.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeFfiViewerCompileResult_lower(_ value: FfiViewerCompileResult) -> RustBuffer {
+    return FfiConverterTypeFfiViewerCompileResult.lower(value)
+}
+
+
+public struct FfiViewerMark {
+    public var markType: String
+    public var attrsJson: String
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(markType: String, attrsJson: String) {
+        self.markType = markType
+        self.attrsJson = attrsJson
+    }
+}
+
+#if compiler(>=6)
+extension FfiViewerMark: Sendable {}
+#endif
+
+
+extension FfiViewerMark: Equatable, Hashable {
+    public static func ==(lhs: FfiViewerMark, rhs: FfiViewerMark) -> Bool {
+        if lhs.markType != rhs.markType {
+            return false
+        }
+        if lhs.attrsJson != rhs.attrsJson {
+            return false
+        }
+        return true
+    }
+
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(markType)
+        hasher.combine(attrsJson)
+    }
+}
+
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeFfiViewerMark: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> FfiViewerMark {
+        return
+            try FfiViewerMark(
+                markType: FfiConverterString.read(from: &buf),
+                attrsJson: FfiConverterString.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: FfiViewerMark, into buf: inout [UInt8]) {
+        FfiConverterString.write(value.markType, into: &buf)
+        FfiConverterString.write(value.attrsJson, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeFfiViewerMark_lift(_ buf: RustBuffer) throws -> FfiViewerMark {
+    return try FfiConverterTypeFfiViewerMark.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeFfiViewerMark_lower(_ value: FfiViewerMark) -> RustBuffer {
+    return FfiConverterTypeFfiViewerMark.lower(value)
+}
+
+// Note that we don't yet support `indirect` for enums.
+// See https://github.com/mozilla/uniffi-rs/issues/396 for further discussion.
+
+public enum FfiViewerElement {
+
+    case textRun(text: String, marks: [FfiViewerMark]
+    )
+    case inlineAtom(nodeType: String, docPos: UInt32, attrsJson: String, label: String
+    )
+    case blockAtom(nodeType: String, docPos: UInt32, attrsJson: String, label: String
+    )
+    case blockStart(nodeType: String, language: String?, depth: UInt16, listContextJson: String?
+    )
+    case blockEnd
+}
+
+
+#if compiler(>=6)
+extension FfiViewerElement: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeFfiViewerElement: FfiConverterRustBuffer {
+    typealias SwiftType = FfiViewerElement
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> FfiViewerElement {
+        let variant: Int32 = try readInt(&buf)
+        switch variant {
+
+        case 1: return .textRun(text: try FfiConverterString.read(from: &buf), marks: try FfiConverterSequenceTypeFfiViewerMark.read(from: &buf)
+        )
+
+        case 2: return .inlineAtom(nodeType: try FfiConverterString.read(from: &buf), docPos: try FfiConverterUInt32.read(from: &buf), attrsJson: try FfiConverterString.read(from: &buf), label: try FfiConverterString.read(from: &buf)
+        )
+
+        case 3: return .blockAtom(nodeType: try FfiConverterString.read(from: &buf), docPos: try FfiConverterUInt32.read(from: &buf), attrsJson: try FfiConverterString.read(from: &buf), label: try FfiConverterString.read(from: &buf)
+        )
+
+        case 4: return .blockStart(nodeType: try FfiConverterString.read(from: &buf), language: try FfiConverterOptionString.read(from: &buf), depth: try FfiConverterUInt16.read(from: &buf), listContextJson: try FfiConverterOptionString.read(from: &buf)
+        )
+
+        case 5: return .blockEnd
+
+        default: throw UniffiInternalError.unexpectedEnumCase
+        }
+    }
+
+    public static func write(_ value: FfiViewerElement, into buf: inout [UInt8]) {
+        switch value {
+
+
+        case let .textRun(text,marks):
+            writeInt(&buf, Int32(1))
+            FfiConverterString.write(text, into: &buf)
+            FfiConverterSequenceTypeFfiViewerMark.write(marks, into: &buf)
+
+
+        case let .inlineAtom(nodeType,docPos,attrsJson,label):
+            writeInt(&buf, Int32(2))
+            FfiConverterString.write(nodeType, into: &buf)
+            FfiConverterUInt32.write(docPos, into: &buf)
+            FfiConverterString.write(attrsJson, into: &buf)
+            FfiConverterString.write(label, into: &buf)
+
+
+        case let .blockAtom(nodeType,docPos,attrsJson,label):
+            writeInt(&buf, Int32(3))
+            FfiConverterString.write(nodeType, into: &buf)
+            FfiConverterUInt32.write(docPos, into: &buf)
+            FfiConverterString.write(attrsJson, into: &buf)
+            FfiConverterString.write(label, into: &buf)
+
+
+        case let .blockStart(nodeType,language,depth,listContextJson):
+            writeInt(&buf, Int32(4))
+            FfiConverterString.write(nodeType, into: &buf)
+            FfiConverterOptionString.write(language, into: &buf)
+            FfiConverterUInt16.write(depth, into: &buf)
+            FfiConverterOptionString.write(listContextJson, into: &buf)
+
+
+        case .blockEnd:
+            writeInt(&buf, Int32(5))
+
+        }
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeFfiViewerElement_lift(_ buf: RustBuffer) throws -> FfiViewerElement {
+    return try FfiConverterTypeFfiViewerElement.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeFfiViewerElement_lower(_ value: FfiViewerElement) -> RustBuffer {
+    return FfiConverterTypeFfiViewerElement.lower(value)
+}
+
+
+extension FfiViewerElement: Equatable, Hashable {}
+
+
+
+
+
+
+// Note that we don't yet support `indirect` for enums.
+// See https://github.com/mozilla/uniffi-rs/issues/396 for further discussion.
+
+public enum FfiViewerSourceKind {
+
+    case json
+    case html
+}
+
+
+#if compiler(>=6)
+extension FfiViewerSourceKind: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeFfiViewerSourceKind: FfiConverterRustBuffer {
+    typealias SwiftType = FfiViewerSourceKind
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> FfiViewerSourceKind {
+        let variant: Int32 = try readInt(&buf)
+        switch variant {
+
+        case 1: return .json
+
+        case 2: return .html
+
+        default: throw UniffiInternalError.unexpectedEnumCase
+        }
+    }
+
+    public static func write(_ value: FfiViewerSourceKind, into buf: inout [UInt8]) {
+        switch value {
+
+
+        case .json:
+            writeInt(&buf, Int32(1))
+
+
+        case .html:
+            writeInt(&buf, Int32(2))
+
+        }
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeFfiViewerSourceKind_lift(_ buf: RustBuffer) throws -> FfiViewerSourceKind {
+    return try FfiConverterTypeFfiViewerSourceKind.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeFfiViewerSourceKind_lower(_ value: FfiViewerSourceKind) -> RustBuffer {
+    return FfiConverterTypeFfiViewerSourceKind.lower(value)
+}
+
+
+extension FfiViewerSourceKind: Equatable, Hashable {}
+
+
+
+
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterOptionUInt32: FfiConverterRustBuffer {
+    typealias SwiftType = UInt32?
+
+    public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
+        guard let value = value else {
+            writeInt(&buf, Int8(0))
+            return
+        }
+        writeInt(&buf, Int8(1))
+        FfiConverterUInt32.write(value, into: &buf)
+    }
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType {
+        switch try readInt(&buf) as Int8 {
+        case 0: return nil
+        case 1: return try FfiConverterUInt32.read(from: &buf)
+        default: throw UniffiInternalError.unexpectedOptionalTag
+        }
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterOptionBool: FfiConverterRustBuffer {
+    typealias SwiftType = Bool?
+
+    public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
+        guard let value = value else {
+            writeInt(&buf, Int8(0))
+            return
+        }
+        writeInt(&buf, Int8(1))
+        FfiConverterBool.write(value, into: &buf)
+    }
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType {
+        switch try readInt(&buf) as Int8 {
+        case 0: return nil
+        case 1: return try FfiConverterBool.read(from: &buf)
+        default: throw UniffiInternalError.unexpectedOptionalTag
+        }
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterOptionString: FfiConverterRustBuffer {
+    typealias SwiftType = String?
+
+    public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
+        guard let value = value else {
+            writeInt(&buf, Int8(0))
+            return
+        }
+        writeInt(&buf, Int8(1))
+        FfiConverterString.write(value, into: &buf)
+    }
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType {
+        switch try readInt(&buf) as Int8 {
+        case 0: return nil
+        case 1: return try FfiConverterString.read(from: &buf)
+        default: throw UniffiInternalError.unexpectedOptionalTag
+        }
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterOptionData: FfiConverterRustBuffer {
+    typealias SwiftType = Data?
+
+    public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
+        guard let value = value else {
+            writeInt(&buf, Int8(0))
+            return
+        }
+        writeInt(&buf, Int8(1))
+        FfiConverterData.write(value, into: &buf)
+    }
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType {
+        switch try readInt(&buf) as Int8 {
+        case 0: return nil
+        case 1: return try FfiConverterData.read(from: &buf)
+        default: throw UniffiInternalError.unexpectedOptionalTag
+        }
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterOptionTypeViewerCompiledDocument: FfiConverterRustBuffer {
+    typealias SwiftType = ViewerCompiledDocument?
+
+    public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
+        guard let value = value else {
+            writeInt(&buf, Int8(0))
+            return
+        }
+        writeInt(&buf, Int8(1))
+        FfiConverterTypeViewerCompiledDocument.write(value, into: &buf)
+    }
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType {
+        switch try readInt(&buf) as Int8 {
+        case 0: return nil
+        case 1: return try FfiConverterTypeViewerCompiledDocument.read(from: &buf)
+        default: throw UniffiInternalError.unexpectedOptionalTag
+        }
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterOptionTypeFfiError: FfiConverterRustBuffer {
+    typealias SwiftType = FfiError?
+
+    public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
+        guard let value = value else {
+            writeInt(&buf, Int8(0))
+            return
+        }
+        writeInt(&buf, Int8(1))
+        FfiConverterTypeFfiError.write(value, into: &buf)
+    }
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType {
+        switch try readInt(&buf) as Int8 {
+        case 0: return nil
+        case 1: return try FfiConverterTypeFfiError.read(from: &buf)
+        default: throw UniffiInternalError.unexpectedOptionalTag
+        }
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterOptionTypeFfiOutboundLease: FfiConverterRustBuffer {
+    typealias SwiftType = FfiOutboundLease?
+
+    public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
+        guard let value = value else {
+            writeInt(&buf, Int8(0))
+            return
+        }
+        writeInt(&buf, Int8(1))
+        FfiConverterTypeFfiOutboundLease.write(value, into: &buf)
+    }
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType {
+        switch try readInt(&buf) as Int8 {
+        case 0: return nil
+        case 1: return try FfiConverterTypeFfiOutboundLease.read(from: &buf)
+        default: throw UniffiInternalError.unexpectedOptionalTag
+        }
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterOptionTypeFfiSnapshotExport: FfiConverterRustBuffer {
+    typealias SwiftType = FfiSnapshotExport?
+
+    public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
+        guard let value = value else {
+            writeInt(&buf, Int8(0))
+            return
+        }
+        writeInt(&buf, Int8(1))
+        FfiConverterTypeFfiSnapshotExport.write(value, into: &buf)
+    }
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType {
+        switch try readInt(&buf) as Int8 {
+        case 0: return nil
+        case 1: return try FfiConverterTypeFfiSnapshotExport.read(from: &buf)
+        default: throw UniffiInternalError.unexpectedOptionalTag
+        }
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterSequenceTypeFfiViewerMark: FfiConverterRustBuffer {
+    typealias SwiftType = [FfiViewerMark]
+
+    public static func write(_ value: [FfiViewerMark], into buf: inout [UInt8]) {
+        let len = Int32(value.count)
+        writeInt(&buf, len)
+        for item in value {
+            FfiConverterTypeFfiViewerMark.write(item, into: &buf)
+        }
+    }
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [FfiViewerMark] {
+        let len: Int32 = try readInt(&buf)
+        var seq = [FfiViewerMark]()
+        seq.reserveCapacity(Int(len))
+        for _ in 0 ..< len {
+            seq.append(try FfiConverterTypeFfiViewerMark.read(from: &buf))
+        }
+        return seq
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterSequenceTypeFfiViewerElement: FfiConverterRustBuffer {
+    typealias SwiftType = [FfiViewerElement]
+
+    public static func write(_ value: [FfiViewerElement], into buf: inout [UInt8]) {
+        let len = Int32(value.count)
+        writeInt(&buf, len)
+        for item in value {
+            FfiConverterTypeFfiViewerElement.write(item, into: &buf)
+        }
+    }
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [FfiViewerElement] {
+        let len: Int32 = try readInt(&buf)
+        var seq = [FfiViewerElement]()
+        seq.reserveCapacity(Int(len))
+        for _ in 0 ..< len {
+            seq.append(try FfiConverterTypeFfiViewerElement.read(from: &buf))
+        }
+        return seq
+    }
+}
+/**
+ * Return the crate version string.
+ */
+public func editorCoreVersion() -> String  {
+    return try!  FfiConverterString.lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_core_version($0
+    )
+})
+}
+public func editorV2ApplyCommand(editorId: String, requestJson: String) -> FfiJsonResult  {
+    return try!  FfiConverterTypeFfiJsonResult_lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_v2_apply_command(
+        FfiConverterString.lower(editorId),
+        FfiConverterString.lower(requestJson),$0
+    )
+})
+}
+public func editorV2ApplyInput(editorId: String, requestJson: String) -> FfiJsonResult  {
+    return try!  FfiConverterTypeFfiJsonResult_lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_v2_apply_input(
+        FfiConverterString.lower(editorId),
+        FfiConverterString.lower(requestJson),$0
+    )
+})
+}
+public func editorV2ApplyLocalApi(editorId: String, requestJson: String) -> FfiJsonResult  {
+    return try!  FfiConverterTypeFfiJsonResult_lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_v2_apply_local_api(
+        FfiConverterString.lower(editorId),
+        FfiConverterString.lower(requestJson),$0
+    )
+})
+}
+public func editorV2ApplyNativeIntent(editorId: String, requestJson: String) -> FfiJsonResult  {
+    return try!  FfiConverterTypeFfiJsonResult_lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_v2_apply_native_intent(
+        FfiConverterString.lower(editorId),
+        FfiConverterString.lower(requestJson),$0
+    )
+})
+}
+public func editorV2CollaborationAckOutbound(editorId: String, generation: String, leaseId: String) -> FfiJsonResult  {
+    return try!  FfiConverterTypeFfiJsonResult_lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_v2_collaboration_ack_outbound(
+        FfiConverterString.lower(editorId),
+        FfiConverterString.lower(generation),
+        FfiConverterString.lower(leaseId),$0
+    )
+})
+}
+/**
+ * Tears down transport state while retaining the editor, document, desired
+ * awareness state, and pending outbox entries.
+ */
+public func editorV2CollaborationDetach(editorId: String) -> FfiUnitResult  {
+    return try!  FfiConverterTypeFfiUnitResult_lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_v2_collaboration_detach(
+        FfiConverterString.lower(editorId),$0
+    )
+})
+}
+/**
+ * Drive initial connection, reconnect eligibility, local-awareness renewal,
+ * and remote-peer expiry from one Rust-owned monotonic clock operation.
+ */
+public func editorV2CollaborationDrive(editorId: String, nowMillis: String) -> FfiJsonResult  {
+    return try!  FfiConverterTypeFfiJsonResult_lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_v2_collaboration_drive(
+        FfiConverterString.lower(editorId),
+        FfiConverterString.lower(nowMillis),$0
+    )
+})
+}
+/**
+ * Lease one retained complete outbound frame. Exactly one of value, empty,
+ * or error is selected; protocol replies retain priority over document
+ * updates unless a frame was already leased.
+ */
+public func editorV2CollaborationLeaseOutbound(editorId: String, generation: String) -> FfiOutboundLeaseResult  {
+    return try!  FfiConverterTypeFfiOutboundLeaseResult_lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_v2_collaboration_lease_outbound(
+        FfiConverterString.lower(editorId),
+        FfiConverterString.lower(generation),$0
+    )
+})
+}
+public func editorV2CollaborationNackOutbound(editorId: String, generation: String, leaseId: String) -> FfiJsonResult  {
+    return try!  FfiConverterTypeFfiJsonResult_lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_v2_collaboration_nack_outbound(
+        FfiConverterString.lower(editorId),
+        FfiConverterString.lower(generation),
+        FfiConverterString.lower(leaseId),$0
+    )
+})
+}
+/**
+ * Live awareness peer projections; client ids are decimal strings so full
+ * u64 ids survive the JSON round-trip.
+ */
+public func editorV2CollaborationPeers(editorId: String) -> FfiJsonResult  {
+    return try!  FfiConverterTypeFfiJsonResult_lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_v2_collaboration_peers(
+        FfiConverterString.lower(editorId),$0
+    )
+})
+}
+/**
+ * Reopens the transport lifecycle after an explicit detach.
+ */
+public func editorV2CollaborationReattach(editorId: String) -> FfiUnitResult  {
+    return try!  FfiConverterTypeFfiUnitResult_lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_v2_collaboration_reattach(
+        FfiConverterString.lower(editorId),$0
+    )
+})
+}
+public func editorV2CollaborationReceive(editorId: String, generation: String, message: Data, nowMillis: String) -> FfiJsonResult  {
+    return try!  FfiConverterTypeFfiJsonResult_lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_v2_collaboration_receive(
+        FfiConverterString.lower(editorId),
+        FfiConverterString.lower(generation),
+        FfiConverterData.lower(message),
+        FfiConverterString.lower(nowMillis),$0
+    )
+})
+}
+/**
+ * Publishes a typed local awareness intent; the literal JSON `null`
+ * withdraws it (standard tombstone broadcast). Rust validates the closed
+ * shape and owns any published sticky cursor representation.
+ */
+public func editorV2CollaborationSetAwareness(editorId: String, awarenessJson: String) -> FfiUnitResult  {
+    return try!  FfiConverterTypeFfiUnitResult_lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_v2_collaboration_set_awareness(
+        FfiConverterString.lower(editorId),
+        FfiConverterString.lower(awarenessJson),$0
+    )
+})
+}
+public func editorV2CollaborationSetAwarenessSelection(editorId: String, selectionJson: String) -> FfiJsonResult  {
+    return try!  FfiConverterTypeFfiJsonResult_lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_v2_collaboration_set_awareness_selection(
+        FfiConverterString.lower(editorId),
+        FfiConverterString.lower(selectionJson),$0
+    )
+})
+}
+/**
+ * `reason` carries no classification weight (Rust alone owns retry
+ * eligibility); a policy-violation close code (1008) parks the transport
+ * `Incompatible`, every other reported close is retryable.
+ */
+public func editorV2CollaborationSocketClose(editorId: String, generation: String, code: UInt32?, reason: String?, nowMillis: String) -> FfiJsonResult  {
+    return try!  FfiConverterTypeFfiJsonResult_lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_v2_collaboration_socket_close(
+        FfiConverterString.lower(editorId),
+        FfiConverterString.lower(generation),
+        FfiConverterOptionUInt32.lower(code),
+        FfiConverterOptionString.lower(reason),
+        FfiConverterString.lower(nowMillis),$0
+    )
+})
+}
+/**
+ * Socket open queues framed Sync Step 1 at protocol priority and returns
+ * only the frozen directive; bytes are retrieved through `lease_outbound`.
+ */
+public func editorV2CollaborationSocketOpen(editorId: String, generation: String, nowMillis: String) -> FfiJsonResult  {
+    return try!  FfiConverterTypeFfiJsonResult_lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_v2_collaboration_socket_open(
+        FfiConverterString.lower(editorId),
+        FfiConverterString.lower(generation),
+        FfiConverterString.lower(nowMillis),$0
+    )
+})
+}
+public func editorV2Create(configJson: String, snapshotState: Data?) -> FfiJsonResult  {
+    return try!  FfiConverterTypeFfiJsonResult_lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_v2_create(
+        FfiConverterString.lower(configJson),
+        FfiConverterOptionData.lower(snapshotState),$0
+    )
+})
+}
+public func editorV2Destroy(editorId: String) -> FfiUnitResult  {
+    return try!  FfiConverterTypeFfiUnitResult_lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_v2_destroy(
+        FfiConverterString.lower(editorId),$0
+    )
+})
+}
+public func editorV2DocToScalar(editorId: String, docPos: UInt32) -> FfiJsonResult  {
+    return try!  FfiConverterTypeFfiJsonResult_lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_v2_doc_to_scalar(
+        FfiConverterString.lower(editorId),
+        FfiConverterUInt32.lower(docPos),$0
+    )
+})
+}
+public func editorV2GetContentSnapshot(editorId: String) -> FfiJsonResult  {
+    return try!  FfiConverterTypeFfiJsonResult_lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_v2_get_content_snapshot(
+        FfiConverterString.lower(editorId),$0
+    )
+})
+}
+public func editorV2GetDocumentHtml(editorId: String) -> FfiJsonResult  {
+    return try!  FfiConverterTypeFfiJsonResult_lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_v2_get_document_html(
+        FfiConverterString.lower(editorId),$0
+    )
+})
+}
+public func editorV2GetDocumentJson(editorId: String) -> FfiJsonResult  {
+    return try!  FfiConverterTypeFfiJsonResult_lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_v2_get_document_json(
+        FfiConverterString.lower(editorId),$0
+    )
+})
+}
+public func editorV2GetState(editorId: String) -> FfiJsonResult  {
+    return try!  FfiConverterTypeFfiJsonResult_lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_v2_get_state(
+        FfiConverterString.lower(editorId),$0
+    )
+})
+}
+public func editorV2PinPositionEpoch(editorId: String, ownerId: String, documentRevision: String) -> FfiJsonResult  {
+    return try!  FfiConverterTypeFfiJsonResult_lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_v2_pin_position_epoch(
+        FfiConverterString.lower(editorId),
+        FfiConverterString.lower(ownerId),
+        FfiConverterString.lower(documentRevision),$0
+    )
+})
+}
+public func editorV2Redo(editorId: String, requestJson: String) -> FfiJsonResult  {
+    return try!  FfiConverterTypeFfiJsonResult_lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_v2_redo(
+        FfiConverterString.lower(editorId),
+        FfiConverterString.lower(requestJson),$0
+    )
+})
+}
+public func editorV2ReleaseNativeBinding(editorId: String, ownerId: String) -> FfiUnitResult  {
+    return try!  FfiConverterTypeFfiUnitResult_lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_v2_release_native_binding(
+        FfiConverterString.lower(editorId),
+        FfiConverterString.lower(ownerId),$0
+    )
+})
+}
+public func editorV2RenderNative(editorId: String, ownerId: String, mirrorScalarAnchor: UInt32?, mirrorScalarHead: UInt32?) -> FfiJsonResult  {
+    return try!  FfiConverterTypeFfiJsonResult_lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_v2_render_native(
+        FfiConverterString.lower(editorId),
+        FfiConverterString.lower(ownerId),
+        FfiConverterOptionUInt32.lower(mirrorScalarAnchor),
+        FfiConverterOptionUInt32.lower(mirrorScalarHead),$0
+    )
+})
+}
+public func editorV2RenderUpdate(editorId: String, mirrorScalarAnchor: UInt32?, mirrorScalarHead: UInt32?) -> FfiJsonResult  {
+    return try!  FfiConverterTypeFfiJsonResult_lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_v2_render_update(
+        FfiConverterString.lower(editorId),
+        FfiConverterOptionUInt32.lower(mirrorScalarAnchor),
+        FfiConverterOptionUInt32.lower(mirrorScalarHead),$0
+    )
+})
+}
+public func editorV2ReplaceDocument(editorId: String, requestJson: String) -> FfiJsonResult  {
+    return try!  FfiConverterTypeFfiJsonResult_lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_v2_replace_document(
+        FfiConverterString.lower(editorId),
+        FfiConverterString.lower(requestJson),$0
+    )
+})
+}
+public func editorV2ResolveScalarSelection(editorId: String, scalarAnchor: UInt32, scalarHead: UInt32) -> FfiJsonResult  {
+    return try!  FfiConverterTypeFfiJsonResult_lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_v2_resolve_scalar_selection(
+        FfiConverterString.lower(editorId),
+        FfiConverterUInt32.lower(scalarAnchor),
+        FfiConverterUInt32.lower(scalarHead),$0
+    )
+})
+}
+public func editorV2ScalarToDoc(editorId: String, scalar: UInt32) -> FfiJsonResult  {
+    return try!  FfiConverterTypeFfiJsonResult_lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_v2_scalar_to_doc(
+        FfiConverterString.lower(editorId),
+        FfiConverterUInt32.lower(scalar),$0
+    )
+})
+}
+public func editorV2SetSelection(editorId: String, requestJson: String) -> FfiJsonResult  {
+    return try!  FfiConverterTypeFfiJsonResult_lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_v2_set_selection(
+        FfiConverterString.lower(editorId),
+        FfiConverterString.lower(requestJson),$0
+    )
+})
+}
+public func editorV2SnapshotExport(editorId: String) -> FfiSnapshotExportResult  {
+    return try!  FfiConverterTypeFfiSnapshotExportResult_lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_v2_snapshot_export(
+        FfiConverterString.lower(editorId),$0
+    )
+})
+}
+public func editorV2SnapshotRestore(editorId: String, metadataJson: String, encodedState: Data) -> FfiJsonResult  {
+    return try!  FfiConverterTypeFfiJsonResult_lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_v2_snapshot_restore(
+        FfiConverterString.lower(editorId),
+        FfiConverterString.lower(metadataJson),
+        FfiConverterData.lower(encodedState),$0
+    )
+})
+}
+public func editorV2Undo(editorId: String, requestJson: String) -> FfiJsonResult  {
+    return try!  FfiConverterTypeFfiJsonResult_lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_v2_undo(
+        FfiConverterString.lower(editorId),
+        FfiConverterString.lower(requestJson),$0
+    )
+})
+}
+public func viewerCompile(request: FfiViewerCompileRequest) -> FfiViewerCompileResult  {
+    return try!  FfiConverterTypeFfiViewerCompileResult_lift(try! rustCall() {
+    uniffi_editor_core_fn_func_viewer_compile(
+        FfiConverterTypeFfiViewerCompileRequest_lower(request),$0
+    )
+})
+}
+
+private enum InitializationResult {
+    case ok
+    case contractVersionMismatch
+    case apiChecksumMismatch
+}
+// Use a global variable to perform the versioning checks. Swift ensures that
+// the code inside is only computed once.
+private let initializationResult: InitializationResult = {
+    // Get the bindings contract version from our ComponentInterface
+    let bindings_contract_version = 29
+    // Get the scaffolding contract version by calling the into the dylib
+    let scaffolding_contract_version = ffi_editor_core_uniffi_contract_version()
+    if bindings_contract_version != scaffolding_contract_version {
+        return InitializationResult.contractVersionMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_core_version() != 41638) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_v2_apply_command() != 14484) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_v2_apply_input() != 29912) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_v2_apply_local_api() != 36451) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_v2_apply_native_intent() != 46364) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_v2_collaboration_ack_outbound() != 21755) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_v2_collaboration_detach() != 25325) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_v2_collaboration_drive() != 55434) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_v2_collaboration_lease_outbound() != 56190) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_v2_collaboration_nack_outbound() != 29045) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_v2_collaboration_peers() != 754) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_v2_collaboration_reattach() != 44291) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_v2_collaboration_receive() != 19926) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_v2_collaboration_set_awareness() != 59502) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_v2_collaboration_set_awareness_selection() != 3071) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_v2_collaboration_socket_close() != 53946) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_v2_collaboration_socket_open() != 25835) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_v2_create() != 9333) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_v2_destroy() != 8349) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_v2_doc_to_scalar() != 62503) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_v2_get_content_snapshot() != 21323) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_v2_get_document_html() != 60959) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_v2_get_document_json() != 25683) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_v2_get_state() != 43856) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_v2_pin_position_epoch() != 42714) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_v2_redo() != 48065) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_v2_release_native_binding() != 2756) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_v2_render_native() != 16234) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_v2_render_update() != 13282) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_v2_replace_document() != 31032) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_v2_resolve_scalar_selection() != 26332) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_v2_scalar_to_doc() != 60383) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_v2_set_selection() != 39340) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_v2_snapshot_export() != 2193) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_v2_snapshot_restore() != 47504) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_v2_undo() != 2492) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_viewer_compile() != 60070) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_method_viewercompileddocument_elements() != 50589) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_method_viewercompileddocument_is_empty() != 2370) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_method_viewercompileddocument_preferred_text_block_name() != 32137) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_method_viewercompileddocument_retained_bytes_decimal() != 13333) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_method_viewercompileddocument_semantic_key() != 2241) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_method_viewercompileddocument_trailing_empty_text_block_count() != 11698) {
+        return InitializationResult.apiChecksumMismatch
+    }
+
+    return InitializationResult.ok
+}()
+
+// Make the ensure init function public so that other modules which have external type references to
+// our types can call it.
+public func uniffiEnsureEditorCoreInitialized() {
+    switch initializationResult {
+    case .ok:
+        break
+    case .contractVersionMismatch:
+        fatalError("UniFFI contract version mismatch: try cleaning and rebuilding your project")
+    case .apiChecksumMismatch:
+        fatalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+}
+
+// swiftlint:enable all