@npaw/forge-react-native 9.6.1

package/ios/ForgeApple/Sources/ForgeKernelUniFFI/forge_kernel.swift

@@ -0,0 +1,3931 @@
+/**
+ * Copyright (C) NPAW - All Rights Reserved
+ *
+ * This source code is protected under international copyright law. All rights
+ * reserved and protected by the copyright holders.
+ * This file is confidential and only available to authorized individuals with the
+ * permission of the copyright holders. If you encounter this file and do not have
+ * permission, please contact the copyright holders and delete this file.
+ *
+ *
+ * @author: Victor Soto <victor.soto@nicepeopleatwork.com>
+ * @description: Generated Swift UniFFI bridge for the Forge Apple runtime binding.
+ */
+
+// 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(ForgeKernelFFI)
+import ForgeKernelFFI
+#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_forge_kernel_uniffi_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_forge_kernel_uniffi_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 {
+    uniffiEnsureForgeKernelUniffiInitialized()
+    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))
+    }
+}
+// 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<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 = 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.
+// Magic number for the Rust proxy to call using the same mechanism as every other method,
+// to free the callback once it's dropped by Rust.
+private let IDX_CALLBACK_FREE: Int32 = 0
+// Callback return codes
+private let UNIFFI_CALLBACK_SUCCESS: Int32 = 0
+private let UNIFFI_CALLBACK_ERROR: Int32 = 1
+private let UNIFFI_CALLBACK_UNEXPECTED_ERROR: Int32 = 2
+
+#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 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 FfiConverterDouble: FfiConverterPrimitive {
+    typealias FfiType = Double
+    typealias SwiftType = Double
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Double {
+        return try lift(readDouble(&buf))
+    }
+
+    public static func write(_ value: Double, into buf: inout [UInt8]) {
+        writeDouble(&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)
+    }
+}
+
+
+
+
+public protocol ForgeRuntimeBridgeProtocol: AnyObject, Sendable {
+    
+    func capturePlan()  -> AppleCapturePlan?
+    
+    func clearCapturePlanListener()  -> AppleBindingOutcome
+    
+    func clearContentMetadataProvider(viewId: UInt64)  -> AppleBindingOutcome
+    
+    func clearSessionPreSendHook()  -> AppleBindingOutcome
+    
+    func clearVideoPreSendHook(viewId: UInt64)  -> AppleBindingOutcome
+    
+    func createVideoView(nowMs: UInt64, options: AppleVideoOptions)  -> UInt64
+    
+    func destroy()  -> AppleBindingOutcome
+    
+    func recordAdEvent(viewId: UInt64, event: AppleAdEvent, timestamp: AppleSemanticTimestamp, overridesJson: String, metadata: AppleAdMetadata, adapterVersion: String?)  -> AppleBindingOutcome
+    
+    func recordApplicationForeground(foreground: Bool, timemarkMs: UInt64)  -> AppleBindingOutcome
+    
+    func recordIdentityEvent(kind: String, timemarkMs: UInt64, fields: [String: String])  -> AppleBindingOutcome
+    
+    func recordNetworkEvent(observation: AppleNetworkObservation)  -> AppleBindingOutcome
+    
+    func recordPlayerEvent(viewId: UInt64, event: AppleVideoEvent, timestamp: AppleSemanticTimestamp, overridesJson: String, metadata: AppleContentMetadata)  -> AppleBindingOutcome
+    
+    func recordSessionEvent(eventName: String, timemarkMs: UInt64, params: [String: String])  -> AppleBindingOutcome
+    
+    func setCapturePlanListener(listener: AppleCapturePlanListener)  -> AppleBindingOutcome
+    
+    func setContentMetadataProvider(viewId: UInt64, provider: AppleContentMetadataProvider)  -> AppleBindingOutcome
+    
+    func setLogLevel(logLevel: String)  -> AppleBindingOutcome
+    
+    func setSessionPreSendHook(hook: AppleSessionPreSendHook)  -> AppleBindingOutcome
+    
+    func setVideoPreSendHook(viewId: UInt64, hook: AppleVideoPreSendHook)  -> AppleBindingOutcome
+    
+    func snapshotEvents()  -> [AppleRuntimeEventSnapshot]
+    
+    func start(nowMs: UInt64)  -> AppleBindingOutcome
+    
+}
+open class ForgeRuntimeBridge: ForgeRuntimeBridgeProtocol, @unchecked Sendable {
+    fileprivate let handle: UInt64
+
+    /// Used to instantiate a [FFIObject] without an actual handle, for fakes in tests, mostly.
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+    public struct NoHandle {
+        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(unsafeFromHandle handle: UInt64) {
+        self.handle = handle
+    }
+
+    // This constructor can be used to instantiate a fake object.
+    // - Parameter noHandle: 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 handle the FFI lower functions will crash.
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+    public init(noHandle: NoHandle) {
+        self.handle = 0
+    }
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+    public func uniffiCloneHandle() -> UInt64 {
+        return try! rustCall { uniffi_forge_kernel_uniffi_fn_clone_forgeruntimebridge(self.handle, $0) }
+    }
+public convenience init(config: AppleRuntimeConfig) {
+    let handle =
+        try! rustCall() {
+    uniffi_forge_kernel_uniffi_fn_constructor_forgeruntimebridge_new(
+        FfiConverterTypeAppleRuntimeConfig_lower(config),$0
+    )
+}
+    self.init(unsafeFromHandle: handle)
+}
+
+    deinit {
+        if handle == 0 {
+            // Mock objects have handle=0 don't try to free them
+            return
+        }
+
+        try! rustCall { uniffi_forge_kernel_uniffi_fn_free_forgeruntimebridge(handle, $0) }
+    }
+
+    
+
+    
+open func capturePlan() -> AppleCapturePlan?  {
+    return try!  FfiConverterOptionTypeAppleCapturePlan.lift(try! rustCall() {
+    uniffi_forge_kernel_uniffi_fn_method_forgeruntimebridge_capture_plan(
+            self.uniffiCloneHandle(),$0
+    )
+})
+}
+    
+open func clearCapturePlanListener() -> AppleBindingOutcome  {
+    return try!  FfiConverterTypeAppleBindingOutcome_lift(try! rustCall() {
+    uniffi_forge_kernel_uniffi_fn_method_forgeruntimebridge_clear_capture_plan_listener(
+            self.uniffiCloneHandle(),$0
+    )
+})
+}
+    
+open func clearContentMetadataProvider(viewId: UInt64) -> AppleBindingOutcome  {
+    return try!  FfiConverterTypeAppleBindingOutcome_lift(try! rustCall() {
+    uniffi_forge_kernel_uniffi_fn_method_forgeruntimebridge_clear_content_metadata_provider(
+            self.uniffiCloneHandle(),
+        FfiConverterUInt64.lower(viewId),$0
+    )
+})
+}
+    
+open func clearSessionPreSendHook() -> AppleBindingOutcome  {
+    return try!  FfiConverterTypeAppleBindingOutcome_lift(try! rustCall() {
+    uniffi_forge_kernel_uniffi_fn_method_forgeruntimebridge_clear_session_pre_send_hook(
+            self.uniffiCloneHandle(),$0
+    )
+})
+}
+    
+open func clearVideoPreSendHook(viewId: UInt64) -> AppleBindingOutcome  {
+    return try!  FfiConverterTypeAppleBindingOutcome_lift(try! rustCall() {
+    uniffi_forge_kernel_uniffi_fn_method_forgeruntimebridge_clear_video_pre_send_hook(
+            self.uniffiCloneHandle(),
+        FfiConverterUInt64.lower(viewId),$0
+    )
+})
+}
+    
+open func createVideoView(nowMs: UInt64, options: AppleVideoOptions) -> UInt64  {
+    return try!  FfiConverterUInt64.lift(try! rustCall() {
+    uniffi_forge_kernel_uniffi_fn_method_forgeruntimebridge_create_video_view(
+            self.uniffiCloneHandle(),
+        FfiConverterUInt64.lower(nowMs),
+        FfiConverterTypeAppleVideoOptions_lower(options),$0
+    )
+})
+}
+    
+open func destroy() -> AppleBindingOutcome  {
+    return try!  FfiConverterTypeAppleBindingOutcome_lift(try! rustCall() {
+    uniffi_forge_kernel_uniffi_fn_method_forgeruntimebridge_destroy(
+            self.uniffiCloneHandle(),$0
+    )
+})
+}
+    
+open func recordAdEvent(viewId: UInt64, event: AppleAdEvent, timestamp: AppleSemanticTimestamp, overridesJson: String, metadata: AppleAdMetadata, adapterVersion: String?) -> AppleBindingOutcome  {
+    return try!  FfiConverterTypeAppleBindingOutcome_lift(try! rustCall() {
+    uniffi_forge_kernel_uniffi_fn_method_forgeruntimebridge_record_ad_event(
+            self.uniffiCloneHandle(),
+        FfiConverterUInt64.lower(viewId),
+        FfiConverterTypeAppleAdEvent_lower(event),
+        FfiConverterTypeAppleSemanticTimestamp_lower(timestamp),
+        FfiConverterString.lower(overridesJson),
+        FfiConverterTypeAppleAdMetadata_lower(metadata),
+        FfiConverterOptionString.lower(adapterVersion),$0
+    )
+})
+}
+    
+open func recordApplicationForeground(foreground: Bool, timemarkMs: UInt64) -> AppleBindingOutcome  {
+    return try!  FfiConverterTypeAppleBindingOutcome_lift(try! rustCall() {
+    uniffi_forge_kernel_uniffi_fn_method_forgeruntimebridge_record_application_foreground(
+            self.uniffiCloneHandle(),
+        FfiConverterBool.lower(foreground),
+        FfiConverterUInt64.lower(timemarkMs),$0
+    )
+})
+}
+    
+open func recordIdentityEvent(kind: String, timemarkMs: UInt64, fields: [String: String]) -> AppleBindingOutcome  {
+    return try!  FfiConverterTypeAppleBindingOutcome_lift(try! rustCall() {
+    uniffi_forge_kernel_uniffi_fn_method_forgeruntimebridge_record_identity_event(
+            self.uniffiCloneHandle(),
+        FfiConverterString.lower(kind),
+        FfiConverterUInt64.lower(timemarkMs),
+        FfiConverterDictionaryStringString.lower(fields),$0
+    )
+})
+}
+    
+open func recordNetworkEvent(observation: AppleNetworkObservation) -> AppleBindingOutcome  {
+    return try!  FfiConverterTypeAppleBindingOutcome_lift(try! rustCall() {
+    uniffi_forge_kernel_uniffi_fn_method_forgeruntimebridge_record_network_event(
+            self.uniffiCloneHandle(),
+        FfiConverterTypeAppleNetworkObservation_lower(observation),$0
+    )
+})
+}
+    
+open func recordPlayerEvent(viewId: UInt64, event: AppleVideoEvent, timestamp: AppleSemanticTimestamp, overridesJson: String, metadata: AppleContentMetadata) -> AppleBindingOutcome  {
+    return try!  FfiConverterTypeAppleBindingOutcome_lift(try! rustCall() {
+    uniffi_forge_kernel_uniffi_fn_method_forgeruntimebridge_record_player_event(
+            self.uniffiCloneHandle(),
+        FfiConverterUInt64.lower(viewId),
+        FfiConverterTypeAppleVideoEvent_lower(event),
+        FfiConverterTypeAppleSemanticTimestamp_lower(timestamp),
+        FfiConverterString.lower(overridesJson),
+        FfiConverterTypeAppleContentMetadata_lower(metadata),$0
+    )
+})
+}
+    
+open func recordSessionEvent(eventName: String, timemarkMs: UInt64, params: [String: String]) -> AppleBindingOutcome  {
+    return try!  FfiConverterTypeAppleBindingOutcome_lift(try! rustCall() {
+    uniffi_forge_kernel_uniffi_fn_method_forgeruntimebridge_record_session_event(
+            self.uniffiCloneHandle(),
+        FfiConverterString.lower(eventName),
+        FfiConverterUInt64.lower(timemarkMs),
+        FfiConverterDictionaryStringString.lower(params),$0
+    )
+})
+}
+    
+open func setCapturePlanListener(listener: AppleCapturePlanListener) -> AppleBindingOutcome  {
+    return try!  FfiConverterTypeAppleBindingOutcome_lift(try! rustCall() {
+    uniffi_forge_kernel_uniffi_fn_method_forgeruntimebridge_set_capture_plan_listener(
+            self.uniffiCloneHandle(),
+        FfiConverterCallbackInterfaceAppleCapturePlanListener_lower(listener),$0
+    )
+})
+}
+    
+open func setContentMetadataProvider(viewId: UInt64, provider: AppleContentMetadataProvider) -> AppleBindingOutcome  {
+    return try!  FfiConverterTypeAppleBindingOutcome_lift(try! rustCall() {
+    uniffi_forge_kernel_uniffi_fn_method_forgeruntimebridge_set_content_metadata_provider(
+            self.uniffiCloneHandle(),
+        FfiConverterUInt64.lower(viewId),
+        FfiConverterCallbackInterfaceAppleContentMetadataProvider_lower(provider),$0
+    )
+})
+}
+    
+open func setLogLevel(logLevel: String) -> AppleBindingOutcome  {
+    return try!  FfiConverterTypeAppleBindingOutcome_lift(try! rustCall() {
+    uniffi_forge_kernel_uniffi_fn_method_forgeruntimebridge_set_log_level(
+            self.uniffiCloneHandle(),
+        FfiConverterString.lower(logLevel),$0
+    )
+})
+}
+    
+open func setSessionPreSendHook(hook: AppleSessionPreSendHook) -> AppleBindingOutcome  {
+    return try!  FfiConverterTypeAppleBindingOutcome_lift(try! rustCall() {
+    uniffi_forge_kernel_uniffi_fn_method_forgeruntimebridge_set_session_pre_send_hook(
+            self.uniffiCloneHandle(),
+        FfiConverterCallbackInterfaceAppleSessionPreSendHook_lower(hook),$0
+    )
+})
+}
+    
+open func setVideoPreSendHook(viewId: UInt64, hook: AppleVideoPreSendHook) -> AppleBindingOutcome  {
+    return try!  FfiConverterTypeAppleBindingOutcome_lift(try! rustCall() {
+    uniffi_forge_kernel_uniffi_fn_method_forgeruntimebridge_set_video_pre_send_hook(
+            self.uniffiCloneHandle(),
+        FfiConverterUInt64.lower(viewId),
+        FfiConverterCallbackInterfaceAppleVideoPreSendHook_lower(hook),$0
+    )
+})
+}
+    
+open func snapshotEvents() -> [AppleRuntimeEventSnapshot]  {
+    return try!  FfiConverterSequenceTypeAppleRuntimeEventSnapshot.lift(try! rustCall() {
+    uniffi_forge_kernel_uniffi_fn_method_forgeruntimebridge_snapshot_events(
+            self.uniffiCloneHandle(),$0
+    )
+})
+}
+    
+open func start(nowMs: UInt64) -> AppleBindingOutcome  {
+    return try!  FfiConverterTypeAppleBindingOutcome_lift(try! rustCall() {
+    uniffi_forge_kernel_uniffi_fn_method_forgeruntimebridge_start(
+            self.uniffiCloneHandle(),
+        FfiConverterUInt64.lower(nowMs),$0
+    )
+})
+}
+    
+
+    
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeForgeRuntimeBridge: FfiConverter {
+    typealias FfiType = UInt64
+    typealias SwiftType = ForgeRuntimeBridge
+
+    public static func lift(_ handle: UInt64) throws -> ForgeRuntimeBridge {
+        return ForgeRuntimeBridge(unsafeFromHandle: handle)
+    }
+
+    public static func lower(_ value: ForgeRuntimeBridge) -> UInt64 {
+        return value.uniffiCloneHandle()
+    }
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ForgeRuntimeBridge {
+        let handle: UInt64 = try readInt(&buf)
+        return try lift(handle)
+    }
+
+    public static func write(_ value: ForgeRuntimeBridge, into buf: inout [UInt8]) {
+        writeInt(&buf, lower(value))
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeForgeRuntimeBridge_lift(_ handle: UInt64) throws -> ForgeRuntimeBridge {
+    return try FfiConverterTypeForgeRuntimeBridge.lift(handle)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeForgeRuntimeBridge_lower(_ value: ForgeRuntimeBridge) -> UInt64 {
+    return FfiConverterTypeForgeRuntimeBridge.lower(value)
+}
+
+
+
+
+public struct AppleAdMetadata: Equatable, Hashable {
+    public var creativeId: String?
+    public var adUrl: String?
+    public var adTitle: String?
+    public var adDurationMs: UInt64?
+    public var adPlayheadMs: UInt64?
+    public var adBitrate: Int64?
+    public var position: AppleAdPosition?
+    public var skippable: Bool?
+    public var quartile: UInt32?
+    public var insertionType: AppleAdInsertionType
+    public var viewability: AppleAdViewabilitySample?
+    public var errorCode: String?
+    public var errorMessage: String?
+    public var errorMetadata: String?
+    public var errorLevel: String?
+    public var extraParams: [String: String]?
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(creativeId: String?, adUrl: String?, adTitle: String?, adDurationMs: UInt64?, adPlayheadMs: UInt64?, adBitrate: Int64?, position: AppleAdPosition?, skippable: Bool?, quartile: UInt32?, insertionType: AppleAdInsertionType, viewability: AppleAdViewabilitySample?, errorCode: String?, errorMessage: String?, errorMetadata: String?, errorLevel: String?, extraParams: [String: String]?) {
+        self.creativeId = creativeId
+        self.adUrl = adUrl
+        self.adTitle = adTitle
+        self.adDurationMs = adDurationMs
+        self.adPlayheadMs = adPlayheadMs
+        self.adBitrate = adBitrate
+        self.position = position
+        self.skippable = skippable
+        self.quartile = quartile
+        self.insertionType = insertionType
+        self.viewability = viewability
+        self.errorCode = errorCode
+        self.errorMessage = errorMessage
+        self.errorMetadata = errorMetadata
+        self.errorLevel = errorLevel
+        self.extraParams = extraParams
+    }
+
+    
+
+    
+}
+
+#if compiler(>=6)
+extension AppleAdMetadata: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeAppleAdMetadata: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AppleAdMetadata {
+        return
+            try AppleAdMetadata(
+                creativeId: FfiConverterOptionString.read(from: &buf), 
+                adUrl: FfiConverterOptionString.read(from: &buf), 
+                adTitle: FfiConverterOptionString.read(from: &buf), 
+                adDurationMs: FfiConverterOptionUInt64.read(from: &buf), 
+                adPlayheadMs: FfiConverterOptionUInt64.read(from: &buf), 
+                adBitrate: FfiConverterOptionInt64.read(from: &buf), 
+                position: FfiConverterOptionTypeAppleAdPosition.read(from: &buf), 
+                skippable: FfiConverterOptionBool.read(from: &buf), 
+                quartile: FfiConverterOptionUInt32.read(from: &buf), 
+                insertionType: FfiConverterTypeAppleAdInsertionType.read(from: &buf), 
+                viewability: FfiConverterOptionTypeAppleAdViewabilitySample.read(from: &buf), 
+                errorCode: FfiConverterOptionString.read(from: &buf), 
+                errorMessage: FfiConverterOptionString.read(from: &buf), 
+                errorMetadata: FfiConverterOptionString.read(from: &buf), 
+                errorLevel: FfiConverterOptionString.read(from: &buf), 
+                extraParams: FfiConverterOptionDictionaryStringString.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: AppleAdMetadata, into buf: inout [UInt8]) {
+        FfiConverterOptionString.write(value.creativeId, into: &buf)
+        FfiConverterOptionString.write(value.adUrl, into: &buf)
+        FfiConverterOptionString.write(value.adTitle, into: &buf)
+        FfiConverterOptionUInt64.write(value.adDurationMs, into: &buf)
+        FfiConverterOptionUInt64.write(value.adPlayheadMs, into: &buf)
+        FfiConverterOptionInt64.write(value.adBitrate, into: &buf)
+        FfiConverterOptionTypeAppleAdPosition.write(value.position, into: &buf)
+        FfiConverterOptionBool.write(value.skippable, into: &buf)
+        FfiConverterOptionUInt32.write(value.quartile, into: &buf)
+        FfiConverterTypeAppleAdInsertionType.write(value.insertionType, into: &buf)
+        FfiConverterOptionTypeAppleAdViewabilitySample.write(value.viewability, into: &buf)
+        FfiConverterOptionString.write(value.errorCode, into: &buf)
+        FfiConverterOptionString.write(value.errorMessage, into: &buf)
+        FfiConverterOptionString.write(value.errorMetadata, into: &buf)
+        FfiConverterOptionString.write(value.errorLevel, into: &buf)
+        FfiConverterOptionDictionaryStringString.write(value.extraParams, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeAppleAdMetadata_lift(_ buf: RustBuffer) throws -> AppleAdMetadata {
+    return try FfiConverterTypeAppleAdMetadata.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeAppleAdMetadata_lower(_ value: AppleAdMetadata) -> RustBuffer {
+    return FfiConverterTypeAppleAdMetadata.lower(value)
+}
+
+
+public struct AppleAdViewabilitySample: Equatable, Hashable {
+    public var maxIntervalMs: Int64?
+    public var viewedDurationMs: UInt64?
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(maxIntervalMs: Int64?, viewedDurationMs: UInt64?) {
+        self.maxIntervalMs = maxIntervalMs
+        self.viewedDurationMs = viewedDurationMs
+    }
+
+    
+
+    
+}
+
+#if compiler(>=6)
+extension AppleAdViewabilitySample: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeAppleAdViewabilitySample: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AppleAdViewabilitySample {
+        return
+            try AppleAdViewabilitySample(
+                maxIntervalMs: FfiConverterOptionInt64.read(from: &buf), 
+                viewedDurationMs: FfiConverterOptionUInt64.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: AppleAdViewabilitySample, into buf: inout [UInt8]) {
+        FfiConverterOptionInt64.write(value.maxIntervalMs, into: &buf)
+        FfiConverterOptionUInt64.write(value.viewedDurationMs, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeAppleAdViewabilitySample_lift(_ buf: RustBuffer) throws -> AppleAdViewabilitySample {
+    return try FfiConverterTypeAppleAdViewabilitySample.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeAppleAdViewabilitySample_lower(_ value: AppleAdViewabilitySample) -> RustBuffer {
+    return FfiConverterTypeAppleAdViewabilitySample.lower(value)
+}
+
+
+public struct AppleBindingOutcome: Equatable, Hashable {
+    public var status: AppleBindingStatus
+    public var reason: String?
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(status: AppleBindingStatus, reason: String?) {
+        self.status = status
+        self.reason = reason
+    }
+
+    
+
+    
+}
+
+#if compiler(>=6)
+extension AppleBindingOutcome: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeAppleBindingOutcome: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AppleBindingOutcome {
+        return
+            try AppleBindingOutcome(
+                status: FfiConverterTypeAppleBindingStatus.read(from: &buf), 
+                reason: FfiConverterOptionString.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: AppleBindingOutcome, into buf: inout [UInt8]) {
+        FfiConverterTypeAppleBindingStatus.write(value.status, into: &buf)
+        FfiConverterOptionString.write(value.reason, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeAppleBindingOutcome_lift(_ buf: RustBuffer) throws -> AppleBindingOutcome {
+    return try FfiConverterTypeAppleBindingOutcome.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeAppleBindingOutcome_lower(_ value: AppleBindingOutcome) -> RustBuffer {
+    return FfiConverterTypeAppleBindingOutcome.lower(value)
+}
+
+
+public struct AppleCapturePlan: Equatable, Hashable {
+    public var planSeq: UInt64
+    public var bits: UInt32
+    public var configVersion: String?
+    public var focusDwellThresholdMs: UInt64
+    public var focusDedupeMs: UInt64
+    public var focusRepeatUnchangedDwell: Bool
+    public var maxTargetTextLength: UInt32
+    public var maxPayloadFields: UInt32
+    public var joinMethod: String?
+    public var seekHeuristicEnabled: Bool?
+    public var seekJumpThresholdMs: UInt64?
+    public var metadataSamplingMs: UInt64?
+    public var sectionsVisibilityThresholdPct: UInt32
+    public var sectionsImpressionMinVisibleMs: UInt64
+    public var sectionsDwellMs: UInt64
+    public var sectionsMaxTrackedItems: UInt32
+    public var sectionsMaxSections: UInt32
+    public var sectionsSectionSelector: String?
+    public var sectionsItemSelector: String?
+    public var sectionsSectionNativeIds: [String]
+    public var sectionsItemNativeIds: [String]
+    public var sectionsNameFrom: String
+    public var targetDataAttributes: [String]
+    public var attributionExtraQueryKeys: [String]
+    public var attributionIncludeLandingUrl: Bool
+    public var attributionDeriveFromDeepLinks: Bool
+    public var attributionInstallReferrerEnabled: Bool
+    public var hash: String
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(planSeq: UInt64, bits: UInt32, configVersion: String?, focusDwellThresholdMs: UInt64, focusDedupeMs: UInt64, focusRepeatUnchangedDwell: Bool, maxTargetTextLength: UInt32, maxPayloadFields: UInt32, joinMethod: String?, seekHeuristicEnabled: Bool?, seekJumpThresholdMs: UInt64?, metadataSamplingMs: UInt64?, sectionsVisibilityThresholdPct: UInt32, sectionsImpressionMinVisibleMs: UInt64, sectionsDwellMs: UInt64, sectionsMaxTrackedItems: UInt32, sectionsMaxSections: UInt32, sectionsSectionSelector: String?, sectionsItemSelector: String?, sectionsSectionNativeIds: [String], sectionsItemNativeIds: [String], sectionsNameFrom: String, targetDataAttributes: [String], attributionExtraQueryKeys: [String], attributionIncludeLandingUrl: Bool, attributionDeriveFromDeepLinks: Bool, attributionInstallReferrerEnabled: Bool, hash: String) {
+        self.planSeq = planSeq
+        self.bits = bits
+        self.configVersion = configVersion
+        self.focusDwellThresholdMs = focusDwellThresholdMs
+        self.focusDedupeMs = focusDedupeMs
+        self.focusRepeatUnchangedDwell = focusRepeatUnchangedDwell
+        self.maxTargetTextLength = maxTargetTextLength
+        self.maxPayloadFields = maxPayloadFields
+        self.joinMethod = joinMethod
+        self.seekHeuristicEnabled = seekHeuristicEnabled
+        self.seekJumpThresholdMs = seekJumpThresholdMs
+        self.metadataSamplingMs = metadataSamplingMs
+        self.sectionsVisibilityThresholdPct = sectionsVisibilityThresholdPct
+        self.sectionsImpressionMinVisibleMs = sectionsImpressionMinVisibleMs
+        self.sectionsDwellMs = sectionsDwellMs
+        self.sectionsMaxTrackedItems = sectionsMaxTrackedItems
+        self.sectionsMaxSections = sectionsMaxSections
+        self.sectionsSectionSelector = sectionsSectionSelector
+        self.sectionsItemSelector = sectionsItemSelector
+        self.sectionsSectionNativeIds = sectionsSectionNativeIds
+        self.sectionsItemNativeIds = sectionsItemNativeIds
+        self.sectionsNameFrom = sectionsNameFrom
+        self.targetDataAttributes = targetDataAttributes
+        self.attributionExtraQueryKeys = attributionExtraQueryKeys
+        self.attributionIncludeLandingUrl = attributionIncludeLandingUrl
+        self.attributionDeriveFromDeepLinks = attributionDeriveFromDeepLinks
+        self.attributionInstallReferrerEnabled = attributionInstallReferrerEnabled
+        self.hash = hash
+    }
+
+    
+
+    
+}
+
+#if compiler(>=6)
+extension AppleCapturePlan: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeAppleCapturePlan: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AppleCapturePlan {
+        return
+            try AppleCapturePlan(
+                planSeq: FfiConverterUInt64.read(from: &buf), 
+                bits: FfiConverterUInt32.read(from: &buf), 
+                configVersion: FfiConverterOptionString.read(from: &buf), 
+                focusDwellThresholdMs: FfiConverterUInt64.read(from: &buf), 
+                focusDedupeMs: FfiConverterUInt64.read(from: &buf), 
+                focusRepeatUnchangedDwell: FfiConverterBool.read(from: &buf), 
+                maxTargetTextLength: FfiConverterUInt32.read(from: &buf), 
+                maxPayloadFields: FfiConverterUInt32.read(from: &buf), 
+                joinMethod: FfiConverterOptionString.read(from: &buf), 
+                seekHeuristicEnabled: FfiConverterOptionBool.read(from: &buf), 
+                seekJumpThresholdMs: FfiConverterOptionUInt64.read(from: &buf), 
+                metadataSamplingMs: FfiConverterOptionUInt64.read(from: &buf), 
+                sectionsVisibilityThresholdPct: FfiConverterUInt32.read(from: &buf), 
+                sectionsImpressionMinVisibleMs: FfiConverterUInt64.read(from: &buf), 
+                sectionsDwellMs: FfiConverterUInt64.read(from: &buf), 
+                sectionsMaxTrackedItems: FfiConverterUInt32.read(from: &buf), 
+                sectionsMaxSections: FfiConverterUInt32.read(from: &buf), 
+                sectionsSectionSelector: FfiConverterOptionString.read(from: &buf), 
+                sectionsItemSelector: FfiConverterOptionString.read(from: &buf), 
+                sectionsSectionNativeIds: FfiConverterSequenceString.read(from: &buf), 
+                sectionsItemNativeIds: FfiConverterSequenceString.read(from: &buf), 
+                sectionsNameFrom: FfiConverterString.read(from: &buf), 
+                targetDataAttributes: FfiConverterSequenceString.read(from: &buf), 
+                attributionExtraQueryKeys: FfiConverterSequenceString.read(from: &buf), 
+                attributionIncludeLandingUrl: FfiConverterBool.read(from: &buf), 
+                attributionDeriveFromDeepLinks: FfiConverterBool.read(from: &buf), 
+                attributionInstallReferrerEnabled: FfiConverterBool.read(from: &buf), 
+                hash: FfiConverterString.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: AppleCapturePlan, into buf: inout [UInt8]) {
+        FfiConverterUInt64.write(value.planSeq, into: &buf)
+        FfiConverterUInt32.write(value.bits, into: &buf)
+        FfiConverterOptionString.write(value.configVersion, into: &buf)
+        FfiConverterUInt64.write(value.focusDwellThresholdMs, into: &buf)
+        FfiConverterUInt64.write(value.focusDedupeMs, into: &buf)
+        FfiConverterBool.write(value.focusRepeatUnchangedDwell, into: &buf)
+        FfiConverterUInt32.write(value.maxTargetTextLength, into: &buf)
+        FfiConverterUInt32.write(value.maxPayloadFields, into: &buf)
+        FfiConverterOptionString.write(value.joinMethod, into: &buf)
+        FfiConverterOptionBool.write(value.seekHeuristicEnabled, into: &buf)
+        FfiConverterOptionUInt64.write(value.seekJumpThresholdMs, into: &buf)
+        FfiConverterOptionUInt64.write(value.metadataSamplingMs, into: &buf)
+        FfiConverterUInt32.write(value.sectionsVisibilityThresholdPct, into: &buf)
+        FfiConverterUInt64.write(value.sectionsImpressionMinVisibleMs, into: &buf)
+        FfiConverterUInt64.write(value.sectionsDwellMs, into: &buf)
+        FfiConverterUInt32.write(value.sectionsMaxTrackedItems, into: &buf)
+        FfiConverterUInt32.write(value.sectionsMaxSections, into: &buf)
+        FfiConverterOptionString.write(value.sectionsSectionSelector, into: &buf)
+        FfiConverterOptionString.write(value.sectionsItemSelector, into: &buf)
+        FfiConverterSequenceString.write(value.sectionsSectionNativeIds, into: &buf)
+        FfiConverterSequenceString.write(value.sectionsItemNativeIds, into: &buf)
+        FfiConverterString.write(value.sectionsNameFrom, into: &buf)
+        FfiConverterSequenceString.write(value.targetDataAttributes, into: &buf)
+        FfiConverterSequenceString.write(value.attributionExtraQueryKeys, into: &buf)
+        FfiConverterBool.write(value.attributionIncludeLandingUrl, into: &buf)
+        FfiConverterBool.write(value.attributionDeriveFromDeepLinks, into: &buf)
+        FfiConverterBool.write(value.attributionInstallReferrerEnabled, into: &buf)
+        FfiConverterString.write(value.hash, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeAppleCapturePlan_lift(_ buf: RustBuffer) throws -> AppleCapturePlan {
+    return try FfiConverterTypeAppleCapturePlan.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeAppleCapturePlan_lower(_ value: AppleCapturePlan) -> RustBuffer {
+    return FfiConverterTypeAppleCapturePlan.lower(value)
+}
+
+
+public struct AppleContentMetadata: Equatable, Hashable {
+    public var player: String
+    public var playerVersion: String?
+    public var resource: String?
+    public var parsedResource: String?
+    public var title: String?
+    public var program: String?
+    public var transactionCode: String?
+    public var contentId: String?
+    public var contentType: AppleContentType
+    public var playheadMs: UInt64?
+    public var durationMs: UInt64?
+    public var bitrate: Int64?
+    public var throughput: Double?
+    public var totalBytes: Int64?
+    public var droppedFrames: UInt64?
+    public var rendition: String?
+    public var videoCodec: String?
+    public var audioCodec: String?
+    public var codecProfile: String?
+    public var containerFormat: String?
+    public var legacyCustomDimensions: [String: String]?
+    public var customDimensions: [String: String]?
+    public var customMetrics: [String: Double]?
+    public var errorCode: String?
+    public var errorMessage: String?
+    public var errorMetadata: String?
+    public var errorLevel: String?
+    public var forceInit: Bool?
+    public var convertFromBuffer: Bool?
+    public var convertFromSeek: Bool?
+    public var customEventJson: String?
+    public var extraParams: [String: String]?
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(player: String, playerVersion: String?, resource: String?, parsedResource: String?, title: String?, program: String?, transactionCode: String?, contentId: String?, contentType: AppleContentType, playheadMs: UInt64?, durationMs: UInt64?, bitrate: Int64?, throughput: Double?, totalBytes: Int64?, droppedFrames: UInt64?, rendition: String?, videoCodec: String?, audioCodec: String?, codecProfile: String?, containerFormat: String?, legacyCustomDimensions: [String: String]?, customDimensions: [String: String]?, customMetrics: [String: Double]?, errorCode: String?, errorMessage: String?, errorMetadata: String?, errorLevel: String?, forceInit: Bool?, convertFromBuffer: Bool?, convertFromSeek: Bool?, customEventJson: String?, extraParams: [String: String]?) {
+        self.player = player
+        self.playerVersion = playerVersion
+        self.resource = resource
+        self.parsedResource = parsedResource
+        self.title = title
+        self.program = program
+        self.transactionCode = transactionCode
+        self.contentId = contentId
+        self.contentType = contentType
+        self.playheadMs = playheadMs
+        self.durationMs = durationMs
+        self.bitrate = bitrate
+        self.throughput = throughput
+        self.totalBytes = totalBytes
+        self.droppedFrames = droppedFrames
+        self.rendition = rendition
+        self.videoCodec = videoCodec
+        self.audioCodec = audioCodec
+        self.codecProfile = codecProfile
+        self.containerFormat = containerFormat
+        self.legacyCustomDimensions = legacyCustomDimensions
+        self.customDimensions = customDimensions
+        self.customMetrics = customMetrics
+        self.errorCode = errorCode
+        self.errorMessage = errorMessage
+        self.errorMetadata = errorMetadata
+        self.errorLevel = errorLevel
+        self.forceInit = forceInit
+        self.convertFromBuffer = convertFromBuffer
+        self.convertFromSeek = convertFromSeek
+        self.customEventJson = customEventJson
+        self.extraParams = extraParams
+    }
+
+    
+
+    
+}
+
+#if compiler(>=6)
+extension AppleContentMetadata: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeAppleContentMetadata: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AppleContentMetadata {
+        return
+            try AppleContentMetadata(
+                player: FfiConverterString.read(from: &buf), 
+                playerVersion: FfiConverterOptionString.read(from: &buf), 
+                resource: FfiConverterOptionString.read(from: &buf), 
+                parsedResource: FfiConverterOptionString.read(from: &buf), 
+                title: FfiConverterOptionString.read(from: &buf), 
+                program: FfiConverterOptionString.read(from: &buf), 
+                transactionCode: FfiConverterOptionString.read(from: &buf), 
+                contentId: FfiConverterOptionString.read(from: &buf), 
+                contentType: FfiConverterTypeAppleContentType.read(from: &buf), 
+                playheadMs: FfiConverterOptionUInt64.read(from: &buf), 
+                durationMs: FfiConverterOptionUInt64.read(from: &buf), 
+                bitrate: FfiConverterOptionInt64.read(from: &buf), 
+                throughput: FfiConverterOptionDouble.read(from: &buf), 
+                totalBytes: FfiConverterOptionInt64.read(from: &buf), 
+                droppedFrames: FfiConverterOptionUInt64.read(from: &buf), 
+                rendition: FfiConverterOptionString.read(from: &buf), 
+                videoCodec: FfiConverterOptionString.read(from: &buf), 
+                audioCodec: FfiConverterOptionString.read(from: &buf), 
+                codecProfile: FfiConverterOptionString.read(from: &buf), 
+                containerFormat: FfiConverterOptionString.read(from: &buf), 
+                legacyCustomDimensions: FfiConverterOptionDictionaryStringString.read(from: &buf), 
+                customDimensions: FfiConverterOptionDictionaryStringString.read(from: &buf), 
+                customMetrics: FfiConverterOptionDictionaryStringDouble.read(from: &buf), 
+                errorCode: FfiConverterOptionString.read(from: &buf), 
+                errorMessage: FfiConverterOptionString.read(from: &buf), 
+                errorMetadata: FfiConverterOptionString.read(from: &buf), 
+                errorLevel: FfiConverterOptionString.read(from: &buf), 
+                forceInit: FfiConverterOptionBool.read(from: &buf), 
+                convertFromBuffer: FfiConverterOptionBool.read(from: &buf), 
+                convertFromSeek: FfiConverterOptionBool.read(from: &buf), 
+                customEventJson: FfiConverterOptionString.read(from: &buf), 
+                extraParams: FfiConverterOptionDictionaryStringString.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: AppleContentMetadata, into buf: inout [UInt8]) {
+        FfiConverterString.write(value.player, into: &buf)
+        FfiConverterOptionString.write(value.playerVersion, into: &buf)
+        FfiConverterOptionString.write(value.resource, into: &buf)
+        FfiConverterOptionString.write(value.parsedResource, into: &buf)
+        FfiConverterOptionString.write(value.title, into: &buf)
+        FfiConverterOptionString.write(value.program, into: &buf)
+        FfiConverterOptionString.write(value.transactionCode, into: &buf)
+        FfiConverterOptionString.write(value.contentId, into: &buf)
+        FfiConverterTypeAppleContentType.write(value.contentType, into: &buf)
+        FfiConverterOptionUInt64.write(value.playheadMs, into: &buf)
+        FfiConverterOptionUInt64.write(value.durationMs, into: &buf)
+        FfiConverterOptionInt64.write(value.bitrate, into: &buf)
+        FfiConverterOptionDouble.write(value.throughput, into: &buf)
+        FfiConverterOptionInt64.write(value.totalBytes, into: &buf)
+        FfiConverterOptionUInt64.write(value.droppedFrames, into: &buf)
+        FfiConverterOptionString.write(value.rendition, into: &buf)
+        FfiConverterOptionString.write(value.videoCodec, into: &buf)
+        FfiConverterOptionString.write(value.audioCodec, into: &buf)
+        FfiConverterOptionString.write(value.codecProfile, into: &buf)
+        FfiConverterOptionString.write(value.containerFormat, into: &buf)
+        FfiConverterOptionDictionaryStringString.write(value.legacyCustomDimensions, into: &buf)
+        FfiConverterOptionDictionaryStringString.write(value.customDimensions, into: &buf)
+        FfiConverterOptionDictionaryStringDouble.write(value.customMetrics, into: &buf)
+        FfiConverterOptionString.write(value.errorCode, into: &buf)
+        FfiConverterOptionString.write(value.errorMessage, into: &buf)
+        FfiConverterOptionString.write(value.errorMetadata, into: &buf)
+        FfiConverterOptionString.write(value.errorLevel, into: &buf)
+        FfiConverterOptionBool.write(value.forceInit, into: &buf)
+        FfiConverterOptionBool.write(value.convertFromBuffer, into: &buf)
+        FfiConverterOptionBool.write(value.convertFromSeek, into: &buf)
+        FfiConverterOptionString.write(value.customEventJson, into: &buf)
+        FfiConverterOptionDictionaryStringString.write(value.extraParams, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeAppleContentMetadata_lift(_ buf: RustBuffer) throws -> AppleContentMetadata {
+    return try FfiConverterTypeAppleContentMetadata.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeAppleContentMetadata_lower(_ value: AppleContentMetadata) -> RustBuffer {
+    return FfiConverterTypeAppleContentMetadata.lower(value)
+}
+
+
+public struct AppleMetadataSnapshot: Equatable, Hashable {
+    public var content: AppleContentMetadata
+    public var qos: AppleQosSnapshot?
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(content: AppleContentMetadata, qos: AppleQosSnapshot?) {
+        self.content = content
+        self.qos = qos
+    }
+
+    
+
+    
+}
+
+#if compiler(>=6)
+extension AppleMetadataSnapshot: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeAppleMetadataSnapshot: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AppleMetadataSnapshot {
+        return
+            try AppleMetadataSnapshot(
+                content: FfiConverterTypeAppleContentMetadata.read(from: &buf), 
+                qos: FfiConverterOptionTypeAppleQosSnapshot.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: AppleMetadataSnapshot, into buf: inout [UInt8]) {
+        FfiConverterTypeAppleContentMetadata.write(value.content, into: &buf)
+        FfiConverterOptionTypeAppleQosSnapshot.write(value.qos, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeAppleMetadataSnapshot_lift(_ buf: RustBuffer) throws -> AppleMetadataSnapshot {
+    return try FfiConverterTypeAppleMetadataSnapshot.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeAppleMetadataSnapshot_lower(_ value: AppleMetadataSnapshot) -> RustBuffer {
+    return FfiConverterTypeAppleMetadataSnapshot.lower(value)
+}
+
+
+public struct AppleNetworkObservation: Equatable, Hashable {
+    public var eventId: String
+    public var source: String
+    public var targetUrl: String
+    public var method: String
+    public var timemarkMs: UInt64
+    public var durationMs: UInt64
+    public var responseStatusCode: UInt16
+    public var outcome: String
+    public var responseStatusText: String?
+    public var errorMessage: String?
+    public var traceparent: String?
+    public var dnsDurationMs: UInt64?
+    public var connectDurationMs: UInt64?
+    public var sslDurationMs: UInt64?
+    public var requestDurationMs: UInt64?
+    public var timeToFirstByteMs: UInt64?
+    public var responseDownloadDurationMs: UInt64?
+    public var redirectDurationMs: UInt64?
+    public var redirectCount: UInt64?
+    public var `protocol`: String?
+    public var requestBytes: UInt64?
+    public var responseBytes: UInt64?
+    public var requestQuery: [String: String]?
+    public var requestHeaders: [String: String]?
+    public var responseHeaders: [String: String]?
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(eventId: String, source: String, targetUrl: String, method: String, timemarkMs: UInt64, durationMs: UInt64, responseStatusCode: UInt16, outcome: String, responseStatusText: String?, errorMessage: String?, traceparent: String?, dnsDurationMs: UInt64?, connectDurationMs: UInt64?, sslDurationMs: UInt64?, requestDurationMs: UInt64?, timeToFirstByteMs: UInt64?, responseDownloadDurationMs: UInt64?, redirectDurationMs: UInt64?, redirectCount: UInt64?, `protocol`: String?, requestBytes: UInt64?, responseBytes: UInt64?, requestQuery: [String: String]?, requestHeaders: [String: String]?, responseHeaders: [String: String]?) {
+        self.eventId = eventId
+        self.source = source
+        self.targetUrl = targetUrl
+        self.method = method
+        self.timemarkMs = timemarkMs
+        self.durationMs = durationMs
+        self.responseStatusCode = responseStatusCode
+        self.outcome = outcome
+        self.responseStatusText = responseStatusText
+        self.errorMessage = errorMessage
+        self.traceparent = traceparent
+        self.dnsDurationMs = dnsDurationMs
+        self.connectDurationMs = connectDurationMs
+        self.sslDurationMs = sslDurationMs
+        self.requestDurationMs = requestDurationMs
+        self.timeToFirstByteMs = timeToFirstByteMs
+        self.responseDownloadDurationMs = responseDownloadDurationMs
+        self.redirectDurationMs = redirectDurationMs
+        self.redirectCount = redirectCount
+        self.`protocol` = `protocol`
+        self.requestBytes = requestBytes
+        self.responseBytes = responseBytes
+        self.requestQuery = requestQuery
+        self.requestHeaders = requestHeaders
+        self.responseHeaders = responseHeaders
+    }
+
+    
+
+    
+}
+
+#if compiler(>=6)
+extension AppleNetworkObservation: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeAppleNetworkObservation: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AppleNetworkObservation {
+        return
+            try AppleNetworkObservation(
+                eventId: FfiConverterString.read(from: &buf), 
+                source: FfiConverterString.read(from: &buf), 
+                targetUrl: FfiConverterString.read(from: &buf), 
+                method: FfiConverterString.read(from: &buf), 
+                timemarkMs: FfiConverterUInt64.read(from: &buf), 
+                durationMs: FfiConverterUInt64.read(from: &buf), 
+                responseStatusCode: FfiConverterUInt16.read(from: &buf), 
+                outcome: FfiConverterString.read(from: &buf), 
+                responseStatusText: FfiConverterOptionString.read(from: &buf), 
+                errorMessage: FfiConverterOptionString.read(from: &buf), 
+                traceparent: FfiConverterOptionString.read(from: &buf), 
+                dnsDurationMs: FfiConverterOptionUInt64.read(from: &buf), 
+                connectDurationMs: FfiConverterOptionUInt64.read(from: &buf), 
+                sslDurationMs: FfiConverterOptionUInt64.read(from: &buf), 
+                requestDurationMs: FfiConverterOptionUInt64.read(from: &buf), 
+                timeToFirstByteMs: FfiConverterOptionUInt64.read(from: &buf), 
+                responseDownloadDurationMs: FfiConverterOptionUInt64.read(from: &buf), 
+                redirectDurationMs: FfiConverterOptionUInt64.read(from: &buf), 
+                redirectCount: FfiConverterOptionUInt64.read(from: &buf), 
+                protocol: FfiConverterOptionString.read(from: &buf), 
+                requestBytes: FfiConverterOptionUInt64.read(from: &buf), 
+                responseBytes: FfiConverterOptionUInt64.read(from: &buf), 
+                requestQuery: FfiConverterOptionDictionaryStringString.read(from: &buf), 
+                requestHeaders: FfiConverterOptionDictionaryStringString.read(from: &buf), 
+                responseHeaders: FfiConverterOptionDictionaryStringString.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: AppleNetworkObservation, into buf: inout [UInt8]) {
+        FfiConverterString.write(value.eventId, into: &buf)
+        FfiConverterString.write(value.source, into: &buf)
+        FfiConverterString.write(value.targetUrl, into: &buf)
+        FfiConverterString.write(value.method, into: &buf)
+        FfiConverterUInt64.write(value.timemarkMs, into: &buf)
+        FfiConverterUInt64.write(value.durationMs, into: &buf)
+        FfiConverterUInt16.write(value.responseStatusCode, into: &buf)
+        FfiConverterString.write(value.outcome, into: &buf)
+        FfiConverterOptionString.write(value.responseStatusText, into: &buf)
+        FfiConverterOptionString.write(value.errorMessage, into: &buf)
+        FfiConverterOptionString.write(value.traceparent, into: &buf)
+        FfiConverterOptionUInt64.write(value.dnsDurationMs, into: &buf)
+        FfiConverterOptionUInt64.write(value.connectDurationMs, into: &buf)
+        FfiConverterOptionUInt64.write(value.sslDurationMs, into: &buf)
+        FfiConverterOptionUInt64.write(value.requestDurationMs, into: &buf)
+        FfiConverterOptionUInt64.write(value.timeToFirstByteMs, into: &buf)
+        FfiConverterOptionUInt64.write(value.responseDownloadDurationMs, into: &buf)
+        FfiConverterOptionUInt64.write(value.redirectDurationMs, into: &buf)
+        FfiConverterOptionUInt64.write(value.redirectCount, into: &buf)
+        FfiConverterOptionString.write(value.`protocol`, into: &buf)
+        FfiConverterOptionUInt64.write(value.requestBytes, into: &buf)
+        FfiConverterOptionUInt64.write(value.responseBytes, into: &buf)
+        FfiConverterOptionDictionaryStringString.write(value.requestQuery, into: &buf)
+        FfiConverterOptionDictionaryStringString.write(value.requestHeaders, into: &buf)
+        FfiConverterOptionDictionaryStringString.write(value.responseHeaders, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeAppleNetworkObservation_lift(_ buf: RustBuffer) throws -> AppleNetworkObservation {
+    return try FfiConverterTypeAppleNetworkObservation.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeAppleNetworkObservation_lower(_ value: AppleNetworkObservation) -> RustBuffer {
+    return FfiConverterTypeAppleNetworkObservation.lower(value)
+}
+
+
+public struct ApplePreSessionEventPolicy: Equatable, Hashable {
+    public var processEventsBeforeSessionStart: Bool
+    public var queueLimitEvents: UInt64
+    public var maxAgeMs: UInt64
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(processEventsBeforeSessionStart: Bool, queueLimitEvents: UInt64, maxAgeMs: UInt64) {
+        self.processEventsBeforeSessionStart = processEventsBeforeSessionStart
+        self.queueLimitEvents = queueLimitEvents
+        self.maxAgeMs = maxAgeMs
+    }
+
+    
+
+    
+}
+
+#if compiler(>=6)
+extension ApplePreSessionEventPolicy: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeApplePreSessionEventPolicy: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ApplePreSessionEventPolicy {
+        return
+            try ApplePreSessionEventPolicy(
+                processEventsBeforeSessionStart: FfiConverterBool.read(from: &buf), 
+                queueLimitEvents: FfiConverterUInt64.read(from: &buf), 
+                maxAgeMs: FfiConverterUInt64.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: ApplePreSessionEventPolicy, into buf: inout [UInt8]) {
+        FfiConverterBool.write(value.processEventsBeforeSessionStart, into: &buf)
+        FfiConverterUInt64.write(value.queueLimitEvents, into: &buf)
+        FfiConverterUInt64.write(value.maxAgeMs, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeApplePreSessionEventPolicy_lift(_ buf: RustBuffer) throws -> ApplePreSessionEventPolicy {
+    return try FfiConverterTypeApplePreSessionEventPolicy.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeApplePreSessionEventPolicy_lower(_ value: ApplePreSessionEventPolicy) -> RustBuffer {
+    return FfiConverterTypeApplePreSessionEventPolicy.lower(value)
+}
+
+
+public struct AppleQosSnapshot: Equatable, Hashable {
+    public var throughput: Double?
+    public var fps: Double?
+    public var latency: Double?
+    public var playrate: Double?
+    public var droppedFrames: UInt64?
+    public var totalBytes: Int64?
+    public var packetLoss: UInt64?
+    public var packetSent: UInt64?
+    public var droppedPackets: UInt64?
+    public var lostPackets: UInt64?
+    public var multicastAffectionTimeMs: UInt64?
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(throughput: Double?, fps: Double?, latency: Double?, playrate: Double?, droppedFrames: UInt64?, totalBytes: Int64?, packetLoss: UInt64?, packetSent: UInt64?, droppedPackets: UInt64?, lostPackets: UInt64?, multicastAffectionTimeMs: UInt64?) {
+        self.throughput = throughput
+        self.fps = fps
+        self.latency = latency
+        self.playrate = playrate
+        self.droppedFrames = droppedFrames
+        self.totalBytes = totalBytes
+        self.packetLoss = packetLoss
+        self.packetSent = packetSent
+        self.droppedPackets = droppedPackets
+        self.lostPackets = lostPackets
+        self.multicastAffectionTimeMs = multicastAffectionTimeMs
+    }
+
+    
+
+    
+}
+
+#if compiler(>=6)
+extension AppleQosSnapshot: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeAppleQosSnapshot: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AppleQosSnapshot {
+        return
+            try AppleQosSnapshot(
+                throughput: FfiConverterOptionDouble.read(from: &buf), 
+                fps: FfiConverterOptionDouble.read(from: &buf), 
+                latency: FfiConverterOptionDouble.read(from: &buf), 
+                playrate: FfiConverterOptionDouble.read(from: &buf), 
+                droppedFrames: FfiConverterOptionUInt64.read(from: &buf), 
+                totalBytes: FfiConverterOptionInt64.read(from: &buf), 
+                packetLoss: FfiConverterOptionUInt64.read(from: &buf), 
+                packetSent: FfiConverterOptionUInt64.read(from: &buf), 
+                droppedPackets: FfiConverterOptionUInt64.read(from: &buf), 
+                lostPackets: FfiConverterOptionUInt64.read(from: &buf), 
+                multicastAffectionTimeMs: FfiConverterOptionUInt64.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: AppleQosSnapshot, into buf: inout [UInt8]) {
+        FfiConverterOptionDouble.write(value.throughput, into: &buf)
+        FfiConverterOptionDouble.write(value.fps, into: &buf)
+        FfiConverterOptionDouble.write(value.latency, into: &buf)
+        FfiConverterOptionDouble.write(value.playrate, into: &buf)
+        FfiConverterOptionUInt64.write(value.droppedFrames, into: &buf)
+        FfiConverterOptionInt64.write(value.totalBytes, into: &buf)
+        FfiConverterOptionUInt64.write(value.packetLoss, into: &buf)
+        FfiConverterOptionUInt64.write(value.packetSent, into: &buf)
+        FfiConverterOptionUInt64.write(value.droppedPackets, into: &buf)
+        FfiConverterOptionUInt64.write(value.lostPackets, into: &buf)
+        FfiConverterOptionUInt64.write(value.multicastAffectionTimeMs, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeAppleQosSnapshot_lift(_ buf: RustBuffer) throws -> AppleQosSnapshot {
+    return try FfiConverterTypeAppleQosSnapshot.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeAppleQosSnapshot_lower(_ value: AppleQosSnapshot) -> RustBuffer {
+    return FfiConverterTypeAppleQosSnapshot.lower(value)
+}
+
+
+public struct AppleRenderedLog: Equatable, Hashable {
+    public var level: String
+    public var tag: String
+    public var message: String
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(level: String, tag: String, message: String) {
+        self.level = level
+        self.tag = tag
+        self.message = message
+    }
+
+    
+
+    
+}
+
+#if compiler(>=6)
+extension AppleRenderedLog: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeAppleRenderedLog: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AppleRenderedLog {
+        return
+            try AppleRenderedLog(
+                level: FfiConverterString.read(from: &buf), 
+                tag: FfiConverterString.read(from: &buf), 
+                message: FfiConverterString.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: AppleRenderedLog, into buf: inout [UInt8]) {
+        FfiConverterString.write(value.level, into: &buf)
+        FfiConverterString.write(value.tag, into: &buf)
+        FfiConverterString.write(value.message, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeAppleRenderedLog_lift(_ buf: RustBuffer) throws -> AppleRenderedLog {
+    return try FfiConverterTypeAppleRenderedLog.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeAppleRenderedLog_lower(_ value: AppleRenderedLog) -> RustBuffer {
+    return FfiConverterTypeAppleRenderedLog.lower(value)
+}
+
+
+public struct AppleRuntimeConfig: Equatable, Hashable {
+    public var accountCode: String
+    public var pluginVersion: String
+    public var appName: String
+    public var buildVariant: String
+    public var appReleaseVersion: String?
+    public var lmaEndpoint: String
+    public var analyticsUserAgent: String?
+    public var allowLocalHttp: Bool
+    public var logLevel: String
+    public var preSessionEventPolicy: ApplePreSessionEventPolicy
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(accountCode: String, pluginVersion: String, appName: String, buildVariant: String, appReleaseVersion: String?, lmaEndpoint: String, analyticsUserAgent: String?, allowLocalHttp: Bool, logLevel: String, preSessionEventPolicy: ApplePreSessionEventPolicy) {
+        self.accountCode = accountCode
+        self.pluginVersion = pluginVersion
+        self.appName = appName
+        self.buildVariant = buildVariant
+        self.appReleaseVersion = appReleaseVersion
+        self.lmaEndpoint = lmaEndpoint
+        self.analyticsUserAgent = analyticsUserAgent
+        self.allowLocalHttp = allowLocalHttp
+        self.logLevel = logLevel
+        self.preSessionEventPolicy = preSessionEventPolicy
+    }
+
+    
+
+    
+}
+
+#if compiler(>=6)
+extension AppleRuntimeConfig: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeAppleRuntimeConfig: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AppleRuntimeConfig {
+        return
+            try AppleRuntimeConfig(
+                accountCode: FfiConverterString.read(from: &buf), 
+                pluginVersion: FfiConverterString.read(from: &buf), 
+                appName: FfiConverterString.read(from: &buf), 
+                buildVariant: FfiConverterString.read(from: &buf), 
+                appReleaseVersion: FfiConverterOptionString.read(from: &buf), 
+                lmaEndpoint: FfiConverterString.read(from: &buf), 
+                analyticsUserAgent: FfiConverterOptionString.read(from: &buf), 
+                allowLocalHttp: FfiConverterBool.read(from: &buf), 
+                logLevel: FfiConverterString.read(from: &buf), 
+                preSessionEventPolicy: FfiConverterTypeApplePreSessionEventPolicy.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: AppleRuntimeConfig, into buf: inout [UInt8]) {
+        FfiConverterString.write(value.accountCode, into: &buf)
+        FfiConverterString.write(value.pluginVersion, into: &buf)
+        FfiConverterString.write(value.appName, into: &buf)
+        FfiConverterString.write(value.buildVariant, into: &buf)
+        FfiConverterOptionString.write(value.appReleaseVersion, into: &buf)
+        FfiConverterString.write(value.lmaEndpoint, into: &buf)
+        FfiConverterOptionString.write(value.analyticsUserAgent, into: &buf)
+        FfiConverterBool.write(value.allowLocalHttp, into: &buf)
+        FfiConverterString.write(value.logLevel, into: &buf)
+        FfiConverterTypeApplePreSessionEventPolicy.write(value.preSessionEventPolicy, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeAppleRuntimeConfig_lift(_ buf: RustBuffer) throws -> AppleRuntimeConfig {
+    return try FfiConverterTypeAppleRuntimeConfig.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeAppleRuntimeConfig_lower(_ value: AppleRuntimeConfig) -> RustBuffer {
+    return FfiConverterTypeAppleRuntimeConfig.lower(value)
+}
+
+
+public struct AppleRuntimeEventSnapshot: Equatable, Hashable {
+    public var eventName: String
+    public var timemarkMs: UInt64
+    public var viewId: UInt64?
+    public var payload: [String: String]
+    public var outcome: AppleBindingOutcome
+    public var destination: String?
+    public var dispatchSource: String
+    public var replay: Bool
+    public var renderedLog: AppleRenderedLog?
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(eventName: String, timemarkMs: UInt64, viewId: UInt64?, payload: [String: String], outcome: AppleBindingOutcome, destination: String?, dispatchSource: String, replay: Bool, renderedLog: AppleRenderedLog?) {
+        self.eventName = eventName
+        self.timemarkMs = timemarkMs
+        self.viewId = viewId
+        self.payload = payload
+        self.outcome = outcome
+        self.destination = destination
+        self.dispatchSource = dispatchSource
+        self.replay = replay
+        self.renderedLog = renderedLog
+    }
+
+    
+
+    
+}
+
+#if compiler(>=6)
+extension AppleRuntimeEventSnapshot: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeAppleRuntimeEventSnapshot: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AppleRuntimeEventSnapshot {
+        return
+            try AppleRuntimeEventSnapshot(
+                eventName: FfiConverterString.read(from: &buf), 
+                timemarkMs: FfiConverterUInt64.read(from: &buf), 
+                viewId: FfiConverterOptionUInt64.read(from: &buf), 
+                payload: FfiConverterDictionaryStringString.read(from: &buf), 
+                outcome: FfiConverterTypeAppleBindingOutcome.read(from: &buf), 
+                destination: FfiConverterOptionString.read(from: &buf), 
+                dispatchSource: FfiConverterString.read(from: &buf), 
+                replay: FfiConverterBool.read(from: &buf), 
+                renderedLog: FfiConverterOptionTypeAppleRenderedLog.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: AppleRuntimeEventSnapshot, into buf: inout [UInt8]) {
+        FfiConverterString.write(value.eventName, into: &buf)
+        FfiConverterUInt64.write(value.timemarkMs, into: &buf)
+        FfiConverterOptionUInt64.write(value.viewId, into: &buf)
+        FfiConverterDictionaryStringString.write(value.payload, into: &buf)
+        FfiConverterTypeAppleBindingOutcome.write(value.outcome, into: &buf)
+        FfiConverterOptionString.write(value.destination, into: &buf)
+        FfiConverterString.write(value.dispatchSource, into: &buf)
+        FfiConverterBool.write(value.replay, into: &buf)
+        FfiConverterOptionTypeAppleRenderedLog.write(value.renderedLog, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeAppleRuntimeEventSnapshot_lift(_ buf: RustBuffer) throws -> AppleRuntimeEventSnapshot {
+    return try FfiConverterTypeAppleRuntimeEventSnapshot.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeAppleRuntimeEventSnapshot_lower(_ value: AppleRuntimeEventSnapshot) -> RustBuffer {
+    return FfiConverterTypeAppleRuntimeEventSnapshot.lower(value)
+}
+
+
+public struct AppleSemanticTimestamp: Equatable, Hashable {
+    public var timemarkMs: UInt64
+    public var elapsedRealtimeMs: UInt64
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(timemarkMs: UInt64, elapsedRealtimeMs: UInt64) {
+        self.timemarkMs = timemarkMs
+        self.elapsedRealtimeMs = elapsedRealtimeMs
+    }
+
+    
+
+    
+}
+
+#if compiler(>=6)
+extension AppleSemanticTimestamp: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeAppleSemanticTimestamp: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AppleSemanticTimestamp {
+        return
+            try AppleSemanticTimestamp(
+                timemarkMs: FfiConverterUInt64.read(from: &buf), 
+                elapsedRealtimeMs: FfiConverterUInt64.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: AppleSemanticTimestamp, into buf: inout [UInt8]) {
+        FfiConverterUInt64.write(value.timemarkMs, into: &buf)
+        FfiConverterUInt64.write(value.elapsedRealtimeMs, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeAppleSemanticTimestamp_lift(_ buf: RustBuffer) throws -> AppleSemanticTimestamp {
+    return try FfiConverterTypeAppleSemanticTimestamp.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeAppleSemanticTimestamp_lower(_ value: AppleSemanticTimestamp) -> RustBuffer {
+    return FfiConverterTypeAppleSemanticTimestamp.lower(value)
+}
+
+
+public struct AppleVideoOptions: Equatable, Hashable {
+    public var joinTimeCalculationMode: String?
+    public var adJoinFromAdBreakStart: Bool?
+    public var adConnectedRequiresAdJoin: Bool?
+    public var contentIsLiveNoSeek: Bool?
+    public var ignorePauseSmallEvents: Bool?
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(joinTimeCalculationMode: String?, adJoinFromAdBreakStart: Bool?, adConnectedRequiresAdJoin: Bool?, contentIsLiveNoSeek: Bool?, ignorePauseSmallEvents: Bool?) {
+        self.joinTimeCalculationMode = joinTimeCalculationMode
+        self.adJoinFromAdBreakStart = adJoinFromAdBreakStart
+        self.adConnectedRequiresAdJoin = adConnectedRequiresAdJoin
+        self.contentIsLiveNoSeek = contentIsLiveNoSeek
+        self.ignorePauseSmallEvents = ignorePauseSmallEvents
+    }
+
+    
+
+    
+}
+
+#if compiler(>=6)
+extension AppleVideoOptions: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeAppleVideoOptions: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AppleVideoOptions {
+        return
+            try AppleVideoOptions(
+                joinTimeCalculationMode: FfiConverterOptionString.read(from: &buf), 
+                adJoinFromAdBreakStart: FfiConverterOptionBool.read(from: &buf), 
+                adConnectedRequiresAdJoin: FfiConverterOptionBool.read(from: &buf), 
+                contentIsLiveNoSeek: FfiConverterOptionBool.read(from: &buf), 
+                ignorePauseSmallEvents: FfiConverterOptionBool.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: AppleVideoOptions, into buf: inout [UInt8]) {
+        FfiConverterOptionString.write(value.joinTimeCalculationMode, into: &buf)
+        FfiConverterOptionBool.write(value.adJoinFromAdBreakStart, into: &buf)
+        FfiConverterOptionBool.write(value.adConnectedRequiresAdJoin, into: &buf)
+        FfiConverterOptionBool.write(value.contentIsLiveNoSeek, into: &buf)
+        FfiConverterOptionBool.write(value.ignorePauseSmallEvents, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeAppleVideoOptions_lift(_ buf: RustBuffer) throws -> AppleVideoOptions {
+    return try FfiConverterTypeAppleVideoOptions.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeAppleVideoOptions_lower(_ value: AppleVideoOptions) -> RustBuffer {
+    return FfiConverterTypeAppleVideoOptions.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 AppleAdEvent: Equatable, Hashable {
+    
+    case manifest
+    case breakStart
+    case `init`
+    case start
+    case join
+    case pause
+    case resume
+    case bufferBegin
+    case bufferEnd
+    case quartile
+    case click
+    case skip
+    case stop
+    case error
+    case fatalError
+    case breakStop
+
+
+
+
+
+}
+
+#if compiler(>=6)
+extension AppleAdEvent: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeAppleAdEvent: FfiConverterRustBuffer {
+    typealias SwiftType = AppleAdEvent
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AppleAdEvent {
+        let variant: Int32 = try readInt(&buf)
+        switch variant {
+        
+        case 1: return .manifest
+        
+        case 2: return .breakStart
+        
+        case 3: return .`init`
+        
+        case 4: return .start
+        
+        case 5: return .join
+        
+        case 6: return .pause
+        
+        case 7: return .resume
+        
+        case 8: return .bufferBegin
+        
+        case 9: return .bufferEnd
+        
+        case 10: return .quartile
+        
+        case 11: return .click
+        
+        case 12: return .skip
+        
+        case 13: return .stop
+        
+        case 14: return .error
+        
+        case 15: return .fatalError
+        
+        case 16: return .breakStop
+        
+        default: throw UniffiInternalError.unexpectedEnumCase
+        }
+    }
+
+    public static func write(_ value: AppleAdEvent, into buf: inout [UInt8]) {
+        switch value {
+        
+        
+        case .manifest:
+            writeInt(&buf, Int32(1))
+        
+        
+        case .breakStart:
+            writeInt(&buf, Int32(2))
+        
+        
+        case .`init`:
+            writeInt(&buf, Int32(3))
+        
+        
+        case .start:
+            writeInt(&buf, Int32(4))
+        
+        
+        case .join:
+            writeInt(&buf, Int32(5))
+        
+        
+        case .pause:
+            writeInt(&buf, Int32(6))
+        
+        
+        case .resume:
+            writeInt(&buf, Int32(7))
+        
+        
+        case .bufferBegin:
+            writeInt(&buf, Int32(8))
+        
+        
+        case .bufferEnd:
+            writeInt(&buf, Int32(9))
+        
+        
+        case .quartile:
+            writeInt(&buf, Int32(10))
+        
+        
+        case .click:
+            writeInt(&buf, Int32(11))
+        
+        
+        case .skip:
+            writeInt(&buf, Int32(12))
+        
+        
+        case .stop:
+            writeInt(&buf, Int32(13))
+        
+        
+        case .error:
+            writeInt(&buf, Int32(14))
+        
+        
+        case .fatalError:
+            writeInt(&buf, Int32(15))
+        
+        
+        case .breakStop:
+            writeInt(&buf, Int32(16))
+        
+        }
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeAppleAdEvent_lift(_ buf: RustBuffer) throws -> AppleAdEvent {
+    return try FfiConverterTypeAppleAdEvent.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeAppleAdEvent_lower(_ value: AppleAdEvent) -> RustBuffer {
+    return FfiConverterTypeAppleAdEvent.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 AppleAdInsertionType: Equatable, Hashable {
+    
+    case clientSide
+    case serverSide
+    case unknown
+
+
+
+
+
+}
+
+#if compiler(>=6)
+extension AppleAdInsertionType: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeAppleAdInsertionType: FfiConverterRustBuffer {
+    typealias SwiftType = AppleAdInsertionType
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AppleAdInsertionType {
+        let variant: Int32 = try readInt(&buf)
+        switch variant {
+        
+        case 1: return .clientSide
+        
+        case 2: return .serverSide
+        
+        case 3: return .unknown
+        
+        default: throw UniffiInternalError.unexpectedEnumCase
+        }
+    }
+
+    public static func write(_ value: AppleAdInsertionType, into buf: inout [UInt8]) {
+        switch value {
+        
+        
+        case .clientSide:
+            writeInt(&buf, Int32(1))
+        
+        
+        case .serverSide:
+            writeInt(&buf, Int32(2))
+        
+        
+        case .unknown:
+            writeInt(&buf, Int32(3))
+        
+        }
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeAppleAdInsertionType_lift(_ buf: RustBuffer) throws -> AppleAdInsertionType {
+    return try FfiConverterTypeAppleAdInsertionType.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeAppleAdInsertionType_lower(_ value: AppleAdInsertionType) -> RustBuffer {
+    return FfiConverterTypeAppleAdInsertionType.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 AppleAdPosition: Equatable, Hashable {
+    
+    case pre
+    case mid
+    case post
+    case unknown
+
+
+
+
+
+}
+
+#if compiler(>=6)
+extension AppleAdPosition: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeAppleAdPosition: FfiConverterRustBuffer {
+    typealias SwiftType = AppleAdPosition
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AppleAdPosition {
+        let variant: Int32 = try readInt(&buf)
+        switch variant {
+        
+        case 1: return .pre
+        
+        case 2: return .mid
+        
+        case 3: return .post
+        
+        case 4: return .unknown
+        
+        default: throw UniffiInternalError.unexpectedEnumCase
+        }
+    }
+
+    public static func write(_ value: AppleAdPosition, into buf: inout [UInt8]) {
+        switch value {
+        
+        
+        case .pre:
+            writeInt(&buf, Int32(1))
+        
+        
+        case .mid:
+            writeInt(&buf, Int32(2))
+        
+        
+        case .post:
+            writeInt(&buf, Int32(3))
+        
+        
+        case .unknown:
+            writeInt(&buf, Int32(4))
+        
+        }
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeAppleAdPosition_lift(_ buf: RustBuffer) throws -> AppleAdPosition {
+    return try FfiConverterTypeAppleAdPosition.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeAppleAdPosition_lower(_ value: AppleAdPosition) -> RustBuffer {
+    return FfiConverterTypeAppleAdPosition.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 AppleBindingStatus: Equatable, Hashable {
+    
+    case accepted
+    case deferred
+    case dropped
+    case ignoredDuplicate
+    case ignoredBeforeSessionStart
+    case ignoredInvalidState
+    case failedWithDiagnostic
+
+
+
+
+
+}
+
+#if compiler(>=6)
+extension AppleBindingStatus: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeAppleBindingStatus: FfiConverterRustBuffer {
+    typealias SwiftType = AppleBindingStatus
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AppleBindingStatus {
+        let variant: Int32 = try readInt(&buf)
+        switch variant {
+        
+        case 1: return .accepted
+        
+        case 2: return .deferred
+        
+        case 3: return .dropped
+        
+        case 4: return .ignoredDuplicate
+        
+        case 5: return .ignoredBeforeSessionStart
+        
+        case 6: return .ignoredInvalidState
+        
+        case 7: return .failedWithDiagnostic
+        
+        default: throw UniffiInternalError.unexpectedEnumCase
+        }
+    }
+
+    public static func write(_ value: AppleBindingStatus, into buf: inout [UInt8]) {
+        switch value {
+        
+        
+        case .accepted:
+            writeInt(&buf, Int32(1))
+        
+        
+        case .deferred:
+            writeInt(&buf, Int32(2))
+        
+        
+        case .dropped:
+            writeInt(&buf, Int32(3))
+        
+        
+        case .ignoredDuplicate:
+            writeInt(&buf, Int32(4))
+        
+        
+        case .ignoredBeforeSessionStart:
+            writeInt(&buf, Int32(5))
+        
+        
+        case .ignoredInvalidState:
+            writeInt(&buf, Int32(6))
+        
+        
+        case .failedWithDiagnostic:
+            writeInt(&buf, Int32(7))
+        
+        }
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeAppleBindingStatus_lift(_ buf: RustBuffer) throws -> AppleBindingStatus {
+    return try FfiConverterTypeAppleBindingStatus.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeAppleBindingStatus_lower(_ value: AppleBindingStatus) -> RustBuffer {
+    return FfiConverterTypeAppleBindingStatus.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 AppleContentType: Equatable, Hashable {
+    
+    case live
+    case vod
+    case audio
+    case unknown
+
+
+
+
+
+}
+
+#if compiler(>=6)
+extension AppleContentType: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeAppleContentType: FfiConverterRustBuffer {
+    typealias SwiftType = AppleContentType
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AppleContentType {
+        let variant: Int32 = try readInt(&buf)
+        switch variant {
+        
+        case 1: return .live
+        
+        case 2: return .vod
+        
+        case 3: return .audio
+        
+        case 4: return .unknown
+        
+        default: throw UniffiInternalError.unexpectedEnumCase
+        }
+    }
+
+    public static func write(_ value: AppleContentType, into buf: inout [UInt8]) {
+        switch value {
+        
+        
+        case .live:
+            writeInt(&buf, Int32(1))
+        
+        
+        case .vod:
+            writeInt(&buf, Int32(2))
+        
+        
+        case .audio:
+            writeInt(&buf, Int32(3))
+        
+        
+        case .unknown:
+            writeInt(&buf, Int32(4))
+        
+        }
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeAppleContentType_lift(_ buf: RustBuffer) throws -> AppleContentType {
+    return try FfiConverterTypeAppleContentType.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeAppleContentType_lower(_ value: AppleContentType) -> RustBuffer {
+    return FfiConverterTypeAppleContentType.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 AppleVideoEvent: Equatable, Hashable {
+    
+    case `init`
+    case start
+    case join
+    case pause
+    case resume
+    case seekBegin
+    case seekEnd
+    case bufferBegin
+    case bufferEnd
+    case stop
+    case error
+    case fatalError
+    case destroy
+    case custom
+    case customEnd
+    case metadataUpdate
+
+
+
+
+
+}
+
+#if compiler(>=6)
+extension AppleVideoEvent: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeAppleVideoEvent: FfiConverterRustBuffer {
+    typealias SwiftType = AppleVideoEvent
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AppleVideoEvent {
+        let variant: Int32 = try readInt(&buf)
+        switch variant {
+        
+        case 1: return .`init`
+        
+        case 2: return .start
+        
+        case 3: return .join
+        
+        case 4: return .pause
+        
+        case 5: return .resume
+        
+        case 6: return .seekBegin
+        
+        case 7: return .seekEnd
+        
+        case 8: return .bufferBegin
+        
+        case 9: return .bufferEnd
+        
+        case 10: return .stop
+        
+        case 11: return .error
+        
+        case 12: return .fatalError
+        
+        case 13: return .destroy
+        
+        case 14: return .custom
+        
+        case 15: return .customEnd
+        
+        case 16: return .metadataUpdate
+        
+        default: throw UniffiInternalError.unexpectedEnumCase
+        }
+    }
+
+    public static func write(_ value: AppleVideoEvent, into buf: inout [UInt8]) {
+        switch value {
+        
+        
+        case .`init`:
+            writeInt(&buf, Int32(1))
+        
+        
+        case .start:
+            writeInt(&buf, Int32(2))
+        
+        
+        case .join:
+            writeInt(&buf, Int32(3))
+        
+        
+        case .pause:
+            writeInt(&buf, Int32(4))
+        
+        
+        case .resume:
+            writeInt(&buf, Int32(5))
+        
+        
+        case .seekBegin:
+            writeInt(&buf, Int32(6))
+        
+        
+        case .seekEnd:
+            writeInt(&buf, Int32(7))
+        
+        
+        case .bufferBegin:
+            writeInt(&buf, Int32(8))
+        
+        
+        case .bufferEnd:
+            writeInt(&buf, Int32(9))
+        
+        
+        case .stop:
+            writeInt(&buf, Int32(10))
+        
+        
+        case .error:
+            writeInt(&buf, Int32(11))
+        
+        
+        case .fatalError:
+            writeInt(&buf, Int32(12))
+        
+        
+        case .destroy:
+            writeInt(&buf, Int32(13))
+        
+        
+        case .custom:
+            writeInt(&buf, Int32(14))
+        
+        
+        case .customEnd:
+            writeInt(&buf, Int32(15))
+        
+        
+        case .metadataUpdate:
+            writeInt(&buf, Int32(16))
+        
+        }
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeAppleVideoEvent_lift(_ buf: RustBuffer) throws -> AppleVideoEvent {
+    return try FfiConverterTypeAppleVideoEvent.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeAppleVideoEvent_lower(_ value: AppleVideoEvent) -> RustBuffer {
+    return FfiConverterTypeAppleVideoEvent.lower(value)
+}
+
+
+
+
+
+public protocol AppleCapturePlanListener: AnyObject, Sendable {
+    
+    func onPlan(plan: AppleCapturePlan) 
+    
+}
+
+
+// Put the implementation in a struct so we don't pollute the top-level namespace
+fileprivate struct UniffiCallbackInterfaceAppleCapturePlanListener {
+
+    // Create the VTable using a series of closures.
+    // Swift automatically converts these into C callback functions.
+    //
+    // Store the vtable directly.
+    static let vtable: UniffiVTableCallbackInterfaceAppleCapturePlanListener = UniffiVTableCallbackInterfaceAppleCapturePlanListener(
+        uniffiFree: { (uniffiHandle: UInt64) -> () in
+            do {
+                try FfiConverterCallbackInterfaceAppleCapturePlanListener.handleMap.remove(handle: uniffiHandle)
+            } catch {
+                print("Uniffi callback interface AppleCapturePlanListener: handle missing in uniffiFree")
+            }
+        },
+        uniffiClone: { (uniffiHandle: UInt64) -> UInt64 in
+            do {
+                return try FfiConverterCallbackInterfaceAppleCapturePlanListener.handleMap.clone(handle: uniffiHandle)
+            } catch {
+                fatalError("Uniffi callback interface AppleCapturePlanListener: handle missing in uniffiClone")
+            }
+        },
+        onPlan: { (
+            uniffiHandle: UInt64,
+            plan: RustBuffer,
+            uniffiOutReturn: UnsafeMutableRawPointer,
+            uniffiCallStatus: UnsafeMutablePointer<RustCallStatus>
+        ) in
+            let makeCall = {
+                () throws -> () in
+                guard let uniffiObj = try? FfiConverterCallbackInterfaceAppleCapturePlanListener.handleMap.get(handle: uniffiHandle) else {
+                    throw UniffiInternalError.unexpectedStaleHandle
+                }
+                return uniffiObj.onPlan(
+                     plan: try FfiConverterTypeAppleCapturePlan_lift(plan)
+                )
+            }
+
+            
+            let writeReturn = { () }
+            uniffiTraitInterfaceCall(
+                callStatus: uniffiCallStatus,
+                makeCall: makeCall,
+                writeReturn: writeReturn
+            )
+        }
+    )
+
+    // Rust stores this pointer for future callback invocations, so it must live
+    // for the process lifetime (not just for the init function call).
+    static let vtablePtr: UnsafePointer<UniffiVTableCallbackInterfaceAppleCapturePlanListener> = {
+        let ptr = UnsafeMutablePointer<UniffiVTableCallbackInterfaceAppleCapturePlanListener>.allocate(capacity: 1)
+        ptr.initialize(to: vtable)
+        return UnsafePointer(ptr)
+    }()
+}
+
+private func uniffiCallbackInitAppleCapturePlanListener() {
+    uniffi_forge_kernel_uniffi_fn_init_callback_vtable_applecaptureplanlistener(UniffiCallbackInterfaceAppleCapturePlanListener.vtablePtr)
+}
+
+// FfiConverter protocol for callback interfaces
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterCallbackInterfaceAppleCapturePlanListener {
+    fileprivate static let handleMap = UniffiHandleMap<AppleCapturePlanListener>()
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+extension FfiConverterCallbackInterfaceAppleCapturePlanListener : FfiConverter {
+    typealias SwiftType = AppleCapturePlanListener
+    typealias FfiType = UInt64
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+    public static func lift(_ handle: UInt64) throws -> SwiftType {
+        try handleMap.get(handle: handle)
+    }
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType {
+        let handle: UInt64 = try readInt(&buf)
+        return try lift(handle)
+    }
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+    public static func lower(_ v: SwiftType) -> UInt64 {
+        return handleMap.insert(obj: v)
+    }
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+    public static func write(_ v: SwiftType, into buf: inout [UInt8]) {
+        writeInt(&buf, lower(v))
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterCallbackInterfaceAppleCapturePlanListener_lift(_ handle: UInt64) throws -> AppleCapturePlanListener {
+    return try FfiConverterCallbackInterfaceAppleCapturePlanListener.lift(handle)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterCallbackInterfaceAppleCapturePlanListener_lower(_ v: AppleCapturePlanListener) -> UInt64 {
+    return FfiConverterCallbackInterfaceAppleCapturePlanListener.lower(v)
+}
+
+
+
+
+public protocol AppleContentMetadataProvider: AnyObject, Sendable {
+    
+    func metadataSnapshot(viewId: UInt64, timestamp: AppleSemanticTimestamp)  -> AppleMetadataSnapshot?
+    
+}
+
+
+// Put the implementation in a struct so we don't pollute the top-level namespace
+fileprivate struct UniffiCallbackInterfaceAppleContentMetadataProvider {
+
+    // Create the VTable using a series of closures.
+    // Swift automatically converts these into C callback functions.
+    //
+    // Store the vtable directly.
+    static let vtable: UniffiVTableCallbackInterfaceAppleContentMetadataProvider = UniffiVTableCallbackInterfaceAppleContentMetadataProvider(
+        uniffiFree: { (uniffiHandle: UInt64) -> () in
+            do {
+                try FfiConverterCallbackInterfaceAppleContentMetadataProvider.handleMap.remove(handle: uniffiHandle)
+            } catch {
+                print("Uniffi callback interface AppleContentMetadataProvider: handle missing in uniffiFree")
+            }
+        },
+        uniffiClone: { (uniffiHandle: UInt64) -> UInt64 in
+            do {
+                return try FfiConverterCallbackInterfaceAppleContentMetadataProvider.handleMap.clone(handle: uniffiHandle)
+            } catch {
+                fatalError("Uniffi callback interface AppleContentMetadataProvider: handle missing in uniffiClone")
+            }
+        },
+        metadataSnapshot: { (
+            uniffiHandle: UInt64,
+            viewId: UInt64,
+            timestamp: RustBuffer,
+            uniffiOutReturn: UnsafeMutablePointer<RustBuffer>,
+            uniffiCallStatus: UnsafeMutablePointer<RustCallStatus>
+        ) in
+            let makeCall = {
+                () throws -> AppleMetadataSnapshot? in
+                guard let uniffiObj = try? FfiConverterCallbackInterfaceAppleContentMetadataProvider.handleMap.get(handle: uniffiHandle) else {
+                    throw UniffiInternalError.unexpectedStaleHandle
+                }
+                return uniffiObj.metadataSnapshot(
+                     viewId: try FfiConverterUInt64.lift(viewId),
+                     timestamp: try FfiConverterTypeAppleSemanticTimestamp_lift(timestamp)
+                )
+            }
+
+            
+            let writeReturn = { uniffiOutReturn.pointee = FfiConverterOptionTypeAppleMetadataSnapshot.lower($0) }
+            uniffiTraitInterfaceCall(
+                callStatus: uniffiCallStatus,
+                makeCall: makeCall,
+                writeReturn: writeReturn
+            )
+        }
+    )
+
+    // Rust stores this pointer for future callback invocations, so it must live
+    // for the process lifetime (not just for the init function call).
+    static let vtablePtr: UnsafePointer<UniffiVTableCallbackInterfaceAppleContentMetadataProvider> = {
+        let ptr = UnsafeMutablePointer<UniffiVTableCallbackInterfaceAppleContentMetadataProvider>.allocate(capacity: 1)
+        ptr.initialize(to: vtable)
+        return UnsafePointer(ptr)
+    }()
+}
+
+private func uniffiCallbackInitAppleContentMetadataProvider() {
+    uniffi_forge_kernel_uniffi_fn_init_callback_vtable_applecontentmetadataprovider(UniffiCallbackInterfaceAppleContentMetadataProvider.vtablePtr)
+}
+
+// FfiConverter protocol for callback interfaces
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterCallbackInterfaceAppleContentMetadataProvider {
+    fileprivate static let handleMap = UniffiHandleMap<AppleContentMetadataProvider>()
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+extension FfiConverterCallbackInterfaceAppleContentMetadataProvider : FfiConverter {
+    typealias SwiftType = AppleContentMetadataProvider
+    typealias FfiType = UInt64
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+    public static func lift(_ handle: UInt64) throws -> SwiftType {
+        try handleMap.get(handle: handle)
+    }
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType {
+        let handle: UInt64 = try readInt(&buf)
+        return try lift(handle)
+    }
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+    public static func lower(_ v: SwiftType) -> UInt64 {
+        return handleMap.insert(obj: v)
+    }
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+    public static func write(_ v: SwiftType, into buf: inout [UInt8]) {
+        writeInt(&buf, lower(v))
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterCallbackInterfaceAppleContentMetadataProvider_lift(_ handle: UInt64) throws -> AppleContentMetadataProvider {
+    return try FfiConverterCallbackInterfaceAppleContentMetadataProvider.lift(handle)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterCallbackInterfaceAppleContentMetadataProvider_lower(_ v: AppleContentMetadataProvider) -> UInt64 {
+    return FfiConverterCallbackInterfaceAppleContentMetadataProvider.lower(v)
+}
+
+
+
+
+public protocol AppleSessionPreSendHook: AnyObject, Sendable {
+    
+    func willSend(serviceName: String, params: [String: String])  -> [String: String]
+    
+}
+
+
+// Put the implementation in a struct so we don't pollute the top-level namespace
+fileprivate struct UniffiCallbackInterfaceAppleSessionPreSendHook {
+
+    // Create the VTable using a series of closures.
+    // Swift automatically converts these into C callback functions.
+    //
+    // Store the vtable directly.
+    static let vtable: UniffiVTableCallbackInterfaceAppleSessionPreSendHook = UniffiVTableCallbackInterfaceAppleSessionPreSendHook(
+        uniffiFree: { (uniffiHandle: UInt64) -> () in
+            do {
+                try FfiConverterCallbackInterfaceAppleSessionPreSendHook.handleMap.remove(handle: uniffiHandle)
+            } catch {
+                print("Uniffi callback interface AppleSessionPreSendHook: handle missing in uniffiFree")
+            }
+        },
+        uniffiClone: { (uniffiHandle: UInt64) -> UInt64 in
+            do {
+                return try FfiConverterCallbackInterfaceAppleSessionPreSendHook.handleMap.clone(handle: uniffiHandle)
+            } catch {
+                fatalError("Uniffi callback interface AppleSessionPreSendHook: handle missing in uniffiClone")
+            }
+        },
+        willSend: { (
+            uniffiHandle: UInt64,
+            serviceName: RustBuffer,
+            params: RustBuffer,
+            uniffiOutReturn: UnsafeMutablePointer<RustBuffer>,
+            uniffiCallStatus: UnsafeMutablePointer<RustCallStatus>
+        ) in
+            let makeCall = {
+                () throws -> [String: String] in
+                guard let uniffiObj = try? FfiConverterCallbackInterfaceAppleSessionPreSendHook.handleMap.get(handle: uniffiHandle) else {
+                    throw UniffiInternalError.unexpectedStaleHandle
+                }
+                return uniffiObj.willSend(
+                     serviceName: try FfiConverterString.lift(serviceName),
+                     params: try FfiConverterDictionaryStringString.lift(params)
+                )
+            }
+
+            
+            let writeReturn = { uniffiOutReturn.pointee = FfiConverterDictionaryStringString.lower($0) }
+            uniffiTraitInterfaceCall(
+                callStatus: uniffiCallStatus,
+                makeCall: makeCall,
+                writeReturn: writeReturn
+            )
+        }
+    )
+
+    // Rust stores this pointer for future callback invocations, so it must live
+    // for the process lifetime (not just for the init function call).
+    static let vtablePtr: UnsafePointer<UniffiVTableCallbackInterfaceAppleSessionPreSendHook> = {
+        let ptr = UnsafeMutablePointer<UniffiVTableCallbackInterfaceAppleSessionPreSendHook>.allocate(capacity: 1)
+        ptr.initialize(to: vtable)
+        return UnsafePointer(ptr)
+    }()
+}
+
+private func uniffiCallbackInitAppleSessionPreSendHook() {
+    uniffi_forge_kernel_uniffi_fn_init_callback_vtable_applesessionpresendhook(UniffiCallbackInterfaceAppleSessionPreSendHook.vtablePtr)
+}
+
+// FfiConverter protocol for callback interfaces
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterCallbackInterfaceAppleSessionPreSendHook {
+    fileprivate static let handleMap = UniffiHandleMap<AppleSessionPreSendHook>()
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+extension FfiConverterCallbackInterfaceAppleSessionPreSendHook : FfiConverter {
+    typealias SwiftType = AppleSessionPreSendHook
+    typealias FfiType = UInt64
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+    public static func lift(_ handle: UInt64) throws -> SwiftType {
+        try handleMap.get(handle: handle)
+    }
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType {
+        let handle: UInt64 = try readInt(&buf)
+        return try lift(handle)
+    }
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+    public static func lower(_ v: SwiftType) -> UInt64 {
+        return handleMap.insert(obj: v)
+    }
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+    public static func write(_ v: SwiftType, into buf: inout [UInt8]) {
+        writeInt(&buf, lower(v))
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterCallbackInterfaceAppleSessionPreSendHook_lift(_ handle: UInt64) throws -> AppleSessionPreSendHook {
+    return try FfiConverterCallbackInterfaceAppleSessionPreSendHook.lift(handle)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterCallbackInterfaceAppleSessionPreSendHook_lower(_ v: AppleSessionPreSendHook) -> UInt64 {
+    return FfiConverterCallbackInterfaceAppleSessionPreSendHook.lower(v)
+}
+
+
+
+
+public protocol AppleVideoPreSendHook: AnyObject, Sendable {
+    
+    func willSend(eventName: String, viewId: UInt64, serviceName: String, params: [String: String])  -> [String: String]
+    
+}
+
+
+// Put the implementation in a struct so we don't pollute the top-level namespace
+fileprivate struct UniffiCallbackInterfaceAppleVideoPreSendHook {
+
+    // Create the VTable using a series of closures.
+    // Swift automatically converts these into C callback functions.
+    //
+    // Store the vtable directly.
+    static let vtable: UniffiVTableCallbackInterfaceAppleVideoPreSendHook = UniffiVTableCallbackInterfaceAppleVideoPreSendHook(
+        uniffiFree: { (uniffiHandle: UInt64) -> () in
+            do {
+                try FfiConverterCallbackInterfaceAppleVideoPreSendHook.handleMap.remove(handle: uniffiHandle)
+            } catch {
+                print("Uniffi callback interface AppleVideoPreSendHook: handle missing in uniffiFree")
+            }
+        },
+        uniffiClone: { (uniffiHandle: UInt64) -> UInt64 in
+            do {
+                return try FfiConverterCallbackInterfaceAppleVideoPreSendHook.handleMap.clone(handle: uniffiHandle)
+            } catch {
+                fatalError("Uniffi callback interface AppleVideoPreSendHook: handle missing in uniffiClone")
+            }
+        },
+        willSend: { (
+            uniffiHandle: UInt64,
+            eventName: RustBuffer,
+            viewId: UInt64,
+            serviceName: RustBuffer,
+            params: RustBuffer,
+            uniffiOutReturn: UnsafeMutablePointer<RustBuffer>,
+            uniffiCallStatus: UnsafeMutablePointer<RustCallStatus>
+        ) in
+            let makeCall = {
+                () throws -> [String: String] in
+                guard let uniffiObj = try? FfiConverterCallbackInterfaceAppleVideoPreSendHook.handleMap.get(handle: uniffiHandle) else {
+                    throw UniffiInternalError.unexpectedStaleHandle
+                }
+                return uniffiObj.willSend(
+                     eventName: try FfiConverterString.lift(eventName),
+                     viewId: try FfiConverterUInt64.lift(viewId),
+                     serviceName: try FfiConverterString.lift(serviceName),
+                     params: try FfiConverterDictionaryStringString.lift(params)
+                )
+            }
+
+            
+            let writeReturn = { uniffiOutReturn.pointee = FfiConverterDictionaryStringString.lower($0) }
+            uniffiTraitInterfaceCall(
+                callStatus: uniffiCallStatus,
+                makeCall: makeCall,
+                writeReturn: writeReturn
+            )
+        }
+    )
+
+    // Rust stores this pointer for future callback invocations, so it must live
+    // for the process lifetime (not just for the init function call).
+    static let vtablePtr: UnsafePointer<UniffiVTableCallbackInterfaceAppleVideoPreSendHook> = {
+        let ptr = UnsafeMutablePointer<UniffiVTableCallbackInterfaceAppleVideoPreSendHook>.allocate(capacity: 1)
+        ptr.initialize(to: vtable)
+        return UnsafePointer(ptr)
+    }()
+}
+
+private func uniffiCallbackInitAppleVideoPreSendHook() {
+    uniffi_forge_kernel_uniffi_fn_init_callback_vtable_applevideopresendhook(UniffiCallbackInterfaceAppleVideoPreSendHook.vtablePtr)
+}
+
+// FfiConverter protocol for callback interfaces
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterCallbackInterfaceAppleVideoPreSendHook {
+    fileprivate static let handleMap = UniffiHandleMap<AppleVideoPreSendHook>()
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+extension FfiConverterCallbackInterfaceAppleVideoPreSendHook : FfiConverter {
+    typealias SwiftType = AppleVideoPreSendHook
+    typealias FfiType = UInt64
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+    public static func lift(_ handle: UInt64) throws -> SwiftType {
+        try handleMap.get(handle: handle)
+    }
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType {
+        let handle: UInt64 = try readInt(&buf)
+        return try lift(handle)
+    }
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+    public static func lower(_ v: SwiftType) -> UInt64 {
+        return handleMap.insert(obj: v)
+    }
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+    public static func write(_ v: SwiftType, into buf: inout [UInt8]) {
+        writeInt(&buf, lower(v))
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterCallbackInterfaceAppleVideoPreSendHook_lift(_ handle: UInt64) throws -> AppleVideoPreSendHook {
+    return try FfiConverterCallbackInterfaceAppleVideoPreSendHook.lift(handle)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterCallbackInterfaceAppleVideoPreSendHook_lower(_ v: AppleVideoPreSendHook) -> UInt64 {
+    return FfiConverterCallbackInterfaceAppleVideoPreSendHook.lower(v)
+}
+
+#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 FfiConverterOptionUInt64: FfiConverterRustBuffer {
+    typealias SwiftType = UInt64?
+
+    public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
+        guard let value = value else {
+            writeInt(&buf, Int8(0))
+            return
+        }
+        writeInt(&buf, Int8(1))
+        FfiConverterUInt64.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 FfiConverterUInt64.read(from: &buf)
+        default: throw UniffiInternalError.unexpectedOptionalTag
+        }
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterOptionInt64: FfiConverterRustBuffer {
+    typealias SwiftType = Int64?
+
+    public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
+        guard let value = value else {
+            writeInt(&buf, Int8(0))
+            return
+        }
+        writeInt(&buf, Int8(1))
+        FfiConverterInt64.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 FfiConverterInt64.read(from: &buf)
+        default: throw UniffiInternalError.unexpectedOptionalTag
+        }
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterOptionDouble: FfiConverterRustBuffer {
+    typealias SwiftType = Double?
+
+    public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
+        guard let value = value else {
+            writeInt(&buf, Int8(0))
+            return
+        }
+        writeInt(&buf, Int8(1))
+        FfiConverterDouble.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 FfiConverterDouble.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 FfiConverterOptionTypeAppleAdViewabilitySample: FfiConverterRustBuffer {
+    typealias SwiftType = AppleAdViewabilitySample?
+
+    public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
+        guard let value = value else {
+            writeInt(&buf, Int8(0))
+            return
+        }
+        writeInt(&buf, Int8(1))
+        FfiConverterTypeAppleAdViewabilitySample.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 FfiConverterTypeAppleAdViewabilitySample.read(from: &buf)
+        default: throw UniffiInternalError.unexpectedOptionalTag
+        }
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterOptionTypeAppleCapturePlan: FfiConverterRustBuffer {
+    typealias SwiftType = AppleCapturePlan?
+
+    public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
+        guard let value = value else {
+            writeInt(&buf, Int8(0))
+            return
+        }
+        writeInt(&buf, Int8(1))
+        FfiConverterTypeAppleCapturePlan.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 FfiConverterTypeAppleCapturePlan.read(from: &buf)
+        default: throw UniffiInternalError.unexpectedOptionalTag
+        }
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterOptionTypeAppleMetadataSnapshot: FfiConverterRustBuffer {
+    typealias SwiftType = AppleMetadataSnapshot?
+
+    public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
+        guard let value = value else {
+            writeInt(&buf, Int8(0))
+            return
+        }
+        writeInt(&buf, Int8(1))
+        FfiConverterTypeAppleMetadataSnapshot.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 FfiConverterTypeAppleMetadataSnapshot.read(from: &buf)
+        default: throw UniffiInternalError.unexpectedOptionalTag
+        }
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterOptionTypeAppleQosSnapshot: FfiConverterRustBuffer {
+    typealias SwiftType = AppleQosSnapshot?
+
+    public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
+        guard let value = value else {
+            writeInt(&buf, Int8(0))
+            return
+        }
+        writeInt(&buf, Int8(1))
+        FfiConverterTypeAppleQosSnapshot.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 FfiConverterTypeAppleQosSnapshot.read(from: &buf)
+        default: throw UniffiInternalError.unexpectedOptionalTag
+        }
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterOptionTypeAppleRenderedLog: FfiConverterRustBuffer {
+    typealias SwiftType = AppleRenderedLog?
+
+    public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
+        guard let value = value else {
+            writeInt(&buf, Int8(0))
+            return
+        }
+        writeInt(&buf, Int8(1))
+        FfiConverterTypeAppleRenderedLog.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 FfiConverterTypeAppleRenderedLog.read(from: &buf)
+        default: throw UniffiInternalError.unexpectedOptionalTag
+        }
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterOptionTypeAppleAdPosition: FfiConverterRustBuffer {
+    typealias SwiftType = AppleAdPosition?
+
+    public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
+        guard let value = value else {
+            writeInt(&buf, Int8(0))
+            return
+        }
+        writeInt(&buf, Int8(1))
+        FfiConverterTypeAppleAdPosition.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 FfiConverterTypeAppleAdPosition.read(from: &buf)
+        default: throw UniffiInternalError.unexpectedOptionalTag
+        }
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterOptionDictionaryStringDouble: FfiConverterRustBuffer {
+    typealias SwiftType = [String: Double]?
+
+    public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
+        guard let value = value else {
+            writeInt(&buf, Int8(0))
+            return
+        }
+        writeInt(&buf, Int8(1))
+        FfiConverterDictionaryStringDouble.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 FfiConverterDictionaryStringDouble.read(from: &buf)
+        default: throw UniffiInternalError.unexpectedOptionalTag
+        }
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterOptionDictionaryStringString: FfiConverterRustBuffer {
+    typealias SwiftType = [String: 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))
+        FfiConverterDictionaryStringString.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 FfiConverterDictionaryStringString.read(from: &buf)
+        default: throw UniffiInternalError.unexpectedOptionalTag
+        }
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterSequenceString: FfiConverterRustBuffer {
+    typealias SwiftType = [String]
+
+    public static func write(_ value: [String], into buf: inout [UInt8]) {
+        let len = Int32(value.count)
+        writeInt(&buf, len)
+        for item in value {
+            FfiConverterString.write(item, into: &buf)
+        }
+    }
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [String] {
+        let len: Int32 = try readInt(&buf)
+        var seq = [String]()
+        seq.reserveCapacity(Int(len))
+        for _ in 0 ..< len {
+            seq.append(try FfiConverterString.read(from: &buf))
+        }
+        return seq
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterSequenceTypeAppleRuntimeEventSnapshot: FfiConverterRustBuffer {
+    typealias SwiftType = [AppleRuntimeEventSnapshot]
+
+    public static func write(_ value: [AppleRuntimeEventSnapshot], into buf: inout [UInt8]) {
+        let len = Int32(value.count)
+        writeInt(&buf, len)
+        for item in value {
+            FfiConverterTypeAppleRuntimeEventSnapshot.write(item, into: &buf)
+        }
+    }
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [AppleRuntimeEventSnapshot] {
+        let len: Int32 = try readInt(&buf)
+        var seq = [AppleRuntimeEventSnapshot]()
+        seq.reserveCapacity(Int(len))
+        for _ in 0 ..< len {
+            seq.append(try FfiConverterTypeAppleRuntimeEventSnapshot.read(from: &buf))
+        }
+        return seq
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterDictionaryStringDouble: FfiConverterRustBuffer {
+    public static func write(_ value: [String: Double], into buf: inout [UInt8]) {
+        let len = Int32(value.count)
+        writeInt(&buf, len)
+        for (key, value) in value {
+            FfiConverterString.write(key, into: &buf)
+            FfiConverterDouble.write(value, into: &buf)
+        }
+    }
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [String: Double] {
+        let len: Int32 = try readInt(&buf)
+        var dict = [String: Double]()
+        dict.reserveCapacity(Int(len))
+        for _ in 0..<len {
+            let key = try FfiConverterString.read(from: &buf)
+            let value = try FfiConverterDouble.read(from: &buf)
+            dict[key] = value
+        }
+        return dict
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterDictionaryStringString: FfiConverterRustBuffer {
+    public static func write(_ value: [String: String], into buf: inout [UInt8]) {
+        let len = Int32(value.count)
+        writeInt(&buf, len)
+        for (key, value) in value {
+            FfiConverterString.write(key, into: &buf)
+            FfiConverterString.write(value, into: &buf)
+        }
+    }
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [String: String] {
+        let len: Int32 = try readInt(&buf)
+        var dict = [String: String]()
+        dict.reserveCapacity(Int(len))
+        for _ in 0..<len {
+            let key = try FfiConverterString.read(from: &buf)
+            let value = try FfiConverterString.read(from: &buf)
+            dict[key] = value
+        }
+        return dict
+    }
+}
+public func forgePluginVersion() -> String  {
+    return try!  FfiConverterString.lift(try! rustCall() {
+    uniffi_forge_kernel_uniffi_fn_func_forge_plugin_version($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 = 30
+    // Get the scaffolding contract version by calling the into the dylib
+    let scaffolding_contract_version = ffi_forge_kernel_uniffi_uniffi_contract_version()
+    if bindings_contract_version != scaffolding_contract_version {
+        return InitializationResult.contractVersionMismatch
+    }
+    if (uniffi_forge_kernel_uniffi_checksum_func_forge_plugin_version() != 6358) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_forge_kernel_uniffi_checksum_method_forgeruntimebridge_capture_plan() != 22959) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_forge_kernel_uniffi_checksum_method_forgeruntimebridge_clear_capture_plan_listener() != 42899) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_forge_kernel_uniffi_checksum_method_forgeruntimebridge_clear_content_metadata_provider() != 29053) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_forge_kernel_uniffi_checksum_method_forgeruntimebridge_clear_session_pre_send_hook() != 25451) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_forge_kernel_uniffi_checksum_method_forgeruntimebridge_clear_video_pre_send_hook() != 37815) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_forge_kernel_uniffi_checksum_method_forgeruntimebridge_create_video_view() != 19294) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_forge_kernel_uniffi_checksum_method_forgeruntimebridge_destroy() != 1814) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_forge_kernel_uniffi_checksum_method_forgeruntimebridge_record_ad_event() != 33930) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_forge_kernel_uniffi_checksum_method_forgeruntimebridge_record_application_foreground() != 33514) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_forge_kernel_uniffi_checksum_method_forgeruntimebridge_record_identity_event() != 47443) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_forge_kernel_uniffi_checksum_method_forgeruntimebridge_record_network_event() != 5299) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_forge_kernel_uniffi_checksum_method_forgeruntimebridge_record_player_event() != 11866) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_forge_kernel_uniffi_checksum_method_forgeruntimebridge_record_session_event() != 32672) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_forge_kernel_uniffi_checksum_method_forgeruntimebridge_set_capture_plan_listener() != 52103) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_forge_kernel_uniffi_checksum_method_forgeruntimebridge_set_content_metadata_provider() != 18303) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_forge_kernel_uniffi_checksum_method_forgeruntimebridge_set_log_level() != 1993) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_forge_kernel_uniffi_checksum_method_forgeruntimebridge_set_session_pre_send_hook() != 21614) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_forge_kernel_uniffi_checksum_method_forgeruntimebridge_set_video_pre_send_hook() != 61030) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_forge_kernel_uniffi_checksum_method_forgeruntimebridge_snapshot_events() != 6144) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_forge_kernel_uniffi_checksum_method_forgeruntimebridge_start() != 56553) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_forge_kernel_uniffi_checksum_constructor_forgeruntimebridge_new() != 24278) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_forge_kernel_uniffi_checksum_method_applecaptureplanlistener_on_plan() != 46911) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_forge_kernel_uniffi_checksum_method_applecontentmetadataprovider_metadata_snapshot() != 21583) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_forge_kernel_uniffi_checksum_method_applesessionpresendhook_will_send() != 48599) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_forge_kernel_uniffi_checksum_method_applevideopresendhook_will_send() != 35608) {
+        return InitializationResult.apiChecksumMismatch
+    }
+
+    uniffiCallbackInitAppleCapturePlanListener()
+    uniffiCallbackInitAppleContentMetadataProvider()
+    uniffiCallbackInitAppleSessionPreSendHook()
+    uniffiCallbackInitAppleVideoPreSendHook()
+    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 uniffiEnsureForgeKernelUniffiInitialized() {
+    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