@apollohg/react-native-prose-editor 0.1.0

package/ios/Generated_editor_core.swift

@@ -0,0 +1,1143 @@
+// 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 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 FfiConverterUInt64: FfiConverterPrimitive {
+    typealias FfiType = UInt64
+    typealias SwiftType = UInt64
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> UInt64 {
+        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)
+    }
+}
+/**
+ * Check if redo is available.
+ */
+public func editorCanRedo(id: UInt64) -> Bool  {
+    return try!  FfiConverterBool.lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_can_redo(
+        FfiConverterUInt64.lower(id),$0
+    )
+})
+}
+/**
+ * Check if undo is available.
+ */
+public func editorCanUndo(id: UInt64) -> Bool  {
+    return try!  FfiConverterBool.lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_can_undo(
+        FfiConverterUInt64.lower(id),$0
+    )
+})
+}
+/**
+ * Return the crate version string.
+ */
+public func editorCoreVersion() -> String  {
+    return try!  FfiConverterString.lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_core_version($0
+    )
+})
+}
+/**
+ * Create a new editor from a JSON config object.
+ *
+ * Config fields (all optional — empty object `{}` creates a default editor):
+ * - `"schema"`: custom schema definition (see `Schema::from_json`)
+ * - `"maxLength"`: maximum document length in characters
+ * - `"readOnly"`: if `true`, rejects non-API mutations
+ * - `"inputFilter"`: regex pattern; only matching characters are inserted
+ *
+ * Falls back to the default Tiptap schema when `"schema"` is absent or invalid.
+ */
+public func editorCreate(configJson: String) -> UInt64  {
+    return try!  FfiConverterUInt64.lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_create(
+        FfiConverterString.lower(configJson),$0
+    )
+})
+}
+/**
+ * Delete a scalar range then split the block (Enter with selection). Returns an update.
+ */
+public func editorDeleteAndSplitScalar(id: UInt64, scalarFrom: UInt32, scalarTo: UInt32) -> String  {
+    return try!  FfiConverterString.lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_delete_and_split_scalar(
+        FfiConverterUInt64.lower(id),
+        FfiConverterUInt32.lower(scalarFrom),
+        FfiConverterUInt32.lower(scalarTo),$0
+    )
+})
+}
+/**
+ * Delete a range. Returns an update JSON string.
+ */
+public func editorDeleteRange(id: UInt64, from: UInt32, to: UInt32) -> String  {
+    return try!  FfiConverterString.lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_delete_range(
+        FfiConverterUInt64.lower(id),
+        FfiConverterUInt32.lower(from),
+        FfiConverterUInt32.lower(to),$0
+    )
+})
+}
+/**
+ * Delete content between two scalar offsets. Returns an update JSON string.
+ */
+public func editorDeleteScalarRange(id: UInt64, scalarFrom: UInt32, scalarTo: UInt32) -> String  {
+    return try!  FfiConverterString.lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_delete_scalar_range(
+        FfiConverterUInt64.lower(id),
+        FfiConverterUInt32.lower(scalarFrom),
+        FfiConverterUInt32.lower(scalarTo),$0
+    )
+})
+}
+/**
+ * Destroy an editor instance, freeing its resources.
+ */
+public func editorDestroy(id: UInt64)  {try! rustCall() {
+    uniffi_editor_core_fn_func_editor_destroy(
+        FfiConverterUInt64.lower(id),$0
+    )
+}
+}
+/**
+ * Convert a document position to a rendered-text scalar offset.
+ */
+public func editorDocToScalar(id: UInt64, docPos: UInt32) -> UInt32  {
+    return try!  FfiConverterUInt32.lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_doc_to_scalar(
+        FfiConverterUInt64.lower(id),
+        FfiConverterUInt32.lower(docPos),$0
+    )
+})
+}
+/**
+ * Get the current editor state (render elements, selection, active state,
+ * history state) without performing any edits. Used by native views to pull
+ * initial state when binding to an already-loaded editor.
+ */
+public func editorGetCurrentState(id: UInt64) -> String  {
+    return try!  FfiConverterString.lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_get_current_state(
+        FfiConverterUInt64.lower(id),$0
+    )
+})
+}
+/**
+ * Get the editor's content as HTML.
+ */
+public func editorGetHtml(id: UInt64) -> String  {
+    return try!  FfiConverterString.lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_get_html(
+        FfiConverterUInt64.lower(id),$0
+    )
+})
+}
+/**
+ * Get the editor's content as ProseMirror JSON.
+ */
+public func editorGetJson(id: UInt64) -> String  {
+    return try!  FfiConverterString.lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_get_json(
+        FfiConverterUInt64.lower(id),$0
+    )
+})
+}
+/**
+ * Get the current selection as JSON.
+ */
+public func editorGetSelection(id: UInt64) -> String  {
+    return try!  FfiConverterString.lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_get_selection(
+        FfiConverterUInt64.lower(id),$0
+    )
+})
+}
+/**
+ * Indent the current list item into a nested list. Returns an update JSON string.
+ */
+public func editorIndentListItem(id: UInt64) -> String  {
+    return try!  FfiConverterString.lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_indent_list_item(
+        FfiConverterUInt64.lower(id),$0
+    )
+})
+}
+/**
+ * Indent the list item at an explicit scalar selection. Returns an update JSON string.
+ */
+public func editorIndentListItemAtSelectionScalar(id: UInt64, scalarAnchor: UInt32, scalarHead: UInt32) -> String  {
+    return try!  FfiConverterString.lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_indent_list_item_at_selection_scalar(
+        FfiConverterUInt64.lower(id),
+        FfiConverterUInt32.lower(scalarAnchor),
+        FfiConverterUInt32.lower(scalarHead),$0
+    )
+})
+}
+/**
+ * Insert HTML content at the current selection. Returns an update JSON string.
+ */
+public func editorInsertContentHtml(id: UInt64, html: String) -> String  {
+    return try!  FfiConverterString.lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_insert_content_html(
+        FfiConverterUInt64.lower(id),
+        FfiConverterString.lower(html),$0
+    )
+})
+}
+/**
+ * Insert JSON content at the current selection. Returns an update JSON string.
+ */
+public func editorInsertContentJson(id: UInt64, json: String) -> String  {
+    return try!  FfiConverterString.lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_insert_content_json(
+        FfiConverterUInt64.lower(id),
+        FfiConverterString.lower(json),$0
+    )
+})
+}
+/**
+ * Insert JSON content at an explicit scalar selection. Returns an update JSON string.
+ */
+public func editorInsertContentJsonAtSelectionScalar(id: UInt64, scalarAnchor: UInt32, scalarHead: UInt32, json: String) -> String  {
+    return try!  FfiConverterString.lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_insert_content_json_at_selection_scalar(
+        FfiConverterUInt64.lower(id),
+        FfiConverterUInt32.lower(scalarAnchor),
+        FfiConverterUInt32.lower(scalarHead),
+        FfiConverterString.lower(json),$0
+    )
+})
+}
+/**
+ * Insert a void node at the current selection. Returns an update JSON string.
+ */
+public func editorInsertNode(id: UInt64, nodeType: String) -> String  {
+    return try!  FfiConverterString.lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_insert_node(
+        FfiConverterUInt64.lower(id),
+        FfiConverterString.lower(nodeType),$0
+    )
+})
+}
+/**
+ * Insert a node at an explicit scalar selection. Returns an update JSON string.
+ */
+public func editorInsertNodeAtSelectionScalar(id: UInt64, scalarAnchor: UInt32, scalarHead: UInt32, nodeType: String) -> String  {
+    return try!  FfiConverterString.lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_insert_node_at_selection_scalar(
+        FfiConverterUInt64.lower(id),
+        FfiConverterUInt32.lower(scalarAnchor),
+        FfiConverterUInt32.lower(scalarHead),
+        FfiConverterString.lower(nodeType),$0
+    )
+})
+}
+/**
+ * Insert text at a position. Returns an update JSON string.
+ */
+public func editorInsertText(id: UInt64, pos: UInt32, text: String) -> String  {
+    return try!  FfiConverterString.lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_insert_text(
+        FfiConverterUInt64.lower(id),
+        FfiConverterUInt32.lower(pos),
+        FfiConverterString.lower(text),$0
+    )
+})
+}
+/**
+ * Insert text at a scalar offset. Returns an update JSON string.
+ */
+public func editorInsertTextScalar(id: UInt64, scalarPos: UInt32, text: String) -> String  {
+    return try!  FfiConverterString.lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_insert_text_scalar(
+        FfiConverterUInt64.lower(id),
+        FfiConverterUInt32.lower(scalarPos),
+        FfiConverterString.lower(text),$0
+    )
+})
+}
+/**
+ * Outdent the current list item to the parent list level. Returns an update JSON string.
+ */
+public func editorOutdentListItem(id: UInt64) -> String  {
+    return try!  FfiConverterString.lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_outdent_list_item(
+        FfiConverterUInt64.lower(id),$0
+    )
+})
+}
+/**
+ * Outdent the list item at an explicit scalar selection. Returns an update JSON string.
+ */
+public func editorOutdentListItemAtSelectionScalar(id: UInt64, scalarAnchor: UInt32, scalarHead: UInt32) -> String  {
+    return try!  FfiConverterString.lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_outdent_list_item_at_selection_scalar(
+        FfiConverterUInt64.lower(id),
+        FfiConverterUInt32.lower(scalarAnchor),
+        FfiConverterUInt32.lower(scalarHead),$0
+    )
+})
+}
+/**
+ * Redo. Returns an update JSON string, or empty string if nothing to redo.
+ */
+public func editorRedo(id: UInt64) -> String  {
+    return try!  FfiConverterString.lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_redo(
+        FfiConverterUInt64.lower(id),$0
+    )
+})
+}
+/**
+ * Replace entire document content with HTML via a transaction (preserves history).
+ */
+public func editorReplaceHtml(id: UInt64, html: String) -> String  {
+    return try!  FfiConverterString.lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_replace_html(
+        FfiConverterUInt64.lower(id),
+        FfiConverterString.lower(html),$0
+    )
+})
+}
+/**
+ * Replace entire document content with JSON via a transaction (preserves history).
+ */
+public func editorReplaceJson(id: UInt64, json: String) -> String  {
+    return try!  FfiConverterString.lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_replace_json(
+        FfiConverterUInt64.lower(id),
+        FfiConverterString.lower(json),$0
+    )
+})
+}
+/**
+ * Replace the current selection with plain text. Returns an update JSON string.
+ */
+public func editorReplaceSelectionText(id: UInt64, text: String) -> String  {
+    return try!  FfiConverterString.lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_replace_selection_text(
+        FfiConverterUInt64.lower(id),
+        FfiConverterString.lower(text),$0
+    )
+})
+}
+/**
+ * Replace a scalar range with text (atomic delete + insert). Returns an update JSON string.
+ */
+public func editorReplaceTextScalar(id: UInt64, scalarFrom: UInt32, scalarTo: UInt32, text: String) -> String  {
+    return try!  FfiConverterString.lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_replace_text_scalar(
+        FfiConverterUInt64.lower(id),
+        FfiConverterUInt32.lower(scalarFrom),
+        FfiConverterUInt32.lower(scalarTo),
+        FfiConverterString.lower(text),$0
+    )
+})
+}
+/**
+ * Convert a rendered-text scalar offset to a document position.
+ */
+public func editorScalarToDoc(id: UInt64, scalar: UInt32) -> UInt32  {
+    return try!  FfiConverterUInt32.lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_scalar_to_doc(
+        FfiConverterUInt64.lower(id),
+        FfiConverterUInt32.lower(scalar),$0
+    )
+})
+}
+/**
+ * Set the editor's content from an HTML string. Returns render elements as JSON.
+ */
+public func editorSetHtml(id: UInt64, html: String) -> String  {
+    return try!  FfiConverterString.lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_set_html(
+        FfiConverterUInt64.lower(id),
+        FfiConverterString.lower(html),$0
+    )
+})
+}
+/**
+ * Set the editor's content from a ProseMirror JSON string.
+ */
+public func editorSetJson(id: UInt64, json: String) -> String  {
+    return try!  FfiConverterString.lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_set_json(
+        FfiConverterUInt64.lower(id),
+        FfiConverterString.lower(json),$0
+    )
+})
+}
+/**
+ * Set the selection. Anchor and head are document positions.
+ */
+public func editorSetSelection(id: UInt64, anchor: UInt32, head: UInt32)  {try! rustCall() {
+    uniffi_editor_core_fn_func_editor_set_selection(
+        FfiConverterUInt64.lower(id),
+        FfiConverterUInt32.lower(anchor),
+        FfiConverterUInt32.lower(head),$0
+    )
+}
+}
+/**
+ * Set the selection from scalar offsets, converting to document positions internally.
+ */
+public func editorSetSelectionScalar(id: UInt64, scalarAnchor: UInt32, scalarHead: UInt32)  {try! rustCall() {
+    uniffi_editor_core_fn_func_editor_set_selection_scalar(
+        FfiConverterUInt64.lower(id),
+        FfiConverterUInt32.lower(scalarAnchor),
+        FfiConverterUInt32.lower(scalarHead),$0
+    )
+}
+}
+/**
+ * Split the block at a position (Enter key). Returns an update JSON string.
+ */
+public func editorSplitBlock(id: UInt64, pos: UInt32) -> String  {
+    return try!  FfiConverterString.lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_split_block(
+        FfiConverterUInt64.lower(id),
+        FfiConverterUInt32.lower(pos),$0
+    )
+})
+}
+/**
+ * Split a block at a scalar offset. Returns an update JSON string.
+ */
+public func editorSplitBlockScalar(id: UInt64, scalarPos: UInt32) -> String  {
+    return try!  FfiConverterString.lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_split_block_scalar(
+        FfiConverterUInt64.lower(id),
+        FfiConverterUInt32.lower(scalarPos),$0
+    )
+})
+}
+/**
+ * Toggle a mark on the current selection. Returns an update JSON string.
+ */
+public func editorToggleMark(id: UInt64, markName: String) -> String  {
+    return try!  FfiConverterString.lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_toggle_mark(
+        FfiConverterUInt64.lower(id),
+        FfiConverterString.lower(markName),$0
+    )
+})
+}
+/**
+ * Toggle a mark at an explicit scalar selection. Returns an update JSON string.
+ */
+public func editorToggleMarkAtSelectionScalar(id: UInt64, scalarAnchor: UInt32, scalarHead: UInt32, markName: String) -> String  {
+    return try!  FfiConverterString.lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_toggle_mark_at_selection_scalar(
+        FfiConverterUInt64.lower(id),
+        FfiConverterUInt32.lower(scalarAnchor),
+        FfiConverterUInt32.lower(scalarHead),
+        FfiConverterString.lower(markName),$0
+    )
+})
+}
+/**
+ * Undo. Returns an update JSON string, or empty string if nothing to undo.
+ */
+public func editorUndo(id: UInt64) -> String  {
+    return try!  FfiConverterString.lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_undo(
+        FfiConverterUInt64.lower(id),$0
+    )
+})
+}
+/**
+ * Unwrap the current list item back to a paragraph. Returns an update JSON string.
+ */
+public func editorUnwrapFromList(id: UInt64) -> String  {
+    return try!  FfiConverterString.lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_unwrap_from_list(
+        FfiConverterUInt64.lower(id),$0
+    )
+})
+}
+/**
+ * Unwrap the list item at an explicit scalar selection. Returns an update JSON string.
+ */
+public func editorUnwrapFromListAtSelectionScalar(id: UInt64, scalarAnchor: UInt32, scalarHead: UInt32) -> String  {
+    return try!  FfiConverterString.lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_unwrap_from_list_at_selection_scalar(
+        FfiConverterUInt64.lower(id),
+        FfiConverterUInt32.lower(scalarAnchor),
+        FfiConverterUInt32.lower(scalarHead),$0
+    )
+})
+}
+/**
+ * Wrap the current selection in a list. Returns an update JSON string.
+ */
+public func editorWrapInList(id: UInt64, listType: String) -> String  {
+    return try!  FfiConverterString.lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_wrap_in_list(
+        FfiConverterUInt64.lower(id),
+        FfiConverterString.lower(listType),$0
+    )
+})
+}
+/**
+ * Wrap or convert a list at an explicit scalar selection. Returns an update JSON string.
+ */
+public func editorWrapInListAtSelectionScalar(id: UInt64, scalarAnchor: UInt32, scalarHead: UInt32, listType: String) -> String  {
+    return try!  FfiConverterString.lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_wrap_in_list_at_selection_scalar(
+        FfiConverterUInt64.lower(id),
+        FfiConverterUInt32.lower(scalarAnchor),
+        FfiConverterUInt32.lower(scalarHead),
+        FfiConverterString.lower(listType),$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_can_redo() != 15854) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_can_undo() != 52062) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_core_version() != 41638) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_create() != 23908) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_delete_and_split_scalar() != 13764) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_delete_range() != 6109) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_delete_scalar_range() != 60098) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_destroy() != 35774) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_doc_to_scalar() != 48291) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_get_current_state() != 13946) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_get_html() != 28868) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_get_json() != 8212) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_get_selection() != 20571) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_indent_list_item() != 10818) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_indent_list_item_at_selection_scalar() != 13664) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_insert_content_html() != 62700) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_insert_content_json() != 56904) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_insert_content_json_at_selection_scalar() != 51362) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_insert_node() != 22371) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_insert_node_at_selection_scalar() != 32254) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_insert_text() != 22584) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_insert_text_scalar() != 30263) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_outdent_list_item() != 55796) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_outdent_list_item_at_selection_scalar() != 32672) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_redo() != 26508) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_replace_html() != 41778) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_replace_json() != 28738) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_replace_selection_text() != 11138) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_replace_text_scalar() != 45475) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_scalar_to_doc() != 40126) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_set_html() != 11045) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_set_json() != 18497) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_set_selection() != 28236) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_set_selection_scalar() != 16443) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_split_block() != 52038) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_split_block_scalar() != 47554) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_toggle_mark() != 30661) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_toggle_mark_at_selection_scalar() != 61751) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_undo() != 28689) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_unwrap_from_list() != 41875) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_unwrap_from_list_at_selection_scalar() != 57899) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_wrap_in_list() != 32846) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_editor_core_checksum_func_editor_wrap_in_list_at_selection_scalar() != 6459) {
+        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