rusto 0.3.2__py3-none-any.whl

rusto/generated/rusto.py

@@ -0,0 +1,2767 @@
+# This file was autogenerated by some hot garbage in the `uniffi` crate.
+# Trust me, you don't want to mess with it!
+
+# Common helper code.
+#
+# Ideally this would live in a separate .py file where it can be unittested etc
+# in isolation, and perhaps even published as a re-useable package.
+#
+# However, it's important that the details of how this helper code works (e.g. the
+# way that different builtin types are passed across the FFI) exactly match what's
+# expected by the rust code on the other side of the interface. In practice right
+# now that means coming from the exact some version of `uniffi` that was used to
+# compile the rust component. The easiest way to ensure this is to bundle the Python
+# helpers directly inline like we're doing here.
+
+from __future__ import annotations
+import os
+import sys
+import ctypes
+from dataclasses import dataclass
+import enum
+import struct
+import contextlib
+import datetime
+import threading
+import itertools
+import traceback
+import typing
+import platform
+
+
+# Used for default argument values
+_DEFAULT = object() # type: typing.Any
+
+
+class _UniffiRustBuffer(ctypes.Structure):
+    _fields_ = [
+        ("capacity", ctypes.c_uint64),
+        ("len", ctypes.c_uint64),
+        ("data", ctypes.POINTER(ctypes.c_char)),
+    ]
+
+    @staticmethod
+    def default():
+        return _UniffiRustBuffer(0, 0, None)
+
+    @staticmethod
+    def alloc(size):
+        return _uniffi_rust_call(_UniffiLib.ffi_rusto_rustbuffer_alloc, size)
+
+    @staticmethod
+    def reserve(rbuf, additional):
+        return _uniffi_rust_call(_UniffiLib.ffi_rusto_rustbuffer_reserve, rbuf, additional)
+
+    def free(self):
+        return _uniffi_rust_call(_UniffiLib.ffi_rusto_rustbuffer_free, self)
+
+    def __str__(self):
+        return "_UniffiRustBuffer(capacity={}, len={}, data={})".format(
+            self.capacity,
+            self.len,
+            self.data[0:self.len]
+        )
+
+    @contextlib.contextmanager
+    def alloc_with_builder(*args):
+        """Context-manger to allocate a buffer using a _UniffiRustBufferBuilder.
+
+        The allocated buffer will be automatically freed if an error occurs, ensuring that
+        we don't accidentally leak it.
+        """
+        builder = _UniffiRustBufferBuilder()
+        try:
+            yield builder
+        except:
+            builder.discard()
+            raise
+
+    @contextlib.contextmanager
+    def consume_with_stream(self):
+        """Context-manager to consume a buffer using a _UniffiRustBufferStream.
+
+        The _UniffiRustBuffer will be freed once the context-manager exits, ensuring that we don't
+        leak it even if an error occurs.
+        """
+        try:
+            s = _UniffiRustBufferStream.from_rust_buffer(self)
+            yield s
+            if s.remaining() != 0:
+                raise RuntimeError(f"junk data left in buffer at end of consume_with_stream {s.remaining()}")
+        finally:
+            self.free()
+
+    @contextlib.contextmanager
+    def read_with_stream(self):
+        """Context-manager to read a buffer using a _UniffiRustBufferStream.
+
+        This is like consume_with_stream, but doesn't free the buffer afterwards.
+        It should only be used with borrowed `_UniffiRustBuffer` data.
+        """
+        s = _UniffiRustBufferStream.from_rust_buffer(self)
+        yield s
+        if s.remaining() != 0:
+            raise RuntimeError(f"junk data left in buffer at end of read_with_stream {s.remaining()}")
+
+class _UniffiForeignBytes(ctypes.Structure):
+    _fields_ = [
+        ("len", ctypes.c_int32),
+        ("data", ctypes.POINTER(ctypes.c_char)),
+    ]
+
+    def __str__(self):
+        return "_UniffiForeignBytes(len={}, data={})".format(self.len, self.data[0:self.len])
+
+
+class _UniffiRustBufferStream:
+    """
+    Helper for structured reading of bytes from a _UniffiRustBuffer
+    """
+
+    def __init__(self, data, len):
+        self.data = data
+        self.len = len
+        self.offset = 0
+
+    @classmethod
+    def from_rust_buffer(cls, buf):
+        return cls(buf.data, buf.len)
+
+    def remaining(self):
+        return self.len - self.offset
+
+    def _unpack_from(self, size, format):
+        if self.offset + size > self.len:
+            raise InternalError("read past end of rust buffer")
+        value = struct.unpack(format, self.data[self.offset:self.offset+size])[0]
+        self.offset += size
+        return value
+
+    def read(self, size):
+        if self.offset + size > self.len:
+            raise InternalError("read past end of rust buffer")
+        data = self.data[self.offset:self.offset+size]
+        self.offset += size
+        return data
+
+    def read_i8(self):
+        return self._unpack_from(1, ">b")
+
+    def read_u8(self):
+        return self._unpack_from(1, ">B")
+
+    def read_i16(self):
+        return self._unpack_from(2, ">h")
+
+    def read_u16(self):
+        return self._unpack_from(2, ">H")
+
+    def read_i32(self):
+        return self._unpack_from(4, ">i")
+
+    def read_u32(self):
+        return self._unpack_from(4, ">I")
+
+    def read_i64(self):
+        return self._unpack_from(8, ">q")
+
+    def read_u64(self):
+        return self._unpack_from(8, ">Q")
+
+    def read_float(self):
+        v = self._unpack_from(4, ">f")
+        return v
+
+    def read_double(self):
+        return self._unpack_from(8, ">d")
+
+class _UniffiRustBufferBuilder:
+    """
+    Helper for structured writing of bytes into a _UniffiRustBuffer.
+    """
+
+    def __init__(self):
+        self.rbuf = _UniffiRustBuffer.alloc(16)
+        self.rbuf.len = 0
+
+    def finalize(self):
+        rbuf = self.rbuf
+        self.rbuf = None
+        return rbuf
+
+    def discard(self):
+        if self.rbuf is not None:
+            rbuf = self.finalize()
+            rbuf.free()
+
+    @contextlib.contextmanager
+    def _reserve(self, num_bytes):
+        if self.rbuf.len + num_bytes > self.rbuf.capacity:
+            self.rbuf = _UniffiRustBuffer.reserve(self.rbuf, num_bytes)
+        yield None
+        self.rbuf.len += num_bytes
+
+    def _pack_into(self, size, format, value):
+        with self._reserve(size):
+            # XXX TODO: I feel like I should be able to use `struct.pack_into` here but can't figure it out.
+            for i, byte in enumerate(struct.pack(format, value)):
+                self.rbuf.data[self.rbuf.len + i] = byte
+
+    def write(self, value):
+        with self._reserve(len(value)):
+            for i, byte in enumerate(value):
+                self.rbuf.data[self.rbuf.len + i] = byte
+
+    def write_i8(self, v):
+        self._pack_into(1, ">b", v)
+
+    def write_u8(self, v):
+        self._pack_into(1, ">B", v)
+
+    def write_i16(self, v):
+        self._pack_into(2, ">h", v)
+
+    def write_u16(self, v):
+        self._pack_into(2, ">H", v)
+
+    def write_i32(self, v):
+        self._pack_into(4, ">i", v)
+
+    def write_u32(self, v):
+        self._pack_into(4, ">I", v)
+
+    def write_i64(self, v):
+        self._pack_into(8, ">q", v)
+
+    def write_u64(self, v):
+        self._pack_into(8, ">Q", v)
+
+    def write_float(self, v):
+        self._pack_into(4, ">f", v)
+
+    def write_double(self, v):
+        self._pack_into(8, ">d", v)
+
+    def write_c_size_t(self, v):
+        self._pack_into(ctypes.sizeof(ctypes.c_size_t) , "@N", v)
+# A handful of classes and functions to support the generated data structures.
+# This would be a good candidate for isolating in its own ffi-support lib.
+
+class InternalError(Exception):
+    pass
+
+class _UniffiRustCallStatus(ctypes.Structure):
+    """
+    Error runtime.
+    """
+    _fields_ = [
+        ("code", ctypes.c_int8),
+        ("error_buf", _UniffiRustBuffer),
+    ]
+
+    # These match the values from the uniffi::rustcalls module
+    CALL_SUCCESS = 0
+    CALL_ERROR = 1
+    CALL_UNEXPECTED_ERROR = 2
+
+    @staticmethod
+    def default():
+        return _UniffiRustCallStatus(code=_UniffiRustCallStatus.CALL_SUCCESS, error_buf=_UniffiRustBuffer.default())
+
+    def __str__(self):
+        if self.code == _UniffiRustCallStatus.CALL_SUCCESS:
+            return "_UniffiRustCallStatus(CALL_SUCCESS)"
+        elif self.code == _UniffiRustCallStatus.CALL_ERROR:
+            return "_UniffiRustCallStatus(CALL_ERROR)"
+        elif self.code == _UniffiRustCallStatus.CALL_UNEXPECTED_ERROR:
+            return "_UniffiRustCallStatus(CALL_UNEXPECTED_ERROR)"
+        else:
+            return "_UniffiRustCallStatus(<invalid code>)"
+
+def _uniffi_rust_call(fn, *args):
+    # Call a rust function
+    return _uniffi_rust_call_with_error(None, fn, *args)
+
+def _uniffi_rust_call_with_error(error_ffi_converter, fn, *args):
+    # Call a rust function and handle any errors
+    #
+    # This function is used for rust calls that return Result<> and therefore can set the CALL_ERROR status code.
+    # error_ffi_converter must be set to the _UniffiConverter for the error class that corresponds to the result.
+    call_status = _UniffiRustCallStatus.default()
+
+    args_with_error = args + (ctypes.byref(call_status),)
+    result = fn(*args_with_error)
+    _uniffi_check_call_status(error_ffi_converter, call_status)
+    return result
+
+def _uniffi_check_call_status(error_ffi_converter, call_status):
+    if call_status.code == _UniffiRustCallStatus.CALL_SUCCESS:
+        pass
+    elif call_status.code == _UniffiRustCallStatus.CALL_ERROR:
+        if error_ffi_converter is None:
+            call_status.error_buf.free()
+            raise InternalError("_uniffi_rust_call_with_error: CALL_ERROR, but error_ffi_converter is None")
+        else:
+            raise error_ffi_converter.lift(call_status.error_buf)
+    elif call_status.code == _UniffiRustCallStatus.CALL_UNEXPECTED_ERROR:
+        # When the rust code sees a panic, it tries to construct a _UniffiRustBuffer
+        # with the message.  But if that code panics, then it just sends back
+        # an empty buffer.
+        if call_status.error_buf.len > 0:
+            msg = _UniffiFfiConverterString.lift(call_status.error_buf)
+        else:
+            msg = "Unknown rust panic"
+        raise InternalError(msg)
+    else:
+        raise InternalError("Invalid _UniffiRustCallStatus code: {}".format(
+            call_status.code))
+
+def _uniffi_trait_interface_call(call_status, make_call, write_return_value):
+    try:
+        return write_return_value(make_call())
+    except Exception as e:
+        call_status.code = _UniffiRustCallStatus.CALL_UNEXPECTED_ERROR
+        call_status.error_buf = _UniffiFfiConverterString.lower(repr(e))
+
+def _uniffi_trait_interface_call_with_error(call_status, make_call, write_return_value, error_type, lower_error):
+    try:
+        try:
+            return write_return_value(make_call())
+        except error_type as e:
+            call_status.code = _UniffiRustCallStatus.CALL_ERROR
+            call_status.error_buf = lower_error(e)
+    except Exception as e:
+        call_status.code = _UniffiRustCallStatus.CALL_UNEXPECTED_ERROR
+        call_status.error_buf = _UniffiFfiConverterString.lower(repr(e))
+# Initial value and increment amount for handles. 
+# These ensure that Python-generated handles always have the lowest bit set
+_UNIFFI_HANDLEMAP_INITIAL = 1
+_UNIFFI_HANDLEMAP_DELTA = 2
+
+class _UniffiHandleMap:
+    """
+    A map where inserting, getting and removing data is synchronized with a lock.
+    """
+
+    def __init__(self):
+        # type Handle = int
+        self._map = {}  # type: Dict[Handle, Any]
+        self._lock = threading.Lock()
+        self._counter = _UNIFFI_HANDLEMAP_INITIAL
+
+    def insert(self, obj):
+        with self._lock:
+            return self._insert(obj)
+
+    """Low-level insert, this assumes `self._lock` is held."""
+    def _insert(self, obj):
+        handle = self._counter
+        self._counter += _UNIFFI_HANDLEMAP_DELTA
+        self._map[handle] = obj
+        return handle
+
+    def get(self, handle):
+        try:
+            with self._lock:
+                return self._map[handle]
+        except KeyError:
+            raise InternalError(f"_UniffiHandleMap.get: Invalid handle {handle}")
+
+    def clone(self, handle):
+        try:
+            with self._lock:
+                obj = self._map[handle]
+                return self._insert(obj)
+        except KeyError:
+            raise InternalError(f"_UniffiHandleMap.clone: Invalid handle {handle}")
+
+    def remove(self, handle):
+        try:
+            with self._lock:
+                return self._map.pop(handle)
+        except KeyError:
+            raise InternalError(f"_UniffiHandleMap.remove: Invalid handle: {handle}")
+
+    def __len__(self):
+        return len(self._map)
+# Types conforming to `_UniffiConverterPrimitive` pass themselves directly over the FFI.
+class _UniffiConverterPrimitive:
+    @classmethod
+    def lift(cls, value):
+        return value
+
+    @classmethod
+    def lower(cls, value):
+        return value
+
+class _UniffiConverterPrimitiveInt(_UniffiConverterPrimitive):
+    @classmethod
+    def check_lower(cls, value):
+        try:
+            value = value.__index__()
+        except Exception:
+            raise TypeError("'{}' object cannot be interpreted as an integer".format(type(value).__name__))
+        if not isinstance(value, int):
+            raise TypeError("__index__ returned non-int (type {})".format(type(value).__name__))
+        if not cls.VALUE_MIN <= value < cls.VALUE_MAX:
+            raise ValueError("{} requires {} <= value < {}".format(cls.CLASS_NAME, cls.VALUE_MIN, cls.VALUE_MAX))
+
+class _UniffiConverterPrimitiveFloat(_UniffiConverterPrimitive):
+    @classmethod
+    def check_lower(cls, value):
+        try:
+            value = value.__float__()
+        except Exception:
+            raise TypeError("must be real number, not {}".format(type(value).__name__))
+        if not isinstance(value, float):
+            raise TypeError("__float__ returned non-float (type {})".format(type(value).__name__))
+
+# Helper class for wrapper types that will always go through a _UniffiRustBuffer.
+# Classes should inherit from this and implement the `read` and `write` static methods.
+class _UniffiConverterRustBuffer:
+    @classmethod
+    def lift(cls, rbuf):
+        with rbuf.consume_with_stream() as stream:
+            return cls.read(stream)
+
+    @classmethod
+    def lower(cls, value):
+        with _UniffiRustBuffer.alloc_with_builder() as builder:
+            cls.write(value, builder)
+            return builder.finalize()
+
+# Contains loading, initialization code, and the FFI Function declarations.
+# Define some ctypes FFI types that we use in the library
+
+"""
+Function pointer for a Rust task, which a callback function that takes a opaque pointer
+"""
+_UNIFFI_RUST_TASK = ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.c_int8)
+
+def _uniffi_future_callback_t(return_type):
+    """
+    Factory function to create callback function types for async functions
+    """
+    return ctypes.CFUNCTYPE(None, ctypes.c_uint64, return_type, _UniffiRustCallStatus)
+
+def _uniffi_load_indirect():
+    """
+    This is how we find and load the dynamic library provided by the component.
+    For now we just look it up by name.
+    """
+    if sys.platform == "darwin":
+        libname = "lib{}.dylib"
+    elif sys.platform.startswith("win"):
+        # As of python3.8, ctypes does not seem to search $PATH when loading DLLs.
+        # We could use `os.add_dll_directory` to configure the search path, but
+        # it doesn't feel right to mess with application-wide settings. Let's
+        # assume that the `.dll` is next to the `.py` file and load by full path.
+        libname = os.path.join(
+            os.path.dirname(__file__),
+            "{}.dll",
+        )
+    else:
+        # Anything else must be an ELF platform - Linux, *BSD, Solaris/illumos
+        libname = "lib{}.so"
+
+    libname = libname.format("rusto")
+    candidates = [
+        os.path.join(os.path.dirname(__file__), libname),
+        os.path.join(os.path.dirname(__file__), "..", libname),
+        os.path.join(os.path.dirname(__file__), "../../../../target/release", libname),
+        os.path.join(os.path.dirname(__file__), "../../../../target/debug", libname),
+    ]
+    env_path = os.environ.get("RUSTO_LIB_PATH")
+    if env_path:
+        candidates.insert(0, env_path)
+
+    for p in candidates:
+        if os.path.exists(p):
+            try:
+                return ctypes.cdll.LoadLibrary(p)
+            except Exception:
+                pass
+
+    try:
+        return ctypes.cdll.LoadLibrary(os.path.join(os.path.dirname(__file__), libname))
+    except Exception:
+        return ctypes.cdll.LoadLibrary(libname)
+
+def _uniffi_check_contract_api_version(lib):
+    # Get the bindings contract version from our ComponentInterface
+    bindings_contract_version = 30
+    # Get the scaffolding contract version by calling the into the dylib
+    scaffolding_contract_version = lib.ffi_rusto_uniffi_contract_version()
+    if bindings_contract_version != scaffolding_contract_version:
+        raise InternalError("UniFFI contract version mismatch: try cleaning and rebuilding your project")
+
+def _uniffi_check_api_checksums(lib):
+    if lib.uniffi_rusto_checksum_func_create_initialize_config_ppv6() != 12132:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_rusto_checksum_func_default_ocr_run_options() != 50314:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_rusto_checksum_func_rusto_version() != 48676:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_rusto_checksum_constructor_rusto_initialize() != 334:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_rusto_checksum_constructor_rusto_initialize_from_json() != 23041:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_rusto_checksum_method_rusto_detect_text() != 7671:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_rusto_checksum_method_rusto_detect_text_rgb() != 14239:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_rusto_checksum_method_rusto_version() != 27087:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+
+# A ctypes library to expose the extern-C FFI definitions.
+# This is an implementation detail which will be called internally by the public API.
+
+_UniffiLib = _uniffi_load_indirect()
+_UniffiLib.ffi_rusto_rustbuffer_alloc.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.ffi_rusto_rustbuffer_alloc.restype = _UniffiRustBuffer
+_UniffiLib.ffi_rusto_rustbuffer_from_bytes.argtypes = (
+    _UniffiForeignBytes,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.ffi_rusto_rustbuffer_from_bytes.restype = _UniffiRustBuffer
+_UniffiLib.ffi_rusto_rustbuffer_free.argtypes = (
+    _UniffiRustBuffer,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.ffi_rusto_rustbuffer_free.restype = None
+_UniffiLib.ffi_rusto_rustbuffer_reserve.argtypes = (
+    _UniffiRustBuffer,
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.ffi_rusto_rustbuffer_reserve.restype = _UniffiRustBuffer
+_UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK = ctypes.CFUNCTYPE(None,ctypes.c_uint64,ctypes.c_int8,
+)
+_UNIFFI_FOREIGN_FUTURE_DROPPED_CALLBACK = ctypes.CFUNCTYPE(None,ctypes.c_uint64,
+)
+class _UniffiForeignFutureDroppedCallbackStruct(ctypes.Structure):
+    _fields_ = [
+        ("handle", ctypes.c_uint64),
+        ("free", _UNIFFI_FOREIGN_FUTURE_DROPPED_CALLBACK),
+    ]
+_UniffiLib.ffi_rusto_rust_future_poll_u8.argtypes = (
+    ctypes.c_uint64,
+    _UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_rusto_rust_future_poll_u8.restype = None
+_UniffiLib.ffi_rusto_rust_future_cancel_u8.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_rusto_rust_future_cancel_u8.restype = None
+_UniffiLib.ffi_rusto_rust_future_complete_u8.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.ffi_rusto_rust_future_complete_u8.restype = ctypes.c_uint8
+_UniffiLib.ffi_rusto_rust_future_free_u8.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_rusto_rust_future_free_u8.restype = None
+_UniffiLib.ffi_rusto_rust_future_poll_i8.argtypes = (
+    ctypes.c_uint64,
+    _UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_rusto_rust_future_poll_i8.restype = None
+_UniffiLib.ffi_rusto_rust_future_cancel_i8.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_rusto_rust_future_cancel_i8.restype = None
+_UniffiLib.ffi_rusto_rust_future_complete_i8.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.ffi_rusto_rust_future_complete_i8.restype = ctypes.c_int8
+_UniffiLib.ffi_rusto_rust_future_free_i8.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_rusto_rust_future_free_i8.restype = None
+_UniffiLib.ffi_rusto_rust_future_poll_u16.argtypes = (
+    ctypes.c_uint64,
+    _UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_rusto_rust_future_poll_u16.restype = None
+_UniffiLib.ffi_rusto_rust_future_cancel_u16.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_rusto_rust_future_cancel_u16.restype = None
+_UniffiLib.ffi_rusto_rust_future_complete_u16.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.ffi_rusto_rust_future_complete_u16.restype = ctypes.c_uint16
+_UniffiLib.ffi_rusto_rust_future_free_u16.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_rusto_rust_future_free_u16.restype = None
+_UniffiLib.ffi_rusto_rust_future_poll_i16.argtypes = (
+    ctypes.c_uint64,
+    _UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_rusto_rust_future_poll_i16.restype = None
+_UniffiLib.ffi_rusto_rust_future_cancel_i16.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_rusto_rust_future_cancel_i16.restype = None
+_UniffiLib.ffi_rusto_rust_future_complete_i16.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.ffi_rusto_rust_future_complete_i16.restype = ctypes.c_int16
+_UniffiLib.ffi_rusto_rust_future_free_i16.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_rusto_rust_future_free_i16.restype = None
+_UniffiLib.ffi_rusto_rust_future_poll_u32.argtypes = (
+    ctypes.c_uint64,
+    _UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_rusto_rust_future_poll_u32.restype = None
+_UniffiLib.ffi_rusto_rust_future_cancel_u32.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_rusto_rust_future_cancel_u32.restype = None
+_UniffiLib.ffi_rusto_rust_future_complete_u32.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.ffi_rusto_rust_future_complete_u32.restype = ctypes.c_uint32
+_UniffiLib.ffi_rusto_rust_future_free_u32.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_rusto_rust_future_free_u32.restype = None
+_UniffiLib.ffi_rusto_rust_future_poll_i32.argtypes = (
+    ctypes.c_uint64,
+    _UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_rusto_rust_future_poll_i32.restype = None
+_UniffiLib.ffi_rusto_rust_future_cancel_i32.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_rusto_rust_future_cancel_i32.restype = None
+_UniffiLib.ffi_rusto_rust_future_complete_i32.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.ffi_rusto_rust_future_complete_i32.restype = ctypes.c_int32
+_UniffiLib.ffi_rusto_rust_future_free_i32.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_rusto_rust_future_free_i32.restype = None
+_UniffiLib.ffi_rusto_rust_future_poll_u64.argtypes = (
+    ctypes.c_uint64,
+    _UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_rusto_rust_future_poll_u64.restype = None
+_UniffiLib.ffi_rusto_rust_future_cancel_u64.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_rusto_rust_future_cancel_u64.restype = None
+_UniffiLib.ffi_rusto_rust_future_complete_u64.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.ffi_rusto_rust_future_complete_u64.restype = ctypes.c_uint64
+_UniffiLib.ffi_rusto_rust_future_free_u64.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_rusto_rust_future_free_u64.restype = None
+_UniffiLib.ffi_rusto_rust_future_poll_i64.argtypes = (
+    ctypes.c_uint64,
+    _UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_rusto_rust_future_poll_i64.restype = None
+_UniffiLib.ffi_rusto_rust_future_cancel_i64.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_rusto_rust_future_cancel_i64.restype = None
+_UniffiLib.ffi_rusto_rust_future_complete_i64.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.ffi_rusto_rust_future_complete_i64.restype = ctypes.c_int64
+_UniffiLib.ffi_rusto_rust_future_free_i64.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_rusto_rust_future_free_i64.restype = None
+_UniffiLib.ffi_rusto_rust_future_poll_f32.argtypes = (
+    ctypes.c_uint64,
+    _UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_rusto_rust_future_poll_f32.restype = None
+_UniffiLib.ffi_rusto_rust_future_cancel_f32.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_rusto_rust_future_cancel_f32.restype = None
+_UniffiLib.ffi_rusto_rust_future_complete_f32.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.ffi_rusto_rust_future_complete_f32.restype = ctypes.c_float
+_UniffiLib.ffi_rusto_rust_future_free_f32.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_rusto_rust_future_free_f32.restype = None
+_UniffiLib.ffi_rusto_rust_future_poll_f64.argtypes = (
+    ctypes.c_uint64,
+    _UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_rusto_rust_future_poll_f64.restype = None
+_UniffiLib.ffi_rusto_rust_future_cancel_f64.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_rusto_rust_future_cancel_f64.restype = None
+_UniffiLib.ffi_rusto_rust_future_complete_f64.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.ffi_rusto_rust_future_complete_f64.restype = ctypes.c_double
+_UniffiLib.ffi_rusto_rust_future_free_f64.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_rusto_rust_future_free_f64.restype = None
+_UniffiLib.ffi_rusto_rust_future_poll_rust_buffer.argtypes = (
+    ctypes.c_uint64,
+    _UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_rusto_rust_future_poll_rust_buffer.restype = None
+_UniffiLib.ffi_rusto_rust_future_cancel_rust_buffer.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_rusto_rust_future_cancel_rust_buffer.restype = None
+_UniffiLib.ffi_rusto_rust_future_complete_rust_buffer.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.ffi_rusto_rust_future_complete_rust_buffer.restype = _UniffiRustBuffer
+_UniffiLib.ffi_rusto_rust_future_free_rust_buffer.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_rusto_rust_future_free_rust_buffer.restype = None
+_UniffiLib.ffi_rusto_rust_future_poll_void.argtypes = (
+    ctypes.c_uint64,
+    _UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_rusto_rust_future_poll_void.restype = None
+_UniffiLib.ffi_rusto_rust_future_cancel_void.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_rusto_rust_future_cancel_void.restype = None
+_UniffiLib.ffi_rusto_rust_future_complete_void.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.ffi_rusto_rust_future_complete_void.restype = None
+_UniffiLib.ffi_rusto_rust_future_free_void.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_rusto_rust_future_free_void.restype = None
+_UniffiLib.uniffi_rusto_fn_clone_rusto.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_rusto_fn_clone_rusto.restype = ctypes.c_uint64
+_UniffiLib.uniffi_rusto_fn_free_rusto.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_rusto_fn_free_rusto.restype = None
+_UniffiLib.uniffi_rusto_fn_func_create_initialize_config_ppv6.argtypes = (
+    _UniffiRustBuffer,
+    _UniffiRustBuffer,
+    _UniffiRustBuffer,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_rusto_fn_func_create_initialize_config_ppv6.restype = _UniffiRustBuffer
+_UniffiLib.uniffi_rusto_fn_func_default_ocr_run_options.argtypes = (
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_rusto_fn_func_default_ocr_run_options.restype = _UniffiRustBuffer
+_UniffiLib.uniffi_rusto_fn_func_rusto_version.argtypes = (
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_rusto_fn_func_rusto_version.restype = _UniffiRustBuffer
+_UniffiLib.uniffi_rusto_fn_constructor_rusto_initialize.argtypes = (
+    _UniffiRustBuffer,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_rusto_fn_constructor_rusto_initialize.restype = ctypes.c_uint64
+_UniffiLib.uniffi_rusto_fn_constructor_rusto_initialize_from_json.argtypes = (
+    _UniffiRustBuffer,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_rusto_fn_constructor_rusto_initialize_from_json.restype = ctypes.c_uint64
+_UniffiLib.uniffi_rusto_fn_method_rusto_detect_text.argtypes = (
+    ctypes.c_uint64,
+    _UniffiRustBuffer,
+    _UniffiRustBuffer,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_rusto_fn_method_rusto_detect_text.restype = _UniffiRustBuffer
+_UniffiLib.uniffi_rusto_fn_method_rusto_detect_text_rgb.argtypes = (
+    ctypes.c_uint64,
+    _UniffiRustBuffer,
+    ctypes.c_uint32,
+    ctypes.c_uint32,
+    ctypes.c_uint64,
+    _UniffiRustBuffer,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_rusto_fn_method_rusto_detect_text_rgb.restype = _UniffiRustBuffer
+_UniffiLib.uniffi_rusto_fn_method_rusto_version.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_rusto_fn_method_rusto_version.restype = _UniffiRustBuffer
+_UniffiLib.ffi_rusto_uniffi_contract_version.argtypes = (
+)
+_UniffiLib.ffi_rusto_uniffi_contract_version.restype = ctypes.c_uint32
+_UniffiLib.uniffi_rusto_checksum_func_create_initialize_config_ppv6.argtypes = (
+)
+_UniffiLib.uniffi_rusto_checksum_func_create_initialize_config_ppv6.restype = ctypes.c_uint16
+_UniffiLib.uniffi_rusto_checksum_func_default_ocr_run_options.argtypes = (
+)
+_UniffiLib.uniffi_rusto_checksum_func_default_ocr_run_options.restype = ctypes.c_uint16
+_UniffiLib.uniffi_rusto_checksum_func_rusto_version.argtypes = (
+)
+_UniffiLib.uniffi_rusto_checksum_func_rusto_version.restype = ctypes.c_uint16
+_UniffiLib.uniffi_rusto_checksum_constructor_rusto_initialize.argtypes = (
+)
+_UniffiLib.uniffi_rusto_checksum_constructor_rusto_initialize.restype = ctypes.c_uint16
+_UniffiLib.uniffi_rusto_checksum_constructor_rusto_initialize_from_json.argtypes = (
+)
+_UniffiLib.uniffi_rusto_checksum_constructor_rusto_initialize_from_json.restype = ctypes.c_uint16
+_UniffiLib.uniffi_rusto_checksum_method_rusto_detect_text.argtypes = (
+)
+_UniffiLib.uniffi_rusto_checksum_method_rusto_detect_text.restype = ctypes.c_uint16
+_UniffiLib.uniffi_rusto_checksum_method_rusto_detect_text_rgb.argtypes = (
+)
+_UniffiLib.uniffi_rusto_checksum_method_rusto_detect_text_rgb.restype = ctypes.c_uint16
+_UniffiLib.uniffi_rusto_checksum_method_rusto_version.argtypes = (
+)
+_UniffiLib.uniffi_rusto_checksum_method_rusto_version.restype = ctypes.c_uint16
+
+_uniffi_check_contract_api_version(_UniffiLib)
+# _uniffi_check_api_checksums(_UniffiLib)
+
+
+
+# Public interface members begin here.
+
+
+class _UniffiFfiConverterFloat32(_UniffiConverterPrimitiveFloat):
+    @staticmethod
+    def read(buf):
+        return buf.read_float()
+
+    @staticmethod
+    def write(value, buf):
+        buf.write_float(value)
+
+class _UniffiFfiConverterOptionalFloat32(_UniffiConverterRustBuffer):
+    @classmethod
+    def check_lower(cls, value):
+        if value is not None:
+            _UniffiFfiConverterFloat32.check_lower(value)
+
+    @classmethod
+    def write(cls, value, buf):
+        if value is None:
+            buf.write_u8(0)
+            return
+
+        buf.write_u8(1)
+        _UniffiFfiConverterFloat32.write(value, buf)
+
+    @classmethod
+    def read(cls, buf):
+        flag = buf.read_u8()
+        if flag == 0:
+            return None
+        elif flag == 1:
+            return _UniffiFfiConverterFloat32.read(buf)
+        else:
+            raise InternalError("Unexpected flag byte for optional type")
+
+@dataclass
+class CalibrationOptions:
+    def __init__(self, *, descreen_strength:typing.Optional[float]):
+        self.descreen_strength = descreen_strength
+        
+        
+
+    
+    def __str__(self):
+        return "CalibrationOptions(descreen_strength={})".format(self.descreen_strength)
+    def __eq__(self, other):
+        if self.descreen_strength != other.descreen_strength:
+            return False
+        return True
+
+class _UniffiFfiConverterTypeCalibrationOptions(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        return CalibrationOptions(
+            descreen_strength=_UniffiFfiConverterOptionalFloat32.read(buf),
+        )
+
+    @staticmethod
+    def check_lower(value):
+        _UniffiFfiConverterOptionalFloat32.check_lower(value.descreen_strength)
+
+    @staticmethod
+    def write(value, buf):
+        _UniffiFfiConverterOptionalFloat32.write(value.descreen_strength, buf)
+
+class _UniffiFfiConverterBoolean:
+    @classmethod
+    def check_lower(cls, value):
+        return not not value
+
+    @classmethod
+    def lower(cls, value):
+        return 1 if value else 0
+
+    @staticmethod
+    def lift(value):
+        return value != 0
+
+    @classmethod
+    def read(cls, buf):
+        return cls.lift(buf.read_u8())
+
+    @classmethod
+    def write(cls, value, buf):
+        buf.write_u8(value)
+
+class _UniffiFfiConverterOptionalBoolean(_UniffiConverterRustBuffer):
+    @classmethod
+    def check_lower(cls, value):
+        if value is not None:
+            _UniffiFfiConverterBoolean.check_lower(value)
+
+    @classmethod
+    def write(cls, value, buf):
+        if value is None:
+            buf.write_u8(0)
+            return
+
+        buf.write_u8(1)
+        _UniffiFfiConverterBoolean.write(value, buf)
+
+    @classmethod
+    def read(cls, buf):
+        flag = buf.read_u8()
+        if flag == 0:
+            return None
+        elif flag == 1:
+            return _UniffiFfiConverterBoolean.read(buf)
+        else:
+            raise InternalError("Unexpected flag byte for optional type")
+
+class _UniffiFfiConverterString:
+    @staticmethod
+    def check_lower(value):
+        if not isinstance(value, str):
+            raise TypeError("argument must be str, not {}".format(type(value).__name__))
+        return value
+
+    @staticmethod
+    def read(buf):
+        size = buf.read_i32()
+        if size < 0:
+            raise InternalError("Unexpected negative string length")
+        utf8_bytes = buf.read(size)
+        return utf8_bytes.decode("utf-8")
+
+    @staticmethod
+    def write(value, buf):
+        utf8_bytes = value.encode("utf-8")
+        buf.write_i32(len(utf8_bytes))
+        buf.write(utf8_bytes)
+
+    @staticmethod
+    def lift(buf):
+        with buf.consume_with_stream() as stream:
+            return stream.read(stream.remaining()).decode("utf-8")
+
+    @staticmethod
+    def lower(value):
+        with _UniffiRustBuffer.alloc_with_builder() as builder:
+            builder.write(value.encode("utf-8"))
+            return builder.finalize()
+
+class _UniffiFfiConverterOptionalString(_UniffiConverterRustBuffer):
+    @classmethod
+    def check_lower(cls, value):
+        if value is not None:
+            _UniffiFfiConverterString.check_lower(value)
+
+    @classmethod
+    def write(cls, value, buf):
+        if value is None:
+            buf.write_u8(0)
+            return
+
+        buf.write_u8(1)
+        _UniffiFfiConverterString.write(value, buf)
+
+    @classmethod
+    def read(cls, buf):
+        flag = buf.read_u8()
+        if flag == 0:
+            return None
+        elif flag == 1:
+            return _UniffiFfiConverterString.read(buf)
+        else:
+            raise InternalError("Unexpected flag byte for optional type")
+
+@dataclass
+class ClassificationConfig:
+    def __init__(self, *, enabled:typing.Optional[bool], model_path:typing.Optional[str], thresh:typing.Optional[float]):
+        self.enabled = enabled
+        self.model_path = model_path
+        self.thresh = thresh
+        
+        
+
+    
+    def __str__(self):
+        return "ClassificationConfig(enabled={}, model_path={}, thresh={})".format(self.enabled, self.model_path, self.thresh)
+    def __eq__(self, other):
+        if self.enabled != other.enabled:
+            return False
+        if self.model_path != other.model_path:
+            return False
+        if self.thresh != other.thresh:
+            return False
+        return True
+
+class _UniffiFfiConverterTypeClassificationConfig(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        return ClassificationConfig(
+            enabled=_UniffiFfiConverterOptionalBoolean.read(buf),
+            model_path=_UniffiFfiConverterOptionalString.read(buf),
+            thresh=_UniffiFfiConverterOptionalFloat32.read(buf),
+        )
+
+    @staticmethod
+    def check_lower(value):
+        _UniffiFfiConverterOptionalBoolean.check_lower(value.enabled)
+        _UniffiFfiConverterOptionalString.check_lower(value.model_path)
+        _UniffiFfiConverterOptionalFloat32.check_lower(value.thresh)
+
+    @staticmethod
+    def write(value, buf):
+        _UniffiFfiConverterOptionalBoolean.write(value.enabled, buf)
+        _UniffiFfiConverterOptionalString.write(value.model_path, buf)
+        _UniffiFfiConverterOptionalFloat32.write(value.thresh, buf)
+
+class _UniffiFfiConverterInt32(_UniffiConverterPrimitiveInt):
+    CLASS_NAME = "i32"
+    VALUE_MIN = -2**31
+    VALUE_MAX = 2**31
+
+    @staticmethod
+    def read(buf):
+        return buf.read_i32()
+
+    @staticmethod
+    def write(value, buf):
+        buf.write_i32(value)
+
+class _UniffiFfiConverterOptionalInt32(_UniffiConverterRustBuffer):
+    @classmethod
+    def check_lower(cls, value):
+        if value is not None:
+            _UniffiFfiConverterInt32.check_lower(value)
+
+    @classmethod
+    def write(cls, value, buf):
+        if value is None:
+            buf.write_u8(0)
+            return
+
+        buf.write_u8(1)
+        _UniffiFfiConverterInt32.write(value, buf)
+
+    @classmethod
+    def read(cls, buf):
+        flag = buf.read_u8()
+        if flag == 0:
+            return None
+        elif flag == 1:
+            return _UniffiFfiConverterInt32.read(buf)
+        else:
+            raise InternalError("Unexpected flag byte for optional type")
+
+@dataclass
+class DetectionConfig:
+    def __init__(self, *, enabled:typing.Optional[bool], model_path:typing.Optional[str], thresh:typing.Optional[float], box_thresh:typing.Optional[float], unclip_ratio:typing.Optional[float], limit_side_len:typing.Optional[int], limit_type:typing.Optional[str], use_dilation:typing.Optional[bool]):
+        self.enabled = enabled
+        self.model_path = model_path
+        self.thresh = thresh
+        self.box_thresh = box_thresh
+        self.unclip_ratio = unclip_ratio
+        self.limit_side_len = limit_side_len
+        self.limit_type = limit_type
+        self.use_dilation = use_dilation
+        
+        
+
+    
+    def __str__(self):
+        return "DetectionConfig(enabled={}, model_path={}, thresh={}, box_thresh={}, unclip_ratio={}, limit_side_len={}, limit_type={}, use_dilation={})".format(self.enabled, self.model_path, self.thresh, self.box_thresh, self.unclip_ratio, self.limit_side_len, self.limit_type, self.use_dilation)
+    def __eq__(self, other):
+        if self.enabled != other.enabled:
+            return False
+        if self.model_path != other.model_path:
+            return False
+        if self.thresh != other.thresh:
+            return False
+        if self.box_thresh != other.box_thresh:
+            return False
+        if self.unclip_ratio != other.unclip_ratio:
+            return False
+        if self.limit_side_len != other.limit_side_len:
+            return False
+        if self.limit_type != other.limit_type:
+            return False
+        if self.use_dilation != other.use_dilation:
+            return False
+        return True
+
+class _UniffiFfiConverterTypeDetectionConfig(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        return DetectionConfig(
+            enabled=_UniffiFfiConverterOptionalBoolean.read(buf),
+            model_path=_UniffiFfiConverterOptionalString.read(buf),
+            thresh=_UniffiFfiConverterOptionalFloat32.read(buf),
+            box_thresh=_UniffiFfiConverterOptionalFloat32.read(buf),
+            unclip_ratio=_UniffiFfiConverterOptionalFloat32.read(buf),
+            limit_side_len=_UniffiFfiConverterOptionalInt32.read(buf),
+            limit_type=_UniffiFfiConverterOptionalString.read(buf),
+            use_dilation=_UniffiFfiConverterOptionalBoolean.read(buf),
+        )
+
+    @staticmethod
+    def check_lower(value):
+        _UniffiFfiConverterOptionalBoolean.check_lower(value.enabled)
+        _UniffiFfiConverterOptionalString.check_lower(value.model_path)
+        _UniffiFfiConverterOptionalFloat32.check_lower(value.thresh)
+        _UniffiFfiConverterOptionalFloat32.check_lower(value.box_thresh)
+        _UniffiFfiConverterOptionalFloat32.check_lower(value.unclip_ratio)
+        _UniffiFfiConverterOptionalInt32.check_lower(value.limit_side_len)
+        _UniffiFfiConverterOptionalString.check_lower(value.limit_type)
+        _UniffiFfiConverterOptionalBoolean.check_lower(value.use_dilation)
+
+    @staticmethod
+    def write(value, buf):
+        _UniffiFfiConverterOptionalBoolean.write(value.enabled, buf)
+        _UniffiFfiConverterOptionalString.write(value.model_path, buf)
+        _UniffiFfiConverterOptionalFloat32.write(value.thresh, buf)
+        _UniffiFfiConverterOptionalFloat32.write(value.box_thresh, buf)
+        _UniffiFfiConverterOptionalFloat32.write(value.unclip_ratio, buf)
+        _UniffiFfiConverterOptionalInt32.write(value.limit_side_len, buf)
+        _UniffiFfiConverterOptionalString.write(value.limit_type, buf)
+        _UniffiFfiConverterOptionalBoolean.write(value.use_dilation, buf)
+
+class _UniffiFfiConverterSequenceFloat32(_UniffiConverterRustBuffer):
+    @classmethod
+    def check_lower(cls, value):
+        for item in value:
+            _UniffiFfiConverterFloat32.check_lower(item)
+
+    @classmethod
+    def write(cls, value, buf):
+        items = len(value)
+        buf.write_i32(items)
+        for item in value:
+            _UniffiFfiConverterFloat32.write(item, buf)
+
+    @classmethod
+    def read(cls, buf):
+        count = buf.read_i32()
+        if count < 0:
+            raise InternalError("Unexpected negative sequence length")
+
+        return [
+            _UniffiFfiConverterFloat32.read(buf) for i in range(count)
+        ]
+
+class _UniffiFfiConverterOptionalSequenceFloat32(_UniffiConverterRustBuffer):
+    @classmethod
+    def check_lower(cls, value):
+        if value is not None:
+            _UniffiFfiConverterSequenceFloat32.check_lower(value)
+
+    @classmethod
+    def write(cls, value, buf):
+        if value is None:
+            buf.write_u8(0)
+            return
+
+        buf.write_u8(1)
+        _UniffiFfiConverterSequenceFloat32.write(value, buf)
+
+    @classmethod
+    def read(cls, buf):
+        flag = buf.read_u8()
+        if flag == 0:
+            return None
+        elif flag == 1:
+            return _UniffiFfiConverterSequenceFloat32.read(buf)
+        else:
+            raise InternalError("Unexpected flag byte for optional type")
+
+@dataclass
+class PostprocessRunOptions:
+    def __init__(self, *, threshold:typing.Optional[float], box_threshold:typing.Optional[float], max_candidates:typing.Optional[int], unclip_ratio:typing.Optional[float], use_dilation:typing.Optional[bool]):
+        self.threshold = threshold
+        self.box_threshold = box_threshold
+        self.max_candidates = max_candidates
+        self.unclip_ratio = unclip_ratio
+        self.use_dilation = use_dilation
+        
+        
+
+    
+    def __str__(self):
+        return "PostprocessRunOptions(threshold={}, box_threshold={}, max_candidates={}, unclip_ratio={}, use_dilation={})".format(self.threshold, self.box_threshold, self.max_candidates, self.unclip_ratio, self.use_dilation)
+    def __eq__(self, other):
+        if self.threshold != other.threshold:
+            return False
+        if self.box_threshold != other.box_threshold:
+            return False
+        if self.max_candidates != other.max_candidates:
+            return False
+        if self.unclip_ratio != other.unclip_ratio:
+            return False
+        if self.use_dilation != other.use_dilation:
+            return False
+        return True
+
+class _UniffiFfiConverterTypePostprocessRunOptions(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        return PostprocessRunOptions(
+            threshold=_UniffiFfiConverterOptionalFloat32.read(buf),
+            box_threshold=_UniffiFfiConverterOptionalFloat32.read(buf),
+            max_candidates=_UniffiFfiConverterOptionalInt32.read(buf),
+            unclip_ratio=_UniffiFfiConverterOptionalFloat32.read(buf),
+            use_dilation=_UniffiFfiConverterOptionalBoolean.read(buf),
+        )
+
+    @staticmethod
+    def check_lower(value):
+        _UniffiFfiConverterOptionalFloat32.check_lower(value.threshold)
+        _UniffiFfiConverterOptionalFloat32.check_lower(value.box_threshold)
+        _UniffiFfiConverterOptionalInt32.check_lower(value.max_candidates)
+        _UniffiFfiConverterOptionalFloat32.check_lower(value.unclip_ratio)
+        _UniffiFfiConverterOptionalBoolean.check_lower(value.use_dilation)
+
+    @staticmethod
+    def write(value, buf):
+        _UniffiFfiConverterOptionalFloat32.write(value.threshold, buf)
+        _UniffiFfiConverterOptionalFloat32.write(value.box_threshold, buf)
+        _UniffiFfiConverterOptionalInt32.write(value.max_candidates, buf)
+        _UniffiFfiConverterOptionalFloat32.write(value.unclip_ratio, buf)
+        _UniffiFfiConverterOptionalBoolean.write(value.use_dilation, buf)
+
+class _UniffiFfiConverterOptionalTypePostprocessRunOptions(_UniffiConverterRustBuffer):
+    @classmethod
+    def check_lower(cls, value):
+        if value is not None:
+            _UniffiFfiConverterTypePostprocessRunOptions.check_lower(value)
+
+    @classmethod
+    def write(cls, value, buf):
+        if value is None:
+            buf.write_u8(0)
+            return
+
+        buf.write_u8(1)
+        _UniffiFfiConverterTypePostprocessRunOptions.write(value, buf)
+
+    @classmethod
+    def read(cls, buf):
+        flag = buf.read_u8()
+        if flag == 0:
+            return None
+        elif flag == 1:
+            return _UniffiFfiConverterTypePostprocessRunOptions.read(buf)
+        else:
+            raise InternalError("Unexpected flag byte for optional type")
+
+@dataclass
+class DetectionRunOptions:
+    def __init__(self, *, limit_side_len:typing.Optional[int], limit_type:typing.Optional[str], mean:typing.Optional[typing.List[float]], std:typing.Optional[typing.List[float]], postprocess:typing.Optional[PostprocessRunOptions]):
+        self.limit_side_len = limit_side_len
+        self.limit_type = limit_type
+        self.mean = mean
+        self.std = std
+        self.postprocess = postprocess
+        
+        
+
+    
+    def __str__(self):
+        return "DetectionRunOptions(limit_side_len={}, limit_type={}, mean={}, std={}, postprocess={})".format(self.limit_side_len, self.limit_type, self.mean, self.std, self.postprocess)
+    def __eq__(self, other):
+        if self.limit_side_len != other.limit_side_len:
+            return False
+        if self.limit_type != other.limit_type:
+            return False
+        if self.mean != other.mean:
+            return False
+        if self.std != other.std:
+            return False
+        if self.postprocess != other.postprocess:
+            return False
+        return True
+
+class _UniffiFfiConverterTypeDetectionRunOptions(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        return DetectionRunOptions(
+            limit_side_len=_UniffiFfiConverterOptionalInt32.read(buf),
+            limit_type=_UniffiFfiConverterOptionalString.read(buf),
+            mean=_UniffiFfiConverterOptionalSequenceFloat32.read(buf),
+            std=_UniffiFfiConverterOptionalSequenceFloat32.read(buf),
+            postprocess=_UniffiFfiConverterOptionalTypePostprocessRunOptions.read(buf),
+        )
+
+    @staticmethod
+    def check_lower(value):
+        _UniffiFfiConverterOptionalInt32.check_lower(value.limit_side_len)
+        _UniffiFfiConverterOptionalString.check_lower(value.limit_type)
+        _UniffiFfiConverterOptionalSequenceFloat32.check_lower(value.mean)
+        _UniffiFfiConverterOptionalSequenceFloat32.check_lower(value.std)
+        _UniffiFfiConverterOptionalTypePostprocessRunOptions.check_lower(value.postprocess)
+
+    @staticmethod
+    def write(value, buf):
+        _UniffiFfiConverterOptionalInt32.write(value.limit_side_len, buf)
+        _UniffiFfiConverterOptionalString.write(value.limit_type, buf)
+        _UniffiFfiConverterOptionalSequenceFloat32.write(value.mean, buf)
+        _UniffiFfiConverterOptionalSequenceFloat32.write(value.std, buf)
+        _UniffiFfiConverterOptionalTypePostprocessRunOptions.write(value.postprocess, buf)
+
+@dataclass
+class Frame:
+    def __init__(self, *, width:float, height:float, top:float, left:float):
+        self.width = width
+        self.height = height
+        self.top = top
+        self.left = left
+        
+        
+
+    
+    def __str__(self):
+        return "Frame(width={}, height={}, top={}, left={})".format(self.width, self.height, self.top, self.left)
+    def __eq__(self, other):
+        if self.width != other.width:
+            return False
+        if self.height != other.height:
+            return False
+        if self.top != other.top:
+            return False
+        if self.left != other.left:
+            return False
+        return True
+
+class _UniffiFfiConverterTypeFrame(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        return Frame(
+            width=_UniffiFfiConverterFloat32.read(buf),
+            height=_UniffiFfiConverterFloat32.read(buf),
+            top=_UniffiFfiConverterFloat32.read(buf),
+            left=_UniffiFfiConverterFloat32.read(buf),
+        )
+
+    @staticmethod
+    def check_lower(value):
+        _UniffiFfiConverterFloat32.check_lower(value.width)
+        _UniffiFfiConverterFloat32.check_lower(value.height)
+        _UniffiFfiConverterFloat32.check_lower(value.top)
+        _UniffiFfiConverterFloat32.check_lower(value.left)
+
+    @staticmethod
+    def write(value, buf):
+        _UniffiFfiConverterFloat32.write(value.width, buf)
+        _UniffiFfiConverterFloat32.write(value.height, buf)
+        _UniffiFfiConverterFloat32.write(value.top, buf)
+        _UniffiFfiConverterFloat32.write(value.left, buf)
+
+class _UniffiFfiConverterOptionalTypeDetectionConfig(_UniffiConverterRustBuffer):
+    @classmethod
+    def check_lower(cls, value):
+        if value is not None:
+            _UniffiFfiConverterTypeDetectionConfig.check_lower(value)
+
+    @classmethod
+    def write(cls, value, buf):
+        if value is None:
+            buf.write_u8(0)
+            return
+
+        buf.write_u8(1)
+        _UniffiFfiConverterTypeDetectionConfig.write(value, buf)
+
+    @classmethod
+    def read(cls, buf):
+        flag = buf.read_u8()
+        if flag == 0:
+            return None
+        elif flag == 1:
+            return _UniffiFfiConverterTypeDetectionConfig.read(buf)
+        else:
+            raise InternalError("Unexpected flag byte for optional type")
+
+@dataclass
+class RecognitionConfig:
+    def __init__(self, *, enabled:typing.Optional[bool], model_path:typing.Optional[str], dict_path:typing.Optional[str]):
+        self.enabled = enabled
+        self.model_path = model_path
+        self.dict_path = dict_path
+        
+        
+
+    
+    def __str__(self):
+        return "RecognitionConfig(enabled={}, model_path={}, dict_path={})".format(self.enabled, self.model_path, self.dict_path)
+    def __eq__(self, other):
+        if self.enabled != other.enabled:
+            return False
+        if self.model_path != other.model_path:
+            return False
+        if self.dict_path != other.dict_path:
+            return False
+        return True
+
+class _UniffiFfiConverterTypeRecognitionConfig(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        return RecognitionConfig(
+            enabled=_UniffiFfiConverterOptionalBoolean.read(buf),
+            model_path=_UniffiFfiConverterOptionalString.read(buf),
+            dict_path=_UniffiFfiConverterOptionalString.read(buf),
+        )
+
+    @staticmethod
+    def check_lower(value):
+        _UniffiFfiConverterOptionalBoolean.check_lower(value.enabled)
+        _UniffiFfiConverterOptionalString.check_lower(value.model_path)
+        _UniffiFfiConverterOptionalString.check_lower(value.dict_path)
+
+    @staticmethod
+    def write(value, buf):
+        _UniffiFfiConverterOptionalBoolean.write(value.enabled, buf)
+        _UniffiFfiConverterOptionalString.write(value.model_path, buf)
+        _UniffiFfiConverterOptionalString.write(value.dict_path, buf)
+
+class _UniffiFfiConverterOptionalTypeRecognitionConfig(_UniffiConverterRustBuffer):
+    @classmethod
+    def check_lower(cls, value):
+        if value is not None:
+            _UniffiFfiConverterTypeRecognitionConfig.check_lower(value)
+
+    @classmethod
+    def write(cls, value, buf):
+        if value is None:
+            buf.write_u8(0)
+            return
+
+        buf.write_u8(1)
+        _UniffiFfiConverterTypeRecognitionConfig.write(value, buf)
+
+    @classmethod
+    def read(cls, buf):
+        flag = buf.read_u8()
+        if flag == 0:
+            return None
+        elif flag == 1:
+            return _UniffiFfiConverterTypeRecognitionConfig.read(buf)
+        else:
+            raise InternalError("Unexpected flag byte for optional type")
+
+class _UniffiFfiConverterOptionalTypeClassificationConfig(_UniffiConverterRustBuffer):
+    @classmethod
+    def check_lower(cls, value):
+        if value is not None:
+            _UniffiFfiConverterTypeClassificationConfig.check_lower(value)
+
+    @classmethod
+    def write(cls, value, buf):
+        if value is None:
+            buf.write_u8(0)
+            return
+
+        buf.write_u8(1)
+        _UniffiFfiConverterTypeClassificationConfig.write(value, buf)
+
+    @classmethod
+    def read(cls, buf):
+        flag = buf.read_u8()
+        if flag == 0:
+            return None
+        elif flag == 1:
+            return _UniffiFfiConverterTypeClassificationConfig.read(buf)
+        else:
+            raise InternalError("Unexpected flag byte for optional type")
+
+@dataclass
+class OrientationConfig:
+    def __init__(self, *, enabled:typing.Optional[bool], model_path:typing.Optional[str], thresh:typing.Optional[float]):
+        self.enabled = enabled
+        self.model_path = model_path
+        self.thresh = thresh
+        
+        
+
+    
+    def __str__(self):
+        return "OrientationConfig(enabled={}, model_path={}, thresh={})".format(self.enabled, self.model_path, self.thresh)
+    def __eq__(self, other):
+        if self.enabled != other.enabled:
+            return False
+        if self.model_path != other.model_path:
+            return False
+        if self.thresh != other.thresh:
+            return False
+        return True
+
+class _UniffiFfiConverterTypeOrientationConfig(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        return OrientationConfig(
+            enabled=_UniffiFfiConverterOptionalBoolean.read(buf),
+            model_path=_UniffiFfiConverterOptionalString.read(buf),
+            thresh=_UniffiFfiConverterOptionalFloat32.read(buf),
+        )
+
+    @staticmethod
+    def check_lower(value):
+        _UniffiFfiConverterOptionalBoolean.check_lower(value.enabled)
+        _UniffiFfiConverterOptionalString.check_lower(value.model_path)
+        _UniffiFfiConverterOptionalFloat32.check_lower(value.thresh)
+
+    @staticmethod
+    def write(value, buf):
+        _UniffiFfiConverterOptionalBoolean.write(value.enabled, buf)
+        _UniffiFfiConverterOptionalString.write(value.model_path, buf)
+        _UniffiFfiConverterOptionalFloat32.write(value.thresh, buf)
+
+class _UniffiFfiConverterOptionalTypeOrientationConfig(_UniffiConverterRustBuffer):
+    @classmethod
+    def check_lower(cls, value):
+        if value is not None:
+            _UniffiFfiConverterTypeOrientationConfig.check_lower(value)
+
+    @classmethod
+    def write(cls, value, buf):
+        if value is None:
+            buf.write_u8(0)
+            return
+
+        buf.write_u8(1)
+        _UniffiFfiConverterTypeOrientationConfig.write(value, buf)
+
+    @classmethod
+    def read(cls, buf):
+        flag = buf.read_u8()
+        if flag == 0:
+            return None
+        elif flag == 1:
+            return _UniffiFfiConverterTypeOrientationConfig.read(buf)
+        else:
+            raise InternalError("Unexpected flag byte for optional type")
+
+@dataclass
+class UnwarpConfig:
+    def __init__(self, *, enabled:typing.Optional[bool], model_path:typing.Optional[str]):
+        self.enabled = enabled
+        self.model_path = model_path
+        
+        
+
+    
+    def __str__(self):
+        return "UnwarpConfig(enabled={}, model_path={})".format(self.enabled, self.model_path)
+    def __eq__(self, other):
+        if self.enabled != other.enabled:
+            return False
+        if self.model_path != other.model_path:
+            return False
+        return True
+
+class _UniffiFfiConverterTypeUnwarpConfig(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        return UnwarpConfig(
+            enabled=_UniffiFfiConverterOptionalBoolean.read(buf),
+            model_path=_UniffiFfiConverterOptionalString.read(buf),
+        )
+
+    @staticmethod
+    def check_lower(value):
+        _UniffiFfiConverterOptionalBoolean.check_lower(value.enabled)
+        _UniffiFfiConverterOptionalString.check_lower(value.model_path)
+
+    @staticmethod
+    def write(value, buf):
+        _UniffiFfiConverterOptionalBoolean.write(value.enabled, buf)
+        _UniffiFfiConverterOptionalString.write(value.model_path, buf)
+
+class _UniffiFfiConverterOptionalTypeUnwarpConfig(_UniffiConverterRustBuffer):
+    @classmethod
+    def check_lower(cls, value):
+        if value is not None:
+            _UniffiFfiConverterTypeUnwarpConfig.check_lower(value)
+
+    @classmethod
+    def write(cls, value, buf):
+        if value is None:
+            buf.write_u8(0)
+            return
+
+        buf.write_u8(1)
+        _UniffiFfiConverterTypeUnwarpConfig.write(value, buf)
+
+    @classmethod
+    def read(cls, buf):
+        flag = buf.read_u8()
+        if flag == 0:
+            return None
+        elif flag == 1:
+            return _UniffiFfiConverterTypeUnwarpConfig.read(buf)
+        else:
+            raise InternalError("Unexpected flag byte for optional type")
+
+@dataclass
+class InitializeConfig:
+    def __init__(self, *, template:typing.Optional[str], detection:typing.Optional[DetectionConfig], recognition:typing.Optional[RecognitionConfig], classification:typing.Optional[ClassificationConfig], orientation:typing.Optional[OrientationConfig], unwarp:typing.Optional[UnwarpConfig]):
+        self.template = template
+        self.detection = detection
+        self.recognition = recognition
+        self.classification = classification
+        self.orientation = orientation
+        self.unwarp = unwarp
+        
+        
+
+    
+    def __str__(self):
+        return "InitializeConfig(template={}, detection={}, recognition={}, classification={}, orientation={}, unwarp={})".format(self.template, self.detection, self.recognition, self.classification, self.orientation, self.unwarp)
+    def __eq__(self, other):
+        if self.template != other.template:
+            return False
+        if self.detection != other.detection:
+            return False
+        if self.recognition != other.recognition:
+            return False
+        if self.classification != other.classification:
+            return False
+        if self.orientation != other.orientation:
+            return False
+        if self.unwarp != other.unwarp:
+            return False
+        return True
+
+class _UniffiFfiConverterTypeInitializeConfig(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        return InitializeConfig(
+            template=_UniffiFfiConverterOptionalString.read(buf),
+            detection=_UniffiFfiConverterOptionalTypeDetectionConfig.read(buf),
+            recognition=_UniffiFfiConverterOptionalTypeRecognitionConfig.read(buf),
+            classification=_UniffiFfiConverterOptionalTypeClassificationConfig.read(buf),
+            orientation=_UniffiFfiConverterOptionalTypeOrientationConfig.read(buf),
+            unwarp=_UniffiFfiConverterOptionalTypeUnwarpConfig.read(buf),
+        )
+
+    @staticmethod
+    def check_lower(value):
+        _UniffiFfiConverterOptionalString.check_lower(value.template)
+        _UniffiFfiConverterOptionalTypeDetectionConfig.check_lower(value.detection)
+        _UniffiFfiConverterOptionalTypeRecognitionConfig.check_lower(value.recognition)
+        _UniffiFfiConverterOptionalTypeClassificationConfig.check_lower(value.classification)
+        _UniffiFfiConverterOptionalTypeOrientationConfig.check_lower(value.orientation)
+        _UniffiFfiConverterOptionalTypeUnwarpConfig.check_lower(value.unwarp)
+
+    @staticmethod
+    def write(value, buf):
+        _UniffiFfiConverterOptionalString.write(value.template, buf)
+        _UniffiFfiConverterOptionalTypeDetectionConfig.write(value.detection, buf)
+        _UniffiFfiConverterOptionalTypeRecognitionConfig.write(value.recognition, buf)
+        _UniffiFfiConverterOptionalTypeClassificationConfig.write(value.classification, buf)
+        _UniffiFfiConverterOptionalTypeOrientationConfig.write(value.orientation, buf)
+        _UniffiFfiConverterOptionalTypeUnwarpConfig.write(value.unwarp, buf)
+
+
+
+
+
+
+class OutputGranularity(enum.Enum):
+    
+    LINES = 0
+    
+    WORDS = 1
+    
+    SPATIAL = 2
+    
+
+
+class _UniffiFfiConverterTypeOutputGranularity(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        variant = buf.read_i32()
+        if variant == 1:
+            return OutputGranularity.LINES
+        if variant == 2:
+            return OutputGranularity.WORDS
+        if variant == 3:
+            return OutputGranularity.SPATIAL
+        raise InternalError("Raw enum value doesn't match any cases")
+
+    @staticmethod
+    def check_lower(value):
+        if value == OutputGranularity.LINES:
+            return
+        if value == OutputGranularity.WORDS:
+            return
+        if value == OutputGranularity.SPATIAL:
+            return
+        raise ValueError(value)
+
+    @staticmethod
+    def write(value, buf):
+        if value == OutputGranularity.LINES:
+            buf.write_i32(1)
+        if value == OutputGranularity.WORDS:
+            buf.write_i32(2)
+        if value == OutputGranularity.SPATIAL:
+            buf.write_i32(3)
+
+
+
+class _UniffiFfiConverterOptionalTypeDetectionRunOptions(_UniffiConverterRustBuffer):
+    @classmethod
+    def check_lower(cls, value):
+        if value is not None:
+            _UniffiFfiConverterTypeDetectionRunOptions.check_lower(value)
+
+    @classmethod
+    def write(cls, value, buf):
+        if value is None:
+            buf.write_u8(0)
+            return
+
+        buf.write_u8(1)
+        _UniffiFfiConverterTypeDetectionRunOptions.write(value, buf)
+
+    @classmethod
+    def read(cls, buf):
+        flag = buf.read_u8()
+        if flag == 0:
+            return None
+        elif flag == 1:
+            return _UniffiFfiConverterTypeDetectionRunOptions.read(buf)
+        else:
+            raise InternalError("Unexpected flag byte for optional type")
+
+class _UniffiFfiConverterOptionalTypeCalibrationOptions(_UniffiConverterRustBuffer):
+    @classmethod
+    def check_lower(cls, value):
+        if value is not None:
+            _UniffiFfiConverterTypeCalibrationOptions.check_lower(value)
+
+    @classmethod
+    def write(cls, value, buf):
+        if value is None:
+            buf.write_u8(0)
+            return
+
+        buf.write_u8(1)
+        _UniffiFfiConverterTypeCalibrationOptions.write(value, buf)
+
+    @classmethod
+    def read(cls, buf):
+        flag = buf.read_u8()
+        if flag == 0:
+            return None
+        elif flag == 1:
+            return _UniffiFfiConverterTypeCalibrationOptions.read(buf)
+        else:
+            raise InternalError("Unexpected flag byte for optional type")
+
+@dataclass
+class OptimizationOptions:
+    def __init__(self, *, crop_padding_x:typing.Optional[float], crop_padding_y:typing.Optional[float]):
+        self.crop_padding_x = crop_padding_x
+        self.crop_padding_y = crop_padding_y
+        
+        
+
+    
+    def __str__(self):
+        return "OptimizationOptions(crop_padding_x={}, crop_padding_y={})".format(self.crop_padding_x, self.crop_padding_y)
+    def __eq__(self, other):
+        if self.crop_padding_x != other.crop_padding_x:
+            return False
+        if self.crop_padding_y != other.crop_padding_y:
+            return False
+        return True
+
+class _UniffiFfiConverterTypeOptimizationOptions(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        return OptimizationOptions(
+            crop_padding_x=_UniffiFfiConverterOptionalFloat32.read(buf),
+            crop_padding_y=_UniffiFfiConverterOptionalFloat32.read(buf),
+        )
+
+    @staticmethod
+    def check_lower(value):
+        _UniffiFfiConverterOptionalFloat32.check_lower(value.crop_padding_x)
+        _UniffiFfiConverterOptionalFloat32.check_lower(value.crop_padding_y)
+
+    @staticmethod
+    def write(value, buf):
+        _UniffiFfiConverterOptionalFloat32.write(value.crop_padding_x, buf)
+        _UniffiFfiConverterOptionalFloat32.write(value.crop_padding_y, buf)
+
+class _UniffiFfiConverterOptionalTypeOptimizationOptions(_UniffiConverterRustBuffer):
+    @classmethod
+    def check_lower(cls, value):
+        if value is not None:
+            _UniffiFfiConverterTypeOptimizationOptions.check_lower(value)
+
+    @classmethod
+    def write(cls, value, buf):
+        if value is None:
+            buf.write_u8(0)
+            return
+
+        buf.write_u8(1)
+        _UniffiFfiConverterTypeOptimizationOptions.write(value, buf)
+
+    @classmethod
+    def read(cls, buf):
+        flag = buf.read_u8()
+        if flag == 0:
+            return None
+        elif flag == 1:
+            return _UniffiFfiConverterTypeOptimizationOptions.read(buf)
+        else:
+            raise InternalError("Unexpected flag byte for optional type")
+
+@dataclass
+class OcrRunOptions:
+    def __init__(self, *, output:OutputGranularity, line_y_threshold:typing.Optional[float], word_x_threshold:typing.Optional[float], text_score:typing.Optional[float], classification:typing.Optional[bool], orientation:typing.Optional[bool], min_height:typing.Optional[float], max_side_len:typing.Optional[float], min_side_len:typing.Optional[float], width_height_ratio:typing.Optional[float], detection:typing.Optional[DetectionRunOptions], postprocess:typing.Optional[PostprocessRunOptions], calibration:typing.Optional[CalibrationOptions], optimization:typing.Optional[OptimizationOptions]):
+        self.output = output
+        self.line_y_threshold = line_y_threshold
+        self.word_x_threshold = word_x_threshold
+        self.text_score = text_score
+        self.classification = classification
+        self.orientation = orientation
+        self.min_height = min_height
+        self.max_side_len = max_side_len
+        self.min_side_len = min_side_len
+        self.width_height_ratio = width_height_ratio
+        self.detection = detection
+        self.postprocess = postprocess
+        self.calibration = calibration
+        self.optimization = optimization
+        
+        
+
+    
+    def __str__(self):
+        return "OcrRunOptions(output={}, line_y_threshold={}, word_x_threshold={}, text_score={}, classification={}, orientation={}, min_height={}, max_side_len={}, min_side_len={}, width_height_ratio={}, detection={}, postprocess={}, calibration={}, optimization={})".format(self.output, self.line_y_threshold, self.word_x_threshold, self.text_score, self.classification, self.orientation, self.min_height, self.max_side_len, self.min_side_len, self.width_height_ratio, self.detection, self.postprocess, self.calibration, self.optimization)
+    def __eq__(self, other):
+        if self.output != other.output:
+            return False
+        if self.line_y_threshold != other.line_y_threshold:
+            return False
+        if self.word_x_threshold != other.word_x_threshold:
+            return False
+        if self.text_score != other.text_score:
+            return False
+        if self.classification != other.classification:
+            return False
+        if self.orientation != other.orientation:
+            return False
+        if self.min_height != other.min_height:
+            return False
+        if self.max_side_len != other.max_side_len:
+            return False
+        if self.min_side_len != other.min_side_len:
+            return False
+        if self.width_height_ratio != other.width_height_ratio:
+            return False
+        if self.detection != other.detection:
+            return False
+        if self.postprocess != other.postprocess:
+            return False
+        if self.calibration != other.calibration:
+            return False
+        if self.optimization != other.optimization:
+            return False
+        return True
+
+class _UniffiFfiConverterTypeOcrRunOptions(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        return OcrRunOptions(
+            output=_UniffiFfiConverterTypeOutputGranularity.read(buf),
+            line_y_threshold=_UniffiFfiConverterOptionalFloat32.read(buf),
+            word_x_threshold=_UniffiFfiConverterOptionalFloat32.read(buf),
+            text_score=_UniffiFfiConverterOptionalFloat32.read(buf),
+            classification=_UniffiFfiConverterOptionalBoolean.read(buf),
+            orientation=_UniffiFfiConverterOptionalBoolean.read(buf),
+            min_height=_UniffiFfiConverterOptionalFloat32.read(buf),
+            max_side_len=_UniffiFfiConverterOptionalFloat32.read(buf),
+            min_side_len=_UniffiFfiConverterOptionalFloat32.read(buf),
+            width_height_ratio=_UniffiFfiConverterOptionalFloat32.read(buf),
+            detection=_UniffiFfiConverterOptionalTypeDetectionRunOptions.read(buf),
+            postprocess=_UniffiFfiConverterOptionalTypePostprocessRunOptions.read(buf),
+            calibration=_UniffiFfiConverterOptionalTypeCalibrationOptions.read(buf),
+            optimization=_UniffiFfiConverterOptionalTypeOptimizationOptions.read(buf),
+        )
+
+    @staticmethod
+    def check_lower(value):
+        _UniffiFfiConverterTypeOutputGranularity.check_lower(value.output)
+        _UniffiFfiConverterOptionalFloat32.check_lower(value.line_y_threshold)
+        _UniffiFfiConverterOptionalFloat32.check_lower(value.word_x_threshold)
+        _UniffiFfiConverterOptionalFloat32.check_lower(value.text_score)
+        _UniffiFfiConverterOptionalBoolean.check_lower(value.classification)
+        _UniffiFfiConverterOptionalBoolean.check_lower(value.orientation)
+        _UniffiFfiConverterOptionalFloat32.check_lower(value.min_height)
+        _UniffiFfiConverterOptionalFloat32.check_lower(value.max_side_len)
+        _UniffiFfiConverterOptionalFloat32.check_lower(value.min_side_len)
+        _UniffiFfiConverterOptionalFloat32.check_lower(value.width_height_ratio)
+        _UniffiFfiConverterOptionalTypeDetectionRunOptions.check_lower(value.detection)
+        _UniffiFfiConverterOptionalTypePostprocessRunOptions.check_lower(value.postprocess)
+        _UniffiFfiConverterOptionalTypeCalibrationOptions.check_lower(value.calibration)
+        _UniffiFfiConverterOptionalTypeOptimizationOptions.check_lower(value.optimization)
+
+    @staticmethod
+    def write(value, buf):
+        _UniffiFfiConverterTypeOutputGranularity.write(value.output, buf)
+        _UniffiFfiConverterOptionalFloat32.write(value.line_y_threshold, buf)
+        _UniffiFfiConverterOptionalFloat32.write(value.word_x_threshold, buf)
+        _UniffiFfiConverterOptionalFloat32.write(value.text_score, buf)
+        _UniffiFfiConverterOptionalBoolean.write(value.classification, buf)
+        _UniffiFfiConverterOptionalBoolean.write(value.orientation, buf)
+        _UniffiFfiConverterOptionalFloat32.write(value.min_height, buf)
+        _UniffiFfiConverterOptionalFloat32.write(value.max_side_len, buf)
+        _UniffiFfiConverterOptionalFloat32.write(value.min_side_len, buf)
+        _UniffiFfiConverterOptionalFloat32.write(value.width_height_ratio, buf)
+        _UniffiFfiConverterOptionalTypeDetectionRunOptions.write(value.detection, buf)
+        _UniffiFfiConverterOptionalTypePostprocessRunOptions.write(value.postprocess, buf)
+        _UniffiFfiConverterOptionalTypeCalibrationOptions.write(value.calibration, buf)
+        _UniffiFfiConverterOptionalTypeOptimizationOptions.write(value.optimization, buf)
+
+@dataclass
+class Point2D:
+    def __init__(self, *, x:float, y:float):
+        self.x = x
+        self.y = y
+        
+        
+
+    
+    def __str__(self):
+        return "Point2D(x={}, y={})".format(self.x, self.y)
+    def __eq__(self, other):
+        if self.x != other.x:
+            return False
+        if self.y != other.y:
+            return False
+        return True
+
+class _UniffiFfiConverterTypePoint2D(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        return Point2D(
+            x=_UniffiFfiConverterFloat32.read(buf),
+            y=_UniffiFfiConverterFloat32.read(buf),
+        )
+
+    @staticmethod
+    def check_lower(value):
+        _UniffiFfiConverterFloat32.check_lower(value.x)
+        _UniffiFfiConverterFloat32.check_lower(value.y)
+
+    @staticmethod
+    def write(value, buf):
+        _UniffiFfiConverterFloat32.write(value.x, buf)
+        _UniffiFfiConverterFloat32.write(value.y, buf)
+
+class _UniffiFfiConverterSequenceTypePoint2D(_UniffiConverterRustBuffer):
+    @classmethod
+    def check_lower(cls, value):
+        for item in value:
+            _UniffiFfiConverterTypePoint2D.check_lower(item)
+
+    @classmethod
+    def write(cls, value, buf):
+        items = len(value)
+        buf.write_i32(items)
+        for item in value:
+            _UniffiFfiConverterTypePoint2D.write(item, buf)
+
+    @classmethod
+    def read(cls, buf):
+        count = buf.read_i32()
+        if count < 0:
+            raise InternalError("Unexpected negative sequence length")
+
+        return [
+            _UniffiFfiConverterTypePoint2D.read(buf) for i in range(count)
+        ]
+
+@dataclass
+class TextResult:
+    def __init__(self, *, text:str, score:float, box_points:typing.List[Point2D], frame:Frame):
+        self.text = text
+        self.score = score
+        self.box_points = box_points
+        self.frame = frame
+        
+        
+
+    
+    def __str__(self):
+        return "TextResult(text={}, score={}, box_points={}, frame={})".format(self.text, self.score, self.box_points, self.frame)
+    def __eq__(self, other):
+        if self.text != other.text:
+            return False
+        if self.score != other.score:
+            return False
+        if self.box_points != other.box_points:
+            return False
+        if self.frame != other.frame:
+            return False
+        return True
+
+class _UniffiFfiConverterTypeTextResult(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        return TextResult(
+            text=_UniffiFfiConverterString.read(buf),
+            score=_UniffiFfiConverterFloat32.read(buf),
+            box_points=_UniffiFfiConverterSequenceTypePoint2D.read(buf),
+            frame=_UniffiFfiConverterTypeFrame.read(buf),
+        )
+
+    @staticmethod
+    def check_lower(value):
+        _UniffiFfiConverterString.check_lower(value.text)
+        _UniffiFfiConverterFloat32.check_lower(value.score)
+        _UniffiFfiConverterSequenceTypePoint2D.check_lower(value.box_points)
+        _UniffiFfiConverterTypeFrame.check_lower(value.frame)
+
+    @staticmethod
+    def write(value, buf):
+        _UniffiFfiConverterString.write(value.text, buf)
+        _UniffiFfiConverterFloat32.write(value.score, buf)
+        _UniffiFfiConverterSequenceTypePoint2D.write(value.box_points, buf)
+        _UniffiFfiConverterTypeFrame.write(value.frame, buf)
+
+class _UniffiFfiConverterSequenceTypeTextResult(_UniffiConverterRustBuffer):
+    @classmethod
+    def check_lower(cls, value):
+        for item in value:
+            _UniffiFfiConverterTypeTextResult.check_lower(item)
+
+    @classmethod
+    def write(cls, value, buf):
+        items = len(value)
+        buf.write_i32(items)
+        for item in value:
+            _UniffiFfiConverterTypeTextResult.write(item, buf)
+
+    @classmethod
+    def read(cls, buf):
+        count = buf.read_i32()
+        if count < 0:
+            raise InternalError("Unexpected negative sequence length")
+
+        return [
+            _UniffiFfiConverterTypeTextResult.read(buf) for i in range(count)
+        ]
+
+
+
+
+
+
+class DetectTextResult:
+    def __init__(self):
+        raise RuntimeError("DetectTextResult cannot be instantiated directly")
+
+    # Each enum variant is a nested class of the enum itself.
+    @dataclass
+    class STRUCTURED:
+        
+        def __init__(self, results:typing.List[TextResult]):
+            self.results = results
+            
+            
+            pass
+
+    
+            
+            
+    
+        def __str__(self):
+            return "DetectTextResult.STRUCTURED(results={})".format(self.results)
+        def __eq__(self, other):
+            if not isinstance(other, DetectTextResult):
+                return NotImplemented
+            if not other.is_STRUCTURED():
+                return False
+            if self.results != other.results:
+                return False
+            return True
+
+    @dataclass
+    class SPATIAL:
+        
+        def __init__(self, text:str):
+            self.text = text
+            
+            
+            pass
+
+    
+            
+            
+    
+        def __str__(self):
+            return "DetectTextResult.SPATIAL(text={})".format(self.text)
+        def __eq__(self, other):
+            if not isinstance(other, DetectTextResult):
+                return NotImplemented
+            if not other.is_SPATIAL():
+                return False
+            if self.text != other.text:
+                return False
+            return True
+
+    
+
+    # For each variant, we have `is_NAME` and `is_name` methods for easily checking
+    # whether an instance is that variant.
+    def is_STRUCTURED(self) -> bool:
+        return isinstance(self, DetectTextResult.STRUCTURED)
+    def is_structured(self) -> bool:
+        return isinstance(self, DetectTextResult.STRUCTURED)
+    def is_SPATIAL(self) -> bool:
+        return isinstance(self, DetectTextResult.SPATIAL)
+    def is_spatial(self) -> bool:
+        return isinstance(self, DetectTextResult.SPATIAL)
+    
+
+# Now, a little trick - we make each nested variant class be a subclass of the main
+# enum class, so that method calls and instance checks etc will work intuitively.
+# We might be able to do this a little more neatly with a metaclass, but this'll do.
+DetectTextResult.STRUCTURED = type("DetectTextResult.STRUCTURED", (DetectTextResult.STRUCTURED, DetectTextResult,), {})  # type: ignore
+DetectTextResult.SPATIAL = type("DetectTextResult.SPATIAL", (DetectTextResult.SPATIAL, DetectTextResult,), {})  # type: ignore
+
+
+
+
+class _UniffiFfiConverterTypeDetectTextResult(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        variant = buf.read_i32()
+        if variant == 1:
+            return DetectTextResult.STRUCTURED(
+                _UniffiFfiConverterSequenceTypeTextResult.read(buf),
+            )
+        if variant == 2:
+            return DetectTextResult.SPATIAL(
+                _UniffiFfiConverterString.read(buf),
+            )
+        raise InternalError("Raw enum value doesn't match any cases")
+
+    @staticmethod
+    def check_lower(value):
+        if value.is_STRUCTURED():
+            _UniffiFfiConverterSequenceTypeTextResult.check_lower(value.results)
+            return
+        if value.is_SPATIAL():
+            _UniffiFfiConverterString.check_lower(value.text)
+            return
+        raise ValueError(value)
+
+    @staticmethod
+    def write(value, buf):
+        if value.is_STRUCTURED():
+            buf.write_i32(1)
+            _UniffiFfiConverterSequenceTypeTextResult.write(value.results, buf)
+        if value.is_SPATIAL():
+            buf.write_i32(2)
+            _UniffiFfiConverterString.write(value.text, buf)
+
+
+
+class _UniffiFfiConverterBytes(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        size = buf.read_i32()
+        if size < 0:
+            raise InternalError("Unexpected negative byte string length")
+        return buf.read(size)
+
+    @staticmethod
+    def check_lower(value):
+        try:
+            memoryview(value)
+        except TypeError:
+            raise TypeError("a bytes-like object is required, not {!r}".format(type(value).__name__))
+
+    @staticmethod
+    def write(value, buf):
+        buf.write_i32(len(value))
+        buf.write(value)
+
+
+
+
+
+
+class ImageSource:
+    def __init__(self):
+        raise RuntimeError("ImageSource cannot be instantiated directly")
+
+    # Each enum variant is a nested class of the enum itself.
+    @dataclass
+    class PATH:
+        
+        def __init__(self, path:str):
+            self.path = path
+            
+            
+            pass
+
+    
+            
+            
+    
+        def __str__(self):
+            return "ImageSource.PATH(path={})".format(self.path)
+        def __eq__(self, other):
+            if not isinstance(other, ImageSource):
+                return NotImplemented
+            if not other.is_PATH():
+                return False
+            if self.path != other.path:
+                return False
+            return True
+
+    @dataclass
+    class BYTES:
+        
+        def __init__(self, data:bytes):
+            self.data = data
+            
+            
+            pass
+
+    
+            
+            
+    
+        def __str__(self):
+            return "ImageSource.BYTES(data={})".format(self.data)
+        def __eq__(self, other):
+            if not isinstance(other, ImageSource):
+                return NotImplemented
+            if not other.is_BYTES():
+                return False
+            if self.data != other.data:
+                return False
+            return True
+
+    
+
+    # For each variant, we have `is_NAME` and `is_name` methods for easily checking
+    # whether an instance is that variant.
+    def is_PATH(self) -> bool:
+        return isinstance(self, ImageSource.PATH)
+    def is_path(self) -> bool:
+        return isinstance(self, ImageSource.PATH)
+    def is_BYTES(self) -> bool:
+        return isinstance(self, ImageSource.BYTES)
+    def is_bytes(self) -> bool:
+        return isinstance(self, ImageSource.BYTES)
+    
+
+# Now, a little trick - we make each nested variant class be a subclass of the main
+# enum class, so that method calls and instance checks etc will work intuitively.
+# We might be able to do this a little more neatly with a metaclass, but this'll do.
+ImageSource.PATH = type("ImageSource.PATH", (ImageSource.PATH, ImageSource,), {})  # type: ignore
+ImageSource.BYTES = type("ImageSource.BYTES", (ImageSource.BYTES, ImageSource,), {})  # type: ignore
+
+
+
+
+class _UniffiFfiConverterTypeImageSource(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        variant = buf.read_i32()
+        if variant == 1:
+            return ImageSource.PATH(
+                _UniffiFfiConverterString.read(buf),
+            )
+        if variant == 2:
+            return ImageSource.BYTES(
+                _UniffiFfiConverterBytes.read(buf),
+            )
+        raise InternalError("Raw enum value doesn't match any cases")
+
+    @staticmethod
+    def check_lower(value):
+        if value.is_PATH():
+            _UniffiFfiConverterString.check_lower(value.path)
+            return
+        if value.is_BYTES():
+            _UniffiFfiConverterBytes.check_lower(value.data)
+            return
+        raise ValueError(value)
+
+    @staticmethod
+    def write(value, buf):
+        if value.is_PATH():
+            buf.write_i32(1)
+            _UniffiFfiConverterString.write(value.path, buf)
+        if value.is_BYTES():
+            buf.write_i32(2)
+            _UniffiFfiConverterBytes.write(value.data, buf)
+
+
+
+
+
+# RustoBindingError
+# We want to define each variant as a nested class that's also a subclass,
+# which is tricky in Python.  To accomplish this we're going to create each
+# class separately, then manually add the child classes to the base class's
+# __dict__.  All of this happens in dummy class to avoid polluting the module
+# namespace.
+class RustoBindingError(Exception):
+    pass
+
+_UniffiTempRustoBindingError = RustoBindingError
+
+class RustoBindingError:  # type: ignore
+    
+    class Initialization(_UniffiTempRustoBindingError):
+        
+        def __init__(self, msg):
+            super().__init__(", ".join([
+                "msg={!r}".format(msg),
+            ]))
+            self.msg = msg
+
+        def __repr__(self):
+            return "RustoBindingError.Initialization({})".format(str(self))
+    _UniffiTempRustoBindingError.Initialization = Initialization # type: ignore
+    class Preprocess(_UniffiTempRustoBindingError):
+        
+        def __init__(self, msg):
+            super().__init__(", ".join([
+                "msg={!r}".format(msg),
+            ]))
+            self.msg = msg
+
+        def __repr__(self):
+            return "RustoBindingError.Preprocess({})".format(str(self))
+    _UniffiTempRustoBindingError.Preprocess = Preprocess # type: ignore
+    class Inference(_UniffiTempRustoBindingError):
+        
+        def __init__(self, msg):
+            super().__init__(", ".join([
+                "msg={!r}".format(msg),
+            ]))
+            self.msg = msg
+
+        def __repr__(self):
+            return "RustoBindingError.Inference({})".format(str(self))
+    _UniffiTempRustoBindingError.Inference = Inference # type: ignore
+    class Postprocess(_UniffiTempRustoBindingError):
+        
+        def __init__(self, msg):
+            super().__init__(", ".join([
+                "msg={!r}".format(msg),
+            ]))
+            self.msg = msg
+
+        def __repr__(self):
+            return "RustoBindingError.Postprocess({})".format(str(self))
+    _UniffiTempRustoBindingError.Postprocess = Postprocess # type: ignore
+    class InvalidInput(_UniffiTempRustoBindingError):
+        
+        def __init__(self, msg):
+            super().__init__(", ".join([
+                "msg={!r}".format(msg),
+            ]))
+            self.msg = msg
+
+        def __repr__(self):
+            return "RustoBindingError.InvalidInput({})".format(str(self))
+    _UniffiTempRustoBindingError.InvalidInput = InvalidInput # type: ignore
+
+RustoBindingError = _UniffiTempRustoBindingError # type: ignore
+del _UniffiTempRustoBindingError
+
+
+class _UniffiFfiConverterTypeRustoBindingError(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        variant = buf.read_i32()
+        if variant == 1:
+            return RustoBindingError.Initialization(
+                _UniffiFfiConverterString.read(buf),
+            )
+        if variant == 2:
+            return RustoBindingError.Preprocess(
+                _UniffiFfiConverterString.read(buf),
+            )
+        if variant == 3:
+            return RustoBindingError.Inference(
+                _UniffiFfiConverterString.read(buf),
+            )
+        if variant == 4:
+            return RustoBindingError.Postprocess(
+                _UniffiFfiConverterString.read(buf),
+            )
+        if variant == 5:
+            return RustoBindingError.InvalidInput(
+                _UniffiFfiConverterString.read(buf),
+            )
+        raise InternalError("Raw enum value doesn't match any cases")
+
+    @staticmethod
+    def check_lower(value):
+        if isinstance(value, RustoBindingError.Initialization):
+            _UniffiFfiConverterString.check_lower(value.msg)
+            return
+        if isinstance(value, RustoBindingError.Preprocess):
+            _UniffiFfiConverterString.check_lower(value.msg)
+            return
+        if isinstance(value, RustoBindingError.Inference):
+            _UniffiFfiConverterString.check_lower(value.msg)
+            return
+        if isinstance(value, RustoBindingError.Postprocess):
+            _UniffiFfiConverterString.check_lower(value.msg)
+            return
+        if isinstance(value, RustoBindingError.InvalidInput):
+            _UniffiFfiConverterString.check_lower(value.msg)
+            return
+
+    @staticmethod
+    def write(value, buf):
+        if isinstance(value, RustoBindingError.Initialization):
+            buf.write_i32(1)
+            _UniffiFfiConverterString.write(value.msg, buf)
+        if isinstance(value, RustoBindingError.Preprocess):
+            buf.write_i32(2)
+            _UniffiFfiConverterString.write(value.msg, buf)
+        if isinstance(value, RustoBindingError.Inference):
+            buf.write_i32(3)
+            _UniffiFfiConverterString.write(value.msg, buf)
+        if isinstance(value, RustoBindingError.Postprocess):
+            buf.write_i32(4)
+            _UniffiFfiConverterString.write(value.msg, buf)
+        if isinstance(value, RustoBindingError.InvalidInput):
+            buf.write_i32(5)
+            _UniffiFfiConverterString.write(value.msg, buf)
+
+class _UniffiFfiConverterUInt32(_UniffiConverterPrimitiveInt):
+    CLASS_NAME = "u32"
+    VALUE_MIN = 0
+    VALUE_MAX = 2**32
+
+    @staticmethod
+    def read(buf):
+        return buf.read_u32()
+
+    @staticmethod
+    def write(value, buf):
+        buf.write_u32(value)
+
+class _UniffiFfiConverterUInt64(_UniffiConverterPrimitiveInt):
+    CLASS_NAME = "u64"
+    VALUE_MIN = 0
+    VALUE_MAX = 2**64
+
+    @staticmethod
+    def read(buf):
+        return buf.read_u64()
+
+    @staticmethod
+    def write(value, buf):
+        buf.write_u64(value)
+
+
+class RustOProtocol(typing.Protocol):
+    
+    def detect_text(self, source: ImageSource,options: OcrRunOptions) -> DetectTextResult:
+        raise NotImplementedError
+    def detect_text_rgb(self, pixels: bytes,width: int,height: int,stride: int,options: OcrRunOptions) -> DetectTextResult:
+        raise NotImplementedError
+    def version(self, ) -> str:
+        raise NotImplementedError
+
+class RustO(RustOProtocol):
+    
+    _handle: ctypes.c_uint64
+    @classmethod
+    def initialize(cls, config: InitializeConfig) -> RustO:
+        
+        _UniffiFfiConverterTypeInitializeConfig.check_lower(config)
+        _uniffi_lowered_args = (
+            _UniffiFfiConverterTypeInitializeConfig.lower(config),
+        )
+        _uniffi_lift_return = _UniffiFfiConverterTypeRustO.lift
+        _uniffi_error_converter = _UniffiFfiConverterTypeRustoBindingError
+        _uniffi_ffi_result = _uniffi_rust_call_with_error(
+            _uniffi_error_converter,
+            _UniffiLib.uniffi_rusto_fn_constructor_rusto_initialize,
+            *_uniffi_lowered_args,
+        )
+        return cls._uniffi_make_instance(_uniffi_ffi_result)
+    @classmethod
+    def initialize_from_json(cls, config_json: str) -> RustO:
+        
+        _UniffiFfiConverterString.check_lower(config_json)
+        _uniffi_lowered_args = (
+            _UniffiFfiConverterString.lower(config_json),
+        )
+        _uniffi_lift_return = _UniffiFfiConverterTypeRustO.lift
+        _uniffi_error_converter = _UniffiFfiConverterTypeRustoBindingError
+        _uniffi_ffi_result = _uniffi_rust_call_with_error(
+            _uniffi_error_converter,
+            _UniffiLib.uniffi_rusto_fn_constructor_rusto_initialize_from_json,
+            *_uniffi_lowered_args,
+        )
+        return cls._uniffi_make_instance(_uniffi_ffi_result)
+    
+    def __init__(self, *args, **kwargs):
+        raise ValueError("This class has no default constructor")
+
+    def __del__(self):
+        # In case of partial initialization of instances.
+        handle = getattr(self, "_handle", None)
+        if handle is not None:
+            _uniffi_rust_call(_UniffiLib.uniffi_rusto_fn_free_rusto, handle)
+
+    def _uniffi_clone_handle(self):
+        return _uniffi_rust_call(_UniffiLib.uniffi_rusto_fn_clone_rusto, self._handle)
+
+    # Used by alternative constructors or any methods which return this type.
+    @classmethod
+    def _uniffi_make_instance(cls, handle):
+        # Lightly yucky way to bypass the usual __init__ logic
+        # and just create a new instance with the required handle.
+        inst = cls.__new__(cls)
+        inst._handle = handle
+        return inst
+    def detect_text(self, source: ImageSource,options: OcrRunOptions) -> DetectTextResult:
+        
+        _UniffiFfiConverterTypeImageSource.check_lower(source)
+
+        _UniffiFfiConverterTypeOcrRunOptions.check_lower(options)
+        _uniffi_lowered_args = (
+            self._uniffi_clone_handle(),
+            _UniffiFfiConverterTypeImageSource.lower(source),
+            _UniffiFfiConverterTypeOcrRunOptions.lower(options),
+        )
+        _uniffi_lift_return = _UniffiFfiConverterTypeDetectTextResult.lift
+        _uniffi_error_converter = _UniffiFfiConverterTypeRustoBindingError
+        _uniffi_ffi_result = _uniffi_rust_call_with_error(
+            _uniffi_error_converter,
+            _UniffiLib.uniffi_rusto_fn_method_rusto_detect_text,
+            *_uniffi_lowered_args,
+        )
+        return _uniffi_lift_return(_uniffi_ffi_result)
+    def detect_text_rgb(self, pixels: bytes,width: int,height: int,stride: int,options: OcrRunOptions) -> DetectTextResult:
+        
+        _UniffiFfiConverterBytes.check_lower(pixels)
+
+        _UniffiFfiConverterUInt32.check_lower(width)
+
+        _UniffiFfiConverterUInt32.check_lower(height)
+
+        _UniffiFfiConverterUInt64.check_lower(stride)
+
+        _UniffiFfiConverterTypeOcrRunOptions.check_lower(options)
+        _uniffi_lowered_args = (
+            self._uniffi_clone_handle(),
+            _UniffiFfiConverterBytes.lower(pixels),
+            _UniffiFfiConverterUInt32.lower(width),
+            _UniffiFfiConverterUInt32.lower(height),
+            _UniffiFfiConverterUInt64.lower(stride),
+            _UniffiFfiConverterTypeOcrRunOptions.lower(options),
+        )
+        _uniffi_lift_return = _UniffiFfiConverterTypeDetectTextResult.lift
+        _uniffi_error_converter = _UniffiFfiConverterTypeRustoBindingError
+        _uniffi_ffi_result = _uniffi_rust_call_with_error(
+            _uniffi_error_converter,
+            _UniffiLib.uniffi_rusto_fn_method_rusto_detect_text_rgb,
+            *_uniffi_lowered_args,
+        )
+        return _uniffi_lift_return(_uniffi_ffi_result)
+    def version(self, ) -> str:
+        _uniffi_lowered_args = (
+            self._uniffi_clone_handle(),
+        )
+        _uniffi_lift_return = _UniffiFfiConverterString.lift
+        _uniffi_error_converter = None
+        _uniffi_ffi_result = _uniffi_rust_call_with_error(
+            _uniffi_error_converter,
+            _UniffiLib.uniffi_rusto_fn_method_rusto_version,
+            *_uniffi_lowered_args,
+        )
+        return _uniffi_lift_return(_uniffi_ffi_result)
+
+
+
+
+
+class _UniffiFfiConverterTypeRustO:
+    @staticmethod
+    def lift(value: int) -> RustO:
+        return RustO._uniffi_make_instance(value)
+
+    @staticmethod
+    def check_lower(value: RustO):
+        if not isinstance(value, RustO):
+            raise TypeError("Expected RustO instance, {} found".format(type(value).__name__))
+
+    @staticmethod
+    def lower(value: RustO) -> ctypes.c_uint64:
+        return value._uniffi_clone_handle()
+
+    @classmethod
+    def read(cls, buf: _UniffiRustBuffer) -> RustO:
+        ptr = buf.read_u64()
+        if ptr == 0:
+            raise InternalError("Raw handle value was null")
+        return cls.lift(ptr)
+
+    @classmethod
+    def write(cls, value: RustO, buf: _UniffiRustBuffer):
+        buf.write_u64(cls.lower(value))
+
+class _UniffiFfiConverterUInt8(_UniffiConverterPrimitiveInt):
+    CLASS_NAME = "u8"
+    VALUE_MIN = 0
+    VALUE_MAX = 2**8
+
+    @staticmethod
+    def read(buf):
+        return buf.read_u8()
+
+    @staticmethod
+    def write(value, buf):
+        buf.write_u8(value)
+def create_initialize_config_ppv6(det_model_path: str,rec_model_path: str,dict_path: str) -> InitializeConfig:
+    
+    _UniffiFfiConverterString.check_lower(det_model_path)
+
+    _UniffiFfiConverterString.check_lower(rec_model_path)
+
+    _UniffiFfiConverterString.check_lower(dict_path)
+    _uniffi_lowered_args = (
+        _UniffiFfiConverterString.lower(det_model_path),
+        _UniffiFfiConverterString.lower(rec_model_path),
+        _UniffiFfiConverterString.lower(dict_path),
+    )
+    _uniffi_lift_return = _UniffiFfiConverterTypeInitializeConfig.lift
+    _uniffi_error_converter = None
+    _uniffi_ffi_result = _uniffi_rust_call_with_error(
+        _uniffi_error_converter,
+        _UniffiLib.uniffi_rusto_fn_func_create_initialize_config_ppv6,
+        *_uniffi_lowered_args,
+    )
+    return _uniffi_lift_return(_uniffi_ffi_result)
+def default_ocr_run_options() -> OcrRunOptions:
+    _uniffi_lowered_args = (
+    )
+    _uniffi_lift_return = _UniffiFfiConverterTypeOcrRunOptions.lift
+    _uniffi_error_converter = None
+    _uniffi_ffi_result = _uniffi_rust_call_with_error(
+        _uniffi_error_converter,
+        _UniffiLib.uniffi_rusto_fn_func_default_ocr_run_options,
+        *_uniffi_lowered_args,
+    )
+    return _uniffi_lift_return(_uniffi_ffi_result)
+def rusto_version() -> str:
+    _uniffi_lowered_args = (
+    )
+    _uniffi_lift_return = _UniffiFfiConverterString.lift
+    _uniffi_error_converter = None
+    _uniffi_ffi_result = _uniffi_rust_call_with_error(
+        _uniffi_error_converter,
+        _UniffiLib.uniffi_rusto_fn_func_rusto_version,
+        *_uniffi_lowered_args,
+    )
+    return _uniffi_lift_return(_uniffi_ffi_result)
+
+__all__ = [
+    "InternalError",
+    "OutputGranularity",
+    "DetectTextResult",
+    "ImageSource",
+    "RustoBindingError",
+    "CalibrationOptions",
+    "ClassificationConfig",
+    "DetectionConfig",
+    "PostprocessRunOptions",
+    "DetectionRunOptions",
+    "Frame",
+    "RecognitionConfig",
+    "OrientationConfig",
+    "UnwarpConfig",
+    "InitializeConfig",
+    "OptimizationOptions",
+    "OcrRunOptions",
+    "Point2D",
+    "TextResult",
+    "create_initialize_config_ppv6",
+    "default_ocr_run_options",
+    "rusto_version",
+    "RustO",
+    "RustOProtocol",
+]