From ddcc5b392ca5f2d79b51bf3d276ef357a6805ebc Mon Sep 17 00:00:00 2001 From: wangdl Date: Sat, 30 May 2026 22:13:22 +0800 Subject: [PATCH] feat: generated Swift bindings from UDL (48KB) --- bindings/ios/generated/zx_document.swift | 1548 ++++++++++++++++++++++ 1 file changed, 1548 insertions(+) create mode 100644 bindings/ios/generated/zx_document.swift diff --git a/bindings/ios/generated/zx_document.swift b/bindings/ios/generated/zx_document.swift new file mode 100644 index 0000000..591732d --- /dev/null +++ b/bindings/ios/generated/zx_document.swift @@ -0,0 +1,1548 @@ +// 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(zx_documentFFI) +import zx_documentFFI +#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) -> RustBuffer { + try! rustCall { ffi_zx_document_ffi_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_zx_document_ffi_rustbuffer_free(self, $0) } + } +} + +fileprivate extension ForeignBytes { + init(bufferPointer: UnsafeBufferPointer) { + 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(_ reader: inout (data: Data, offset: Data.Index)) throws -> T { + let range = reader.offset...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 { + 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(_ 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(_ 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(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(_ callback: (UnsafeMutablePointer) -> T) throws -> T { + let neverThrow: ((RustBuffer) throws -> Never)? = nil + return try makeRustCall(callback, errorHandler: neverThrow) +} + +private func rustCallWithError( + _ errorHandler: @escaping (RustBuffer) throws -> E, + _ callback: (UnsafeMutablePointer) -> T) throws -> T { + try makeRustCall(callback, errorHandler: errorHandler) +} + +private func makeRustCall( + _ callback: (UnsafeMutablePointer) -> T, + errorHandler: ((RustBuffer) throws -> E)? +) throws -> T { + uniffiEnsureZxDocumentFfiInitialized() + var callStatus = RustCallStatus.init() + let returnedVal = callback(&callStatus) + try uniffiCheckCallStatus(callStatus: callStatus, errorHandler: errorHandler) + return returnedVal +} + +private func uniffiCheckCallStatus( + 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( + callStatus: UnsafeMutablePointer, + 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( + callStatus: UnsafeMutablePointer, + 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)) + } +} +// Initial value and increment amount for handles. +// These ensure that SWIFT handles always have the lowest bit set +fileprivate let UNIFFI_HANDLEMAP_INITIAL: UInt64 = 1 +fileprivate let UNIFFI_HANDLEMAP_DELTA: UInt64 = 2 + +fileprivate final class UniffiHandleMap: @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 = UNIFFI_HANDLEMAP_INITIAL + + func insert(obj: T) -> UInt64 { + lock.withLock { + return doInsert(obj) + } + } + + // Low-level insert function, this assumes `lock` is held. + private func doInsert(_ obj: T) -> UInt64 { + let handle = currentHandle + currentHandle += UNIFFI_HANDLEMAP_DELTA + 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 + } + } + + func clone(handle: UInt64) throws -> UInt64 { + try lock.withLock { + guard let obj = map[handle] else { + throw UniffiInternalError.unexpectedStaleHandle + } + return doInsert(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 FfiConverterInt64: FfiConverterPrimitive { + typealias FfiType = Int64 + typealias SwiftType = Int64 + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Int64 { + return try lift(readInt(&buf)) + } + + public static func write(_ value: Int64, into buf: inout [UInt8]) { + writeInt(&buf, lower(value)) + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterFloat: FfiConverterPrimitive { + typealias FfiType = Float + typealias SwiftType = Float + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Float { + return try lift(readFloat(&buf)) + } + + public static func write(_ value: Float, into buf: inout [UInt8]) { + writeFloat(&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(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) + } +} + + +public struct DocumentInfo: Equatable, Hashable { + public var materialId: String + public var title: String + public var materialType: MaterialType + public var previewMode: PreviewMode + public var fileSize: UInt64 + public var pageCount: UInt32? + public var wordCount: UInt32? + public var createdAt: String? + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init(materialId: String, title: String, materialType: MaterialType, previewMode: PreviewMode, fileSize: UInt64, pageCount: UInt32?, wordCount: UInt32?, createdAt: String?) { + self.materialId = materialId + self.title = title + self.materialType = materialType + self.previewMode = previewMode + self.fileSize = fileSize + self.pageCount = pageCount + self.wordCount = wordCount + self.createdAt = createdAt + } + + + + +} + +#if compiler(>=6) +extension DocumentInfo: Sendable {} +#endif + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeDocumentInfo: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> DocumentInfo { + return + try DocumentInfo( + materialId: FfiConverterString.read(from: &buf), + title: FfiConverterString.read(from: &buf), + materialType: FfiConverterTypeMaterialType.read(from: &buf), + previewMode: FfiConverterTypePreviewMode.read(from: &buf), + fileSize: FfiConverterUInt64.read(from: &buf), + pageCount: FfiConverterOptionUInt32.read(from: &buf), + wordCount: FfiConverterOptionUInt32.read(from: &buf), + createdAt: FfiConverterOptionString.read(from: &buf) + ) + } + + public static func write(_ value: DocumentInfo, into buf: inout [UInt8]) { + FfiConverterString.write(value.materialId, into: &buf) + FfiConverterString.write(value.title, into: &buf) + FfiConverterTypeMaterialType.write(value.materialType, into: &buf) + FfiConverterTypePreviewMode.write(value.previewMode, into: &buf) + FfiConverterUInt64.write(value.fileSize, into: &buf) + FfiConverterOptionUInt32.write(value.pageCount, into: &buf) + FfiConverterOptionUInt32.write(value.wordCount, into: &buf) + FfiConverterOptionString.write(value.createdAt, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeDocumentInfo_lift(_ buf: RustBuffer) throws -> DocumentInfo { + return try FfiConverterTypeDocumentInfo.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeDocumentInfo_lower(_ value: DocumentInfo) -> RustBuffer { + return FfiConverterTypeDocumentInfo.lower(value) +} + + +public struct ImageMeta: Equatable, Hashable { + public var width: UInt32 + public var height: UInt32 + public var format: String + public var fileSize: UInt64 + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init(width: UInt32, height: UInt32, format: String, fileSize: UInt64) { + self.width = width + self.height = height + self.format = format + self.fileSize = fileSize + } + + + + +} + +#if compiler(>=6) +extension ImageMeta: Sendable {} +#endif + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeImageMeta: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ImageMeta { + return + try ImageMeta( + width: FfiConverterUInt32.read(from: &buf), + height: FfiConverterUInt32.read(from: &buf), + format: FfiConverterString.read(from: &buf), + fileSize: FfiConverterUInt64.read(from: &buf) + ) + } + + public static func write(_ value: ImageMeta, into buf: inout [UInt8]) { + FfiConverterUInt32.write(value.width, into: &buf) + FfiConverterUInt32.write(value.height, into: &buf) + FfiConverterString.write(value.format, into: &buf) + FfiConverterUInt64.write(value.fileSize, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeImageMeta_lift(_ buf: RustBuffer) throws -> ImageMeta { + return try FfiConverterTypeImageMeta.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeImageMeta_lower(_ value: ImageMeta) -> RustBuffer { + return FfiConverterTypeImageMeta.lower(value) +} + + +public struct SearchResult: Equatable, Hashable { + public var blockId: String + public var lineNumber: UInt32? + public var snippet: String + public var matchStart: UInt64 + public var matchEnd: UInt64 + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init(blockId: String, lineNumber: UInt32?, snippet: String, matchStart: UInt64, matchEnd: UInt64) { + self.blockId = blockId + self.lineNumber = lineNumber + self.snippet = snippet + self.matchStart = matchStart + self.matchEnd = matchEnd + } + + + + +} + +#if compiler(>=6) +extension SearchResult: Sendable {} +#endif + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeSearchResult: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SearchResult { + return + try SearchResult( + blockId: FfiConverterString.read(from: &buf), + lineNumber: FfiConverterOptionUInt32.read(from: &buf), + snippet: FfiConverterString.read(from: &buf), + matchStart: FfiConverterUInt64.read(from: &buf), + matchEnd: FfiConverterUInt64.read(from: &buf) + ) + } + + public static func write(_ value: SearchResult, into buf: inout [UInt8]) { + FfiConverterString.write(value.blockId, into: &buf) + FfiConverterOptionUInt32.write(value.lineNumber, into: &buf) + FfiConverterString.write(value.snippet, into: &buf) + FfiConverterUInt64.write(value.matchStart, into: &buf) + FfiConverterUInt64.write(value.matchEnd, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeSearchResult_lift(_ buf: RustBuffer) throws -> SearchResult { + return try FfiConverterTypeSearchResult.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeSearchResult_lower(_ value: SearchResult) -> RustBuffer { + return FfiConverterTypeSearchResult.lower(value) +} + + +public struct TextStats: Equatable, Hashable { + public var lineCount: UInt32 + public var wordCount: UInt32 + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init(lineCount: UInt32, wordCount: UInt32) { + self.lineCount = lineCount + self.wordCount = wordCount + } + + + + +} + +#if compiler(>=6) +extension TextStats: Sendable {} +#endif + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeTextStats: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> TextStats { + return + try TextStats( + lineCount: FfiConverterUInt32.read(from: &buf), + wordCount: FfiConverterUInt32.read(from: &buf) + ) + } + + public static func write(_ value: TextStats, into buf: inout [UInt8]) { + FfiConverterUInt32.write(value.lineCount, into: &buf) + FfiConverterUInt32.write(value.wordCount, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeTextStats_lift(_ buf: RustBuffer) throws -> TextStats { + return try FfiConverterTypeTextStats.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeTextStats_lower(_ value: TextStats) -> RustBuffer { + return FfiConverterTypeTextStats.lower(value) +} + + +public enum DocumentError: Swift.Error, Equatable, Hashable, Foundation.LocalizedError { + + + + case FileNotFound(message: String) + + case UnsupportedFormat(message: String) + + case ParseError(message: String) + + case InvalidEncoding(message: String) + + case IoError(message: String) + + + + + + + + public var errorDescription: String? { + String(reflecting: self) + } + +} + +#if compiler(>=6) +extension DocumentError: Sendable {} +#endif + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeDocumentError: FfiConverterRustBuffer { + typealias SwiftType = DocumentError + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> DocumentError { + let variant: Int32 = try readInt(&buf) + switch variant { + + + + + case 1: return .FileNotFound( + message: try FfiConverterString.read(from: &buf) + ) + + case 2: return .UnsupportedFormat( + message: try FfiConverterString.read(from: &buf) + ) + + case 3: return .ParseError( + message: try FfiConverterString.read(from: &buf) + ) + + case 4: return .InvalidEncoding( + message: try FfiConverterString.read(from: &buf) + ) + + case 5: return .IoError( + message: try FfiConverterString.read(from: &buf) + ) + + + default: throw UniffiInternalError.unexpectedEnumCase + } + } + + public static func write(_ value: DocumentError, into buf: inout [UInt8]) { + switch value { + + + + + case .FileNotFound(_ /* message is ignored*/): + writeInt(&buf, Int32(1)) + case .UnsupportedFormat(_ /* message is ignored*/): + writeInt(&buf, Int32(2)) + case .ParseError(_ /* message is ignored*/): + writeInt(&buf, Int32(3)) + case .InvalidEncoding(_ /* message is ignored*/): + writeInt(&buf, Int32(4)) + case .IoError(_ /* message is ignored*/): + writeInt(&buf, Int32(5)) + + + } + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeDocumentError_lift(_ buf: RustBuffer) throws -> DocumentError { + return try FfiConverterTypeDocumentError.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeDocumentError_lower(_ value: DocumentError) -> RustBuffer { + return FfiConverterTypeDocumentError.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 MaterialType: Equatable, Hashable { + + case markdown + case text + case pdf + case image + case epub + case word + case excel + case powerPoint + case unknown + + + + + +} + +#if compiler(>=6) +extension MaterialType: Sendable {} +#endif + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeMaterialType: FfiConverterRustBuffer { + typealias SwiftType = MaterialType + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MaterialType { + let variant: Int32 = try readInt(&buf) + switch variant { + + case 1: return .markdown + + case 2: return .text + + case 3: return .pdf + + case 4: return .image + + case 5: return .epub + + case 6: return .word + + case 7: return .excel + + case 8: return .powerPoint + + case 9: return .unknown + + default: throw UniffiInternalError.unexpectedEnumCase + } + } + + public static func write(_ value: MaterialType, into buf: inout [UInt8]) { + switch value { + + + case .markdown: + writeInt(&buf, Int32(1)) + + + case .text: + writeInt(&buf, Int32(2)) + + + case .pdf: + writeInt(&buf, Int32(3)) + + + case .image: + writeInt(&buf, Int32(4)) + + + case .epub: + writeInt(&buf, Int32(5)) + + + case .word: + writeInt(&buf, Int32(6)) + + + case .excel: + writeInt(&buf, Int32(7)) + + + case .powerPoint: + writeInt(&buf, Int32(8)) + + + case .unknown: + writeInt(&buf, Int32(9)) + + } + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMaterialType_lift(_ buf: RustBuffer) throws -> MaterialType { + return try FfiConverterTypeMaterialType.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMaterialType_lower(_ value: MaterialType) -> RustBuffer { + return FfiConverterTypeMaterialType.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 NoteAnchor: Equatable, Hashable { + + case material(materialId: String + ) + case markdownBlock(materialId: String, blockId: String + ) + case textLine(materialId: String, lineNumber: UInt32 + ) + case pdfPage(materialId: String, pageNumber: UInt32 + ) + case image(materialId: String + ) + case epubChapter(materialId: String, chapterId: String + ) + case knowledgeItem(knowledgeItemId: String + ) + + + + + +} + +#if compiler(>=6) +extension NoteAnchor: Sendable {} +#endif + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeNoteAnchor: FfiConverterRustBuffer { + typealias SwiftType = NoteAnchor + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> NoteAnchor { + let variant: Int32 = try readInt(&buf) + switch variant { + + case 1: return .material(materialId: try FfiConverterString.read(from: &buf) + ) + + case 2: return .markdownBlock(materialId: try FfiConverterString.read(from: &buf), blockId: try FfiConverterString.read(from: &buf) + ) + + case 3: return .textLine(materialId: try FfiConverterString.read(from: &buf), lineNumber: try FfiConverterUInt32.read(from: &buf) + ) + + case 4: return .pdfPage(materialId: try FfiConverterString.read(from: &buf), pageNumber: try FfiConverterUInt32.read(from: &buf) + ) + + case 5: return .image(materialId: try FfiConverterString.read(from: &buf) + ) + + case 6: return .epubChapter(materialId: try FfiConverterString.read(from: &buf), chapterId: try FfiConverterString.read(from: &buf) + ) + + case 7: return .knowledgeItem(knowledgeItemId: try FfiConverterString.read(from: &buf) + ) + + default: throw UniffiInternalError.unexpectedEnumCase + } + } + + public static func write(_ value: NoteAnchor, into buf: inout [UInt8]) { + switch value { + + + case let .material(materialId): + writeInt(&buf, Int32(1)) + FfiConverterString.write(materialId, into: &buf) + + + case let .markdownBlock(materialId,blockId): + writeInt(&buf, Int32(2)) + FfiConverterString.write(materialId, into: &buf) + FfiConverterString.write(blockId, into: &buf) + + + case let .textLine(materialId,lineNumber): + writeInt(&buf, Int32(3)) + FfiConverterString.write(materialId, into: &buf) + FfiConverterUInt32.write(lineNumber, into: &buf) + + + case let .pdfPage(materialId,pageNumber): + writeInt(&buf, Int32(4)) + FfiConverterString.write(materialId, into: &buf) + FfiConverterUInt32.write(pageNumber, into: &buf) + + + case let .image(materialId): + writeInt(&buf, Int32(5)) + FfiConverterString.write(materialId, into: &buf) + + + case let .epubChapter(materialId,chapterId): + writeInt(&buf, Int32(6)) + FfiConverterString.write(materialId, into: &buf) + FfiConverterString.write(chapterId, into: &buf) + + + case let .knowledgeItem(knowledgeItemId): + writeInt(&buf, Int32(7)) + FfiConverterString.write(knowledgeItemId, into: &buf) + + } + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeNoteAnchor_lift(_ buf: RustBuffer) throws -> NoteAnchor { + return try FfiConverterTypeNoteAnchor.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeNoteAnchor_lower(_ value: NoteAnchor) -> RustBuffer { + return FfiConverterTypeNoteAnchor.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 PreviewMode: Equatable, Hashable { + + case nativeReader + case platformPreview + case externalOpen + case unsupported + + + + + +} + +#if compiler(>=6) +extension PreviewMode: Sendable {} +#endif + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypePreviewMode: FfiConverterRustBuffer { + typealias SwiftType = PreviewMode + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> PreviewMode { + let variant: Int32 = try readInt(&buf) + switch variant { + + case 1: return .nativeReader + + case 2: return .platformPreview + + case 3: return .externalOpen + + case 4: return .unsupported + + default: throw UniffiInternalError.unexpectedEnumCase + } + } + + public static func write(_ value: PreviewMode, into buf: inout [UInt8]) { + switch value { + + + case .nativeReader: + writeInt(&buf, Int32(1)) + + + case .platformPreview: + writeInt(&buf, Int32(2)) + + + case .externalOpen: + writeInt(&buf, Int32(3)) + + + case .unsupported: + writeInt(&buf, Int32(4)) + + } + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypePreviewMode_lift(_ buf: RustBuffer) throws -> PreviewMode { + return try FfiConverterTypePreviewMode.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypePreviewMode_lower(_ value: PreviewMode) -> RustBuffer { + return FfiConverterTypePreviewMode.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 ReadingEvent: Equatable, Hashable { + + case materialOpened(materialId: String, timestampMs: Int64 + ) + case materialClosed(materialId: String, timestampMs: Int64, activeSeconds: UInt32 + ) + case positionChanged(materialId: String, position: ReadingPosition, timestampMs: Int64 + ) + case heartbeat(materialId: String, activeSeconds: UInt32, position: ReadingPosition?, timestampMs: Int64 + ) + case markedAsRead(materialId: String, timestampMs: Int64 + ) + + + + + +} + +#if compiler(>=6) +extension ReadingEvent: Sendable {} +#endif + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeReadingEvent: FfiConverterRustBuffer { + typealias SwiftType = ReadingEvent + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ReadingEvent { + let variant: Int32 = try readInt(&buf) + switch variant { + + case 1: return .materialOpened(materialId: try FfiConverterString.read(from: &buf), timestampMs: try FfiConverterInt64.read(from: &buf) + ) + + case 2: return .materialClosed(materialId: try FfiConverterString.read(from: &buf), timestampMs: try FfiConverterInt64.read(from: &buf), activeSeconds: try FfiConverterUInt32.read(from: &buf) + ) + + case 3: return .positionChanged(materialId: try FfiConverterString.read(from: &buf), position: try FfiConverterTypeReadingPosition.read(from: &buf), timestampMs: try FfiConverterInt64.read(from: &buf) + ) + + case 4: return .heartbeat(materialId: try FfiConverterString.read(from: &buf), activeSeconds: try FfiConverterUInt32.read(from: &buf), position: try FfiConverterOptionTypeReadingPosition.read(from: &buf), timestampMs: try FfiConverterInt64.read(from: &buf) + ) + + case 5: return .markedAsRead(materialId: try FfiConverterString.read(from: &buf), timestampMs: try FfiConverterInt64.read(from: &buf) + ) + + default: throw UniffiInternalError.unexpectedEnumCase + } + } + + public static func write(_ value: ReadingEvent, into buf: inout [UInt8]) { + switch value { + + + case let .materialOpened(materialId,timestampMs): + writeInt(&buf, Int32(1)) + FfiConverterString.write(materialId, into: &buf) + FfiConverterInt64.write(timestampMs, into: &buf) + + + case let .materialClosed(materialId,timestampMs,activeSeconds): + writeInt(&buf, Int32(2)) + FfiConverterString.write(materialId, into: &buf) + FfiConverterInt64.write(timestampMs, into: &buf) + FfiConverterUInt32.write(activeSeconds, into: &buf) + + + case let .positionChanged(materialId,position,timestampMs): + writeInt(&buf, Int32(3)) + FfiConverterString.write(materialId, into: &buf) + FfiConverterTypeReadingPosition.write(position, into: &buf) + FfiConverterInt64.write(timestampMs, into: &buf) + + + case let .heartbeat(materialId,activeSeconds,position,timestampMs): + writeInt(&buf, Int32(4)) + FfiConverterString.write(materialId, into: &buf) + FfiConverterUInt32.write(activeSeconds, into: &buf) + FfiConverterOptionTypeReadingPosition.write(position, into: &buf) + FfiConverterInt64.write(timestampMs, into: &buf) + + + case let .markedAsRead(materialId,timestampMs): + writeInt(&buf, Int32(5)) + FfiConverterString.write(materialId, into: &buf) + FfiConverterInt64.write(timestampMs, into: &buf) + + } + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeReadingEvent_lift(_ buf: RustBuffer) throws -> ReadingEvent { + return try FfiConverterTypeReadingEvent.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeReadingEvent_lower(_ value: ReadingEvent) -> RustBuffer { + return FfiConverterTypeReadingEvent.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 ReadingPosition: Equatable, Hashable { + + case markdown(blockId: String, scrollProgress: Float + ) + case text(lineNumber: UInt32, scrollProgress: Float + ) + case pdf(pageNumber: UInt32, pageProgress: Float, overallProgress: Float + ) + case image(zoomScale: Float, offsetX: Float, offsetY: Float + ) + case epub(chapterId: String, chapterProgress: Float, overallProgress: Float + ) + case unknown + + + + + +} + +#if compiler(>=6) +extension ReadingPosition: Sendable {} +#endif + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeReadingPosition: FfiConverterRustBuffer { + typealias SwiftType = ReadingPosition + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ReadingPosition { + let variant: Int32 = try readInt(&buf) + switch variant { + + case 1: return .markdown(blockId: try FfiConverterString.read(from: &buf), scrollProgress: try FfiConverterFloat.read(from: &buf) + ) + + case 2: return .text(lineNumber: try FfiConverterUInt32.read(from: &buf), scrollProgress: try FfiConverterFloat.read(from: &buf) + ) + + case 3: return .pdf(pageNumber: try FfiConverterUInt32.read(from: &buf), pageProgress: try FfiConverterFloat.read(from: &buf), overallProgress: try FfiConverterFloat.read(from: &buf) + ) + + case 4: return .image(zoomScale: try FfiConverterFloat.read(from: &buf), offsetX: try FfiConverterFloat.read(from: &buf), offsetY: try FfiConverterFloat.read(from: &buf) + ) + + case 5: return .epub(chapterId: try FfiConverterString.read(from: &buf), chapterProgress: try FfiConverterFloat.read(from: &buf), overallProgress: try FfiConverterFloat.read(from: &buf) + ) + + case 6: return .unknown + + default: throw UniffiInternalError.unexpectedEnumCase + } + } + + public static func write(_ value: ReadingPosition, into buf: inout [UInt8]) { + switch value { + + + case let .markdown(blockId,scrollProgress): + writeInt(&buf, Int32(1)) + FfiConverterString.write(blockId, into: &buf) + FfiConverterFloat.write(scrollProgress, into: &buf) + + + case let .text(lineNumber,scrollProgress): + writeInt(&buf, Int32(2)) + FfiConverterUInt32.write(lineNumber, into: &buf) + FfiConverterFloat.write(scrollProgress, into: &buf) + + + case let .pdf(pageNumber,pageProgress,overallProgress): + writeInt(&buf, Int32(3)) + FfiConverterUInt32.write(pageNumber, into: &buf) + FfiConverterFloat.write(pageProgress, into: &buf) + FfiConverterFloat.write(overallProgress, into: &buf) + + + case let .image(zoomScale,offsetX,offsetY): + writeInt(&buf, Int32(4)) + FfiConverterFloat.write(zoomScale, into: &buf) + FfiConverterFloat.write(offsetX, into: &buf) + FfiConverterFloat.write(offsetY, into: &buf) + + + case let .epub(chapterId,chapterProgress,overallProgress): + writeInt(&buf, Int32(5)) + FfiConverterString.write(chapterId, into: &buf) + FfiConverterFloat.write(chapterProgress, into: &buf) + FfiConverterFloat.write(overallProgress, into: &buf) + + + case .unknown: + writeInt(&buf, Int32(6)) + + } + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeReadingPosition_lift(_ buf: RustBuffer) throws -> ReadingPosition { + return try FfiConverterTypeReadingPosition.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeReadingPosition_lower(_ value: ReadingPosition) -> RustBuffer { + return FfiConverterTypeReadingPosition.lower(value) +} + + +#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 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 FfiConverterOptionTypeReadingPosition: FfiConverterRustBuffer { + typealias SwiftType = ReadingPosition? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeReadingPosition.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 FfiConverterTypeReadingPosition.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +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 = 30 + // Get the scaffolding contract version by calling the into the dylib + let scaffolding_contract_version = ffi_zx_document_ffi_uniffi_contract_version() + if bindings_contract_version != scaffolding_contract_version { + return InitializationResult.contractVersionMismatch + } + + 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 uniffiEnsureZxDocumentFfiInitialized() { + 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 \ No newline at end of file