breez-sdk-spark 0.1.0rc8__cp310-cp310-macosx_11_0_universal2.whl → 0.3.5rc1__cp310-cp310-macosx_11_0_universal2.whl

breez_sdk_spark/breez_sdk_common.py

@@ -461,9 +461,35 @@ def _uniffi_check_contract_api_version(lib):
         raise InternalError("UniFFI contract version mismatch: try cleaning and rebuilding your project")
 
 def _uniffi_check_api_checksums(lib):
-    if lib.uniffi_breez_sdk_common_checksum_method_restclient_get() != 32450:
+    if lib.uniffi_breez_sdk_common_checksum_method_fiatservice_fetch_fiat_currencies() != 63089:
         raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
-    if lib.uniffi_breez_sdk_common_checksum_method_restclient_post() != 14213:
+    if lib.uniffi_breez_sdk_common_checksum_method_fiatservice_fetch_fiat_rates() != 48636:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_breez_sdk_common_checksum_method_restclient_get_request() != 1702:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_breez_sdk_common_checksum_method_restclient_post_request() != 38998:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_breez_sdk_common_checksum_method_restclient_delete_request() != 26893:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_breez_sdk_common_checksum_method_syncstorage_add_outgoing_change() != 18302:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_breez_sdk_common_checksum_method_syncstorage_complete_outgoing_sync() != 1608:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_breez_sdk_common_checksum_method_syncstorage_get_pending_outgoing_changes() != 43350:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_breez_sdk_common_checksum_method_syncstorage_get_last_revision() != 11560:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_breez_sdk_common_checksum_method_syncstorage_insert_incoming_records() != 65359:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_breez_sdk_common_checksum_method_syncstorage_delete_incoming_record() != 6222:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_breez_sdk_common_checksum_method_syncstorage_rebase_pending_outgoing_records() != 49312:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_breez_sdk_common_checksum_method_syncstorage_get_incoming_records() != 39529:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_breez_sdk_common_checksum_method_syncstorage_get_latest_outgoing_change() != 13979:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_breez_sdk_common_checksum_method_syncstorage_update_record_from_incoming() != 63333:
         raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
 
 # A ctypes library to expose the extern-C FFI definitions.
@@ -571,16 +597,85 @@ class _UniffiForeignFutureStructVoid(ctypes.Structure):
     ]
 _UNIFFI_FOREIGN_FUTURE_COMPLETE_VOID = ctypes.CFUNCTYPE(None,ctypes.c_uint64,_UniffiForeignFutureStructVoid,
 )
+_UNIFFI_CALLBACK_INTERFACE_FIAT_SERVICE_METHOD0 = ctypes.CFUNCTYPE(None,ctypes.c_uint64,_UNIFFI_FOREIGN_FUTURE_COMPLETE_RUST_BUFFER,ctypes.c_uint64,ctypes.POINTER(_UniffiForeignFuture),
+)
+_UNIFFI_CALLBACK_INTERFACE_FIAT_SERVICE_METHOD1 = ctypes.CFUNCTYPE(None,ctypes.c_uint64,_UNIFFI_FOREIGN_FUTURE_COMPLETE_RUST_BUFFER,ctypes.c_uint64,ctypes.POINTER(_UniffiForeignFuture),
+)
 _UNIFFI_CALLBACK_INTERFACE_REST_CLIENT_METHOD0 = ctypes.CFUNCTYPE(None,ctypes.c_uint64,_UniffiRustBuffer,_UniffiRustBuffer,_UNIFFI_FOREIGN_FUTURE_COMPLETE_RUST_BUFFER,ctypes.c_uint64,ctypes.POINTER(_UniffiForeignFuture),
 )
 _UNIFFI_CALLBACK_INTERFACE_REST_CLIENT_METHOD1 = ctypes.CFUNCTYPE(None,ctypes.c_uint64,_UniffiRustBuffer,_UniffiRustBuffer,_UniffiRustBuffer,_UNIFFI_FOREIGN_FUTURE_COMPLETE_RUST_BUFFER,ctypes.c_uint64,ctypes.POINTER(_UniffiForeignFuture),
 )
+_UNIFFI_CALLBACK_INTERFACE_REST_CLIENT_METHOD2 = ctypes.CFUNCTYPE(None,ctypes.c_uint64,_UniffiRustBuffer,_UniffiRustBuffer,_UniffiRustBuffer,_UNIFFI_FOREIGN_FUTURE_COMPLETE_RUST_BUFFER,ctypes.c_uint64,ctypes.POINTER(_UniffiForeignFuture),
+)
+_UNIFFI_CALLBACK_INTERFACE_SYNC_STORAGE_METHOD0 = ctypes.CFUNCTYPE(None,ctypes.c_uint64,_UniffiRustBuffer,_UNIFFI_FOREIGN_FUTURE_COMPLETE_U64,ctypes.c_uint64,ctypes.POINTER(_UniffiForeignFuture),
+)
+_UNIFFI_CALLBACK_INTERFACE_SYNC_STORAGE_METHOD1 = ctypes.CFUNCTYPE(None,ctypes.c_uint64,_UniffiRustBuffer,_UNIFFI_FOREIGN_FUTURE_COMPLETE_VOID,ctypes.c_uint64,ctypes.POINTER(_UniffiForeignFuture),
+)
+_UNIFFI_CALLBACK_INTERFACE_SYNC_STORAGE_METHOD2 = ctypes.CFUNCTYPE(None,ctypes.c_uint64,ctypes.c_uint32,_UNIFFI_FOREIGN_FUTURE_COMPLETE_RUST_BUFFER,ctypes.c_uint64,ctypes.POINTER(_UniffiForeignFuture),
+)
+_UNIFFI_CALLBACK_INTERFACE_SYNC_STORAGE_METHOD3 = ctypes.CFUNCTYPE(None,ctypes.c_uint64,_UNIFFI_FOREIGN_FUTURE_COMPLETE_U64,ctypes.c_uint64,ctypes.POINTER(_UniffiForeignFuture),
+)
+_UNIFFI_CALLBACK_INTERFACE_SYNC_STORAGE_METHOD4 = ctypes.CFUNCTYPE(None,ctypes.c_uint64,_UniffiRustBuffer,_UNIFFI_FOREIGN_FUTURE_COMPLETE_VOID,ctypes.c_uint64,ctypes.POINTER(_UniffiForeignFuture),
+)
+_UNIFFI_CALLBACK_INTERFACE_SYNC_STORAGE_METHOD5 = ctypes.CFUNCTYPE(None,ctypes.c_uint64,_UniffiRustBuffer,_UNIFFI_FOREIGN_FUTURE_COMPLETE_VOID,ctypes.c_uint64,ctypes.POINTER(_UniffiForeignFuture),
+)
+_UNIFFI_CALLBACK_INTERFACE_SYNC_STORAGE_METHOD6 = ctypes.CFUNCTYPE(None,ctypes.c_uint64,ctypes.c_uint64,_UNIFFI_FOREIGN_FUTURE_COMPLETE_VOID,ctypes.c_uint64,ctypes.POINTER(_UniffiForeignFuture),
+)
+_UNIFFI_CALLBACK_INTERFACE_SYNC_STORAGE_METHOD7 = ctypes.CFUNCTYPE(None,ctypes.c_uint64,ctypes.c_uint32,_UNIFFI_FOREIGN_FUTURE_COMPLETE_RUST_BUFFER,ctypes.c_uint64,ctypes.POINTER(_UniffiForeignFuture),
+)
+_UNIFFI_CALLBACK_INTERFACE_SYNC_STORAGE_METHOD8 = ctypes.CFUNCTYPE(None,ctypes.c_uint64,_UNIFFI_FOREIGN_FUTURE_COMPLETE_RUST_BUFFER,ctypes.c_uint64,ctypes.POINTER(_UniffiForeignFuture),
+)
+_UNIFFI_CALLBACK_INTERFACE_SYNC_STORAGE_METHOD9 = ctypes.CFUNCTYPE(None,ctypes.c_uint64,_UniffiRustBuffer,_UNIFFI_FOREIGN_FUTURE_COMPLETE_VOID,ctypes.c_uint64,ctypes.POINTER(_UniffiForeignFuture),
+)
+class _UniffiVTableCallbackInterfaceFiatService(ctypes.Structure):
+    _fields_ = [
+        ("fetch_fiat_currencies", _UNIFFI_CALLBACK_INTERFACE_FIAT_SERVICE_METHOD0),
+        ("fetch_fiat_rates", _UNIFFI_CALLBACK_INTERFACE_FIAT_SERVICE_METHOD1),
+        ("uniffi_free", _UNIFFI_CALLBACK_INTERFACE_FREE),
+    ]
 class _UniffiVTableCallbackInterfaceRestClient(ctypes.Structure):
     _fields_ = [
-        ("get", _UNIFFI_CALLBACK_INTERFACE_REST_CLIENT_METHOD0),
-        ("post", _UNIFFI_CALLBACK_INTERFACE_REST_CLIENT_METHOD1),
+        ("get_request", _UNIFFI_CALLBACK_INTERFACE_REST_CLIENT_METHOD0),
+        ("post_request", _UNIFFI_CALLBACK_INTERFACE_REST_CLIENT_METHOD1),
+        ("delete_request", _UNIFFI_CALLBACK_INTERFACE_REST_CLIENT_METHOD2),
+        ("uniffi_free", _UNIFFI_CALLBACK_INTERFACE_FREE),
+    ]
+class _UniffiVTableCallbackInterfaceSyncStorage(ctypes.Structure):
+    _fields_ = [
+        ("add_outgoing_change", _UNIFFI_CALLBACK_INTERFACE_SYNC_STORAGE_METHOD0),
+        ("complete_outgoing_sync", _UNIFFI_CALLBACK_INTERFACE_SYNC_STORAGE_METHOD1),
+        ("get_pending_outgoing_changes", _UNIFFI_CALLBACK_INTERFACE_SYNC_STORAGE_METHOD2),
+        ("get_last_revision", _UNIFFI_CALLBACK_INTERFACE_SYNC_STORAGE_METHOD3),
+        ("insert_incoming_records", _UNIFFI_CALLBACK_INTERFACE_SYNC_STORAGE_METHOD4),
+        ("delete_incoming_record", _UNIFFI_CALLBACK_INTERFACE_SYNC_STORAGE_METHOD5),
+        ("rebase_pending_outgoing_records", _UNIFFI_CALLBACK_INTERFACE_SYNC_STORAGE_METHOD6),
+        ("get_incoming_records", _UNIFFI_CALLBACK_INTERFACE_SYNC_STORAGE_METHOD7),
+        ("get_latest_outgoing_change", _UNIFFI_CALLBACK_INTERFACE_SYNC_STORAGE_METHOD8),
+        ("update_record_from_incoming", _UNIFFI_CALLBACK_INTERFACE_SYNC_STORAGE_METHOD9),
         ("uniffi_free", _UNIFFI_CALLBACK_INTERFACE_FREE),
     ]
+_UniffiLib.uniffi_breez_sdk_common_fn_clone_fiatservice.argtypes = (
+    ctypes.c_void_p,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_breez_sdk_common_fn_clone_fiatservice.restype = ctypes.c_void_p
+_UniffiLib.uniffi_breez_sdk_common_fn_free_fiatservice.argtypes = (
+    ctypes.c_void_p,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_breez_sdk_common_fn_free_fiatservice.restype = None
+_UniffiLib.uniffi_breez_sdk_common_fn_init_callback_vtable_fiatservice.argtypes = (
+    ctypes.POINTER(_UniffiVTableCallbackInterfaceFiatService),
+)
+_UniffiLib.uniffi_breez_sdk_common_fn_init_callback_vtable_fiatservice.restype = None
+_UniffiLib.uniffi_breez_sdk_common_fn_method_fiatservice_fetch_fiat_currencies.argtypes = (
+    ctypes.c_void_p,
+)
+_UniffiLib.uniffi_breez_sdk_common_fn_method_fiatservice_fetch_fiat_currencies.restype = ctypes.c_uint64
+_UniffiLib.uniffi_breez_sdk_common_fn_method_fiatservice_fetch_fiat_rates.argtypes = (
+    ctypes.c_void_p,
+)
+_UniffiLib.uniffi_breez_sdk_common_fn_method_fiatservice_fetch_fiat_rates.restype = ctypes.c_uint64
 _UniffiLib.uniffi_breez_sdk_common_fn_clone_restclient.argtypes = (
     ctypes.c_void_p,
     ctypes.POINTER(_UniffiRustCallStatus),
@@ -595,19 +690,88 @@ _UniffiLib.uniffi_breez_sdk_common_fn_init_callback_vtable_restclient.argtypes =
     ctypes.POINTER(_UniffiVTableCallbackInterfaceRestClient),
 )
 _UniffiLib.uniffi_breez_sdk_common_fn_init_callback_vtable_restclient.restype = None
-_UniffiLib.uniffi_breez_sdk_common_fn_method_restclient_get.argtypes = (
+_UniffiLib.uniffi_breez_sdk_common_fn_method_restclient_get_request.argtypes = (
+    ctypes.c_void_p,
+    _UniffiRustBuffer,
+    _UniffiRustBuffer,
+)
+_UniffiLib.uniffi_breez_sdk_common_fn_method_restclient_get_request.restype = ctypes.c_uint64
+_UniffiLib.uniffi_breez_sdk_common_fn_method_restclient_post_request.argtypes = (
+    ctypes.c_void_p,
+    _UniffiRustBuffer,
+    _UniffiRustBuffer,
+    _UniffiRustBuffer,
+)
+_UniffiLib.uniffi_breez_sdk_common_fn_method_restclient_post_request.restype = ctypes.c_uint64
+_UniffiLib.uniffi_breez_sdk_common_fn_method_restclient_delete_request.argtypes = (
+    ctypes.c_void_p,
+    _UniffiRustBuffer,
+    _UniffiRustBuffer,
+    _UniffiRustBuffer,
+)
+_UniffiLib.uniffi_breez_sdk_common_fn_method_restclient_delete_request.restype = ctypes.c_uint64
+_UniffiLib.uniffi_breez_sdk_common_fn_clone_syncstorage.argtypes = (
+    ctypes.c_void_p,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_breez_sdk_common_fn_clone_syncstorage.restype = ctypes.c_void_p
+_UniffiLib.uniffi_breez_sdk_common_fn_free_syncstorage.argtypes = (
+    ctypes.c_void_p,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_breez_sdk_common_fn_free_syncstorage.restype = None
+_UniffiLib.uniffi_breez_sdk_common_fn_init_callback_vtable_syncstorage.argtypes = (
+    ctypes.POINTER(_UniffiVTableCallbackInterfaceSyncStorage),
+)
+_UniffiLib.uniffi_breez_sdk_common_fn_init_callback_vtable_syncstorage.restype = None
+_UniffiLib.uniffi_breez_sdk_common_fn_method_syncstorage_add_outgoing_change.argtypes = (
     ctypes.c_void_p,
     _UniffiRustBuffer,
+)
+_UniffiLib.uniffi_breez_sdk_common_fn_method_syncstorage_add_outgoing_change.restype = ctypes.c_uint64
+_UniffiLib.uniffi_breez_sdk_common_fn_method_syncstorage_complete_outgoing_sync.argtypes = (
+    ctypes.c_void_p,
     _UniffiRustBuffer,
 )
-_UniffiLib.uniffi_breez_sdk_common_fn_method_restclient_get.restype = ctypes.c_uint64
-_UniffiLib.uniffi_breez_sdk_common_fn_method_restclient_post.argtypes = (
+_UniffiLib.uniffi_breez_sdk_common_fn_method_syncstorage_complete_outgoing_sync.restype = ctypes.c_uint64
+_UniffiLib.uniffi_breez_sdk_common_fn_method_syncstorage_get_pending_outgoing_changes.argtypes = (
+    ctypes.c_void_p,
+    ctypes.c_uint32,
+)
+_UniffiLib.uniffi_breez_sdk_common_fn_method_syncstorage_get_pending_outgoing_changes.restype = ctypes.c_uint64
+_UniffiLib.uniffi_breez_sdk_common_fn_method_syncstorage_get_last_revision.argtypes = (
+    ctypes.c_void_p,
+)
+_UniffiLib.uniffi_breez_sdk_common_fn_method_syncstorage_get_last_revision.restype = ctypes.c_uint64
+_UniffiLib.uniffi_breez_sdk_common_fn_method_syncstorage_insert_incoming_records.argtypes = (
     ctypes.c_void_p,
     _UniffiRustBuffer,
+)
+_UniffiLib.uniffi_breez_sdk_common_fn_method_syncstorage_insert_incoming_records.restype = ctypes.c_uint64
+_UniffiLib.uniffi_breez_sdk_common_fn_method_syncstorage_delete_incoming_record.argtypes = (
+    ctypes.c_void_p,
     _UniffiRustBuffer,
+)
+_UniffiLib.uniffi_breez_sdk_common_fn_method_syncstorage_delete_incoming_record.restype = ctypes.c_uint64
+_UniffiLib.uniffi_breez_sdk_common_fn_method_syncstorage_rebase_pending_outgoing_records.argtypes = (
+    ctypes.c_void_p,
+    ctypes.c_uint64,
+)
+_UniffiLib.uniffi_breez_sdk_common_fn_method_syncstorage_rebase_pending_outgoing_records.restype = ctypes.c_uint64
+_UniffiLib.uniffi_breez_sdk_common_fn_method_syncstorage_get_incoming_records.argtypes = (
+    ctypes.c_void_p,
+    ctypes.c_uint32,
+)
+_UniffiLib.uniffi_breez_sdk_common_fn_method_syncstorage_get_incoming_records.restype = ctypes.c_uint64
+_UniffiLib.uniffi_breez_sdk_common_fn_method_syncstorage_get_latest_outgoing_change.argtypes = (
+    ctypes.c_void_p,
+)
+_UniffiLib.uniffi_breez_sdk_common_fn_method_syncstorage_get_latest_outgoing_change.restype = ctypes.c_uint64
+_UniffiLib.uniffi_breez_sdk_common_fn_method_syncstorage_update_record_from_incoming.argtypes = (
+    ctypes.c_void_p,
     _UniffiRustBuffer,
 )
-_UniffiLib.uniffi_breez_sdk_common_fn_method_restclient_post.restype = ctypes.c_uint64
+_UniffiLib.uniffi_breez_sdk_common_fn_method_syncstorage_update_record_from_incoming.restype = ctypes.c_uint64
 _UniffiLib.ffi_breez_sdk_common_rustbuffer_alloc.argtypes = (
     ctypes.c_uint64,
     ctypes.POINTER(_UniffiRustCallStatus),
@@ -876,12 +1040,51 @@ _UniffiLib.ffi_breez_sdk_common_rust_future_complete_void.argtypes = (
     ctypes.POINTER(_UniffiRustCallStatus),
 )
 _UniffiLib.ffi_breez_sdk_common_rust_future_complete_void.restype = None
-_UniffiLib.uniffi_breez_sdk_common_checksum_method_restclient_get.argtypes = (
+_UniffiLib.uniffi_breez_sdk_common_checksum_method_fiatservice_fetch_fiat_currencies.argtypes = (
+)
+_UniffiLib.uniffi_breez_sdk_common_checksum_method_fiatservice_fetch_fiat_currencies.restype = ctypes.c_uint16
+_UniffiLib.uniffi_breez_sdk_common_checksum_method_fiatservice_fetch_fiat_rates.argtypes = (
+)
+_UniffiLib.uniffi_breez_sdk_common_checksum_method_fiatservice_fetch_fiat_rates.restype = ctypes.c_uint16
+_UniffiLib.uniffi_breez_sdk_common_checksum_method_restclient_get_request.argtypes = (
+)
+_UniffiLib.uniffi_breez_sdk_common_checksum_method_restclient_get_request.restype = ctypes.c_uint16
+_UniffiLib.uniffi_breez_sdk_common_checksum_method_restclient_post_request.argtypes = (
+)
+_UniffiLib.uniffi_breez_sdk_common_checksum_method_restclient_post_request.restype = ctypes.c_uint16
+_UniffiLib.uniffi_breez_sdk_common_checksum_method_restclient_delete_request.argtypes = (
+)
+_UniffiLib.uniffi_breez_sdk_common_checksum_method_restclient_delete_request.restype = ctypes.c_uint16
+_UniffiLib.uniffi_breez_sdk_common_checksum_method_syncstorage_add_outgoing_change.argtypes = (
+)
+_UniffiLib.uniffi_breez_sdk_common_checksum_method_syncstorage_add_outgoing_change.restype = ctypes.c_uint16
+_UniffiLib.uniffi_breez_sdk_common_checksum_method_syncstorage_complete_outgoing_sync.argtypes = (
+)
+_UniffiLib.uniffi_breez_sdk_common_checksum_method_syncstorage_complete_outgoing_sync.restype = ctypes.c_uint16
+_UniffiLib.uniffi_breez_sdk_common_checksum_method_syncstorage_get_pending_outgoing_changes.argtypes = (
 )
-_UniffiLib.uniffi_breez_sdk_common_checksum_method_restclient_get.restype = ctypes.c_uint16
-_UniffiLib.uniffi_breez_sdk_common_checksum_method_restclient_post.argtypes = (
+_UniffiLib.uniffi_breez_sdk_common_checksum_method_syncstorage_get_pending_outgoing_changes.restype = ctypes.c_uint16
+_UniffiLib.uniffi_breez_sdk_common_checksum_method_syncstorage_get_last_revision.argtypes = (
 )
-_UniffiLib.uniffi_breez_sdk_common_checksum_method_restclient_post.restype = ctypes.c_uint16
+_UniffiLib.uniffi_breez_sdk_common_checksum_method_syncstorage_get_last_revision.restype = ctypes.c_uint16
+_UniffiLib.uniffi_breez_sdk_common_checksum_method_syncstorage_insert_incoming_records.argtypes = (
+)
+_UniffiLib.uniffi_breez_sdk_common_checksum_method_syncstorage_insert_incoming_records.restype = ctypes.c_uint16
+_UniffiLib.uniffi_breez_sdk_common_checksum_method_syncstorage_delete_incoming_record.argtypes = (
+)
+_UniffiLib.uniffi_breez_sdk_common_checksum_method_syncstorage_delete_incoming_record.restype = ctypes.c_uint16
+_UniffiLib.uniffi_breez_sdk_common_checksum_method_syncstorage_rebase_pending_outgoing_records.argtypes = (
+)
+_UniffiLib.uniffi_breez_sdk_common_checksum_method_syncstorage_rebase_pending_outgoing_records.restype = ctypes.c_uint16
+_UniffiLib.uniffi_breez_sdk_common_checksum_method_syncstorage_get_incoming_records.argtypes = (
+)
+_UniffiLib.uniffi_breez_sdk_common_checksum_method_syncstorage_get_incoming_records.restype = ctypes.c_uint16
+_UniffiLib.uniffi_breez_sdk_common_checksum_method_syncstorage_get_latest_outgoing_change.argtypes = (
+)
+_UniffiLib.uniffi_breez_sdk_common_checksum_method_syncstorage_get_latest_outgoing_change.restype = ctypes.c_uint16
+_UniffiLib.uniffi_breez_sdk_common_checksum_method_syncstorage_update_record_from_incoming.argtypes = (
+)
+_UniffiLib.uniffi_breez_sdk_common_checksum_method_syncstorage_update_record_from_incoming.restype = ctypes.c_uint16
 _UniffiLib.ffi_breez_sdk_common_uniffi_contract_version.argtypes = (
 )
 _UniffiLib.ffi_breez_sdk_common_uniffi_contract_version.restype = ctypes.c_uint32
@@ -995,29 +1198,30 @@ class _UniffiConverterString:
 
 
 
-class RestClient(typing.Protocol):
-    def get(self, url: "str",headers: "typing.Optional[dict[str, str]]"):
+class FiatService(typing.Protocol):
+    """
+    Trait covering fiat-related functionality
+    """
+
+    def fetch_fiat_currencies(self, ):
         """
-        Makes a GET request and logs on DEBUG.
-        ### Arguments
-        - `url`: the URL on which GET will be called
-        - `headers`: optional headers that will be set on the request
+        List all supported fiat currencies for which there is a known exchange rate.
         """
 
         raise NotImplementedError
-    def post(self, url: "str",headers: "typing.Optional[dict[str, str]]",body: "typing.Optional[str]"):
+    def fetch_fiat_rates(self, ):
         """
-        Makes a POST request, and logs on DEBUG.
-        ### Arguments
-        - `url`: the URL on which POST will be called
-        - `headers`: the optional POST headers
-        - `body`: the optional POST body
+        Get the live rates from the server.
         """
 
         raise NotImplementedError
 
 
-class RestClientImpl:
+class FiatServiceImpl:
+    """
+    Trait covering fiat-related functionality
+    """
+
     _pointer: ctypes.c_void_p
     
     def __init__(self, *args, **kwargs):
@@ -1027,10 +1231,10 @@ class RestClientImpl:
         # In case of partial initialization of instances.
         pointer = getattr(self, "_pointer", None)
         if pointer is not None:
-            _uniffi_rust_call(_UniffiLib.uniffi_breez_sdk_common_fn_free_restclient, pointer)
+            _uniffi_rust_call(_UniffiLib.uniffi_breez_sdk_common_fn_free_fiatservice, pointer)
 
     def _uniffi_clone_pointer(self):
-        return _uniffi_rust_call(_UniffiLib.uniffi_breez_sdk_common_fn_clone_restclient, self._pointer)
+        return _uniffi_rust_call(_UniffiLib.uniffi_breez_sdk_common_fn_clone_fiatservice, self._pointer)
 
     # Used by alternative constructors or any methods which return this type.
     @classmethod
@@ -1041,29 +1245,20 @@ class RestClientImpl:
         inst._pointer = pointer
         return inst
 
-    async def get(self, url: "str",headers: "typing.Optional[dict[str, str]]") -> "RestResponse":
+    async def fetch_fiat_currencies(self, ) -> "typing.List[FiatCurrency]":
         """
-        Makes a GET request and logs on DEBUG.
-        ### Arguments
-        - `url`: the URL on which GET will be called
-        - `headers`: optional headers that will be set on the request
+        List all supported fiat currencies for which there is a known exchange rate.
         """
 
-        _UniffiConverterString.check_lower(url)
-        
-        _UniffiConverterOptionalMapStringString.check_lower(headers)
-        
         return await _uniffi_rust_call_async(
-            _UniffiLib.uniffi_breez_sdk_common_fn_method_restclient_get(
+            _UniffiLib.uniffi_breez_sdk_common_fn_method_fiatservice_fetch_fiat_currencies(
                 self._uniffi_clone_pointer(), 
-        _UniffiConverterString.lower(url),
-        _UniffiConverterOptionalMapStringString.lower(headers)
             ),
             _UniffiLib.ffi_breez_sdk_common_rust_future_poll_rust_buffer,
             _UniffiLib.ffi_breez_sdk_common_rust_future_complete_rust_buffer,
             _UniffiLib.ffi_breez_sdk_common_rust_future_free_rust_buffer,
             # lift function
-            _UniffiConverterTypeRestResponse.lift,
+            _UniffiConverterSequenceTypeFiatCurrency.lift,
             
     # Error FFI converter
 _UniffiConverterTypeServiceConnectivityError,
@@ -1072,33 +1267,20 @@ _UniffiConverterTypeServiceConnectivityError,
 
 
 
-    async def post(self, url: "str",headers: "typing.Optional[dict[str, str]]",body: "typing.Optional[str]") -> "RestResponse":
+    async def fetch_fiat_rates(self, ) -> "typing.List[Rate]":
         """
-        Makes a POST request, and logs on DEBUG.
-        ### Arguments
-        - `url`: the URL on which POST will be called
-        - `headers`: the optional POST headers
-        - `body`: the optional POST body
+        Get the live rates from the server.
         """
 
-        _UniffiConverterString.check_lower(url)
-        
-        _UniffiConverterOptionalMapStringString.check_lower(headers)
-        
-        _UniffiConverterOptionalString.check_lower(body)
-        
         return await _uniffi_rust_call_async(
-            _UniffiLib.uniffi_breez_sdk_common_fn_method_restclient_post(
+            _UniffiLib.uniffi_breez_sdk_common_fn_method_fiatservice_fetch_fiat_rates(
                 self._uniffi_clone_pointer(), 
-        _UniffiConverterString.lower(url),
-        _UniffiConverterOptionalMapStringString.lower(headers),
-        _UniffiConverterOptionalString.lower(body)
             ),
             _UniffiLib.ffi_breez_sdk_common_rust_future_poll_rust_buffer,
             _UniffiLib.ffi_breez_sdk_common_rust_future_complete_rust_buffer,
             _UniffiLib.ffi_breez_sdk_common_rust_future_free_rust_buffer,
             # lift function
-            _UniffiConverterTypeRestResponse.lift,
+            _UniffiConverterSequenceTypeRate.lift,
             
     # Error FFI converter
 _UniffiConverterTypeServiceConnectivityError,
@@ -1140,22 +1322,20 @@ class _UniffiCallbackInterfaceFfiConverter:
         buf.write_u64(cls.lower(cb))
 
 # Put all the bits inside a class to keep the top-level namespace clean
-class _UniffiTraitImplRestClient:
+class _UniffiTraitImplFiatService:
     # For each method, generate a callback function to pass to Rust
 
-    @_UNIFFI_CALLBACK_INTERFACE_REST_CLIENT_METHOD0
-    def get(
+    @_UNIFFI_CALLBACK_INTERFACE_FIAT_SERVICE_METHOD0
+    def fetch_fiat_currencies(
             uniffi_handle,
-            url,
-            headers,
             uniffi_future_callback,
             uniffi_callback_data,
             uniffi_out_return,
         ):
-        uniffi_obj = _UniffiConverterTypeRestClient._handle_map.get(uniffi_handle)
+        uniffi_obj = _UniffiConverterTypeFiatService._handle_map.get(uniffi_handle)
         def make_call():
-            args = (_UniffiConverterString.lift(url), _UniffiConverterOptionalMapStringString.lift(headers), )
-            method = uniffi_obj.get
+            args = ()
+            method = uniffi_obj.fetch_fiat_currencies
             return method(*args)
 
         
@@ -1163,7 +1343,7 @@ class _UniffiTraitImplRestClient:
             uniffi_future_callback(
                 uniffi_callback_data,
                 _UniffiForeignFutureStructRustBuffer(
-                    _UniffiConverterTypeRestResponse.lower(return_value),
+                    _UniffiConverterSequenceTypeFiatCurrency.lower(return_value),
                     _UniffiRustCallStatus.default()
                 )
             )
@@ -1178,20 +1358,17 @@ class _UniffiTraitImplRestClient:
             )
         uniffi_out_return[0] = _uniffi_trait_interface_call_async_with_error(make_call, handle_success, handle_error, ServiceConnectivityError, _UniffiConverterTypeServiceConnectivityError.lower)
 
-    @_UNIFFI_CALLBACK_INTERFACE_REST_CLIENT_METHOD1
-    def post(
+    @_UNIFFI_CALLBACK_INTERFACE_FIAT_SERVICE_METHOD1
+    def fetch_fiat_rates(
             uniffi_handle,
-            url,
-            headers,
-            body,
             uniffi_future_callback,
             uniffi_callback_data,
             uniffi_out_return,
         ):
-        uniffi_obj = _UniffiConverterTypeRestClient._handle_map.get(uniffi_handle)
+        uniffi_obj = _UniffiConverterTypeFiatService._handle_map.get(uniffi_handle)
         def make_call():
-            args = (_UniffiConverterString.lift(url), _UniffiConverterOptionalMapStringString.lift(headers), _UniffiConverterOptionalString.lift(body), )
-            method = uniffi_obj.post
+            args = ()
+            method = uniffi_obj.fetch_fiat_rates
             return method(*args)
 
         
@@ -1199,7 +1376,7 @@ class _UniffiTraitImplRestClient:
             uniffi_future_callback(
                 uniffi_callback_data,
                 _UniffiForeignFutureStructRustBuffer(
-                    _UniffiConverterTypeRestResponse.lower(return_value),
+                    _UniffiConverterSequenceTypeRate.lower(return_value),
                     _UniffiRustCallStatus.default()
                 )
             )
@@ -1216,34 +1393,34 @@ class _UniffiTraitImplRestClient:
 
     @_UNIFFI_CALLBACK_INTERFACE_FREE
     def _uniffi_free(uniffi_handle):
-        _UniffiConverterTypeRestClient._handle_map.remove(uniffi_handle)
+        _UniffiConverterTypeFiatService._handle_map.remove(uniffi_handle)
 
     # Generate the FFI VTable.  This has a field for each callback interface method.
-    _uniffi_vtable = _UniffiVTableCallbackInterfaceRestClient(
-        get,
-        post,
+    _uniffi_vtable = _UniffiVTableCallbackInterfaceFiatService(
+        fetch_fiat_currencies,
+        fetch_fiat_rates,
         _uniffi_free
     )
     # Send Rust a pointer to the VTable.  Note: this means we need to keep the struct alive forever,
     # or else bad things will happen when Rust tries to access it.
-    _UniffiLib.uniffi_breez_sdk_common_fn_init_callback_vtable_restclient(ctypes.byref(_uniffi_vtable))
+    _UniffiLib.uniffi_breez_sdk_common_fn_init_callback_vtable_fiatservice(ctypes.byref(_uniffi_vtable))
 
 
 
-class _UniffiConverterTypeRestClient:
+class _UniffiConverterTypeFiatService:
     _handle_map = _UniffiHandleMap()
 
     @staticmethod
     def lift(value: int):
-        return RestClientImpl._make_instance_(value)
+        return FiatServiceImpl._make_instance_(value)
 
     @staticmethod
-    def check_lower(value: RestClient):
+    def check_lower(value: FiatService):
         pass
 
     @staticmethod
-    def lower(value: RestClient):
-        return _UniffiConverterTypeRestClient._handle_map.insert(value)
+    def lower(value: FiatService):
+        return _UniffiConverterTypeFiatService._handle_map.insert(value)
 
     @classmethod
     def read(cls, buf: _UniffiRustBuffer):
@@ -1253,74 +1430,1090 @@ class _UniffiConverterTypeRestClient:
         return cls.lift(ptr)
 
     @classmethod
-    def write(cls, value: RestClient, buf: _UniffiRustBuffer):
+    def write(cls, value: FiatService, buf: _UniffiRustBuffer):
         buf.write_u64(cls.lower(value))
 
 
-class AesSuccessActionData:
-    """
-    Payload of the AES success action, as received from the LNURL endpoint
-
-    See [`AesSuccessActionDataDecrypted`] for a similar wrapper containing the decrypted payload
-    """
-
-    description: "str"
-    """
-    Contents description, up to 144 characters
-    """
 
-    ciphertext: "str"
-    """
-    Base64, AES-encrypted data where encryption key is payment preimage, up to 4kb of characters
-    """
+class RestClient(typing.Protocol):
+    def get_request(self, url: "str",headers: "typing.Optional[dict[str, str]]"):
+        """
+        Makes a GET request and logs on DEBUG.
+        ### Arguments
+        - `url`: the URL on which GET will be called
+        - `headers`: optional headers that will be set on the request
+        """
 
-    iv: "str"
-    """
-    Base64, initialization vector, exactly 24 characters
-    """
+        raise NotImplementedError
+    def post_request(self, url: "str",headers: "typing.Optional[dict[str, str]]",body: "typing.Optional[str]"):
+        """
+        Makes a POST request, and logs on DEBUG.
+        ### Arguments
+        - `url`: the URL on which POST will be called
+        - `headers`: the optional POST headers
+        - `body`: the optional POST body
+        """
 
-    def __init__(self, *, description: "str", ciphertext: "str", iv: "str"):
-        self.description = description
-        self.ciphertext = ciphertext
-        self.iv = iv
+        raise NotImplementedError
+    def delete_request(self, url: "str",headers: "typing.Optional[dict[str, str]]",body: "typing.Optional[str]"):
+        """
+        Makes a DELETE request, and logs on DEBUG.
+        ### Arguments
+        - `url`: the URL on which DELETE will be called
+        - `headers`: the optional DELETE headers
+        - `body`: the optional DELETE body
+        """
 
-    def __str__(self):
-        return "AesSuccessActionData(description={}, ciphertext={}, iv={})".format(self.description, self.ciphertext, self.iv)
+        raise NotImplementedError
 
-    def __eq__(self, other):
-        if self.description != other.description:
-            return False
-        if self.ciphertext != other.ciphertext:
-            return False
-        if self.iv != other.iv:
-            return False
-        return True
 
-class _UniffiConverterTypeAesSuccessActionData(_UniffiConverterRustBuffer):
-    @staticmethod
-    def read(buf):
-        return AesSuccessActionData(
-            description=_UniffiConverterString.read(buf),
-            ciphertext=_UniffiConverterString.read(buf),
-            iv=_UniffiConverterString.read(buf),
-        )
+class RestClientImpl:
+    _pointer: ctypes.c_void_p
+    
+    def __init__(self, *args, **kwargs):
+        raise ValueError("This class has no default constructor")
 
-    @staticmethod
-    def check_lower(value):
-        _UniffiConverterString.check_lower(value.description)
-        _UniffiConverterString.check_lower(value.ciphertext)
-        _UniffiConverterString.check_lower(value.iv)
+    def __del__(self):
+        # In case of partial initialization of instances.
+        pointer = getattr(self, "_pointer", None)
+        if pointer is not None:
+            _uniffi_rust_call(_UniffiLib.uniffi_breez_sdk_common_fn_free_restclient, pointer)
 
-    @staticmethod
-    def write(value, buf):
-        _UniffiConverterString.write(value.description, buf)
-        _UniffiConverterString.write(value.ciphertext, buf)
-        _UniffiConverterString.write(value.iv, buf)
+    def _uniffi_clone_pointer(self):
+        return _uniffi_rust_call(_UniffiLib.uniffi_breez_sdk_common_fn_clone_restclient, self._pointer)
 
+    # Used by alternative constructors or any methods which return this type.
+    @classmethod
+    def _make_instance_(cls, pointer):
+        # Lightly yucky way to bypass the usual __init__ logic
+        # and just create a new instance with the required pointer.
+        inst = cls.__new__(cls)
+        inst._pointer = pointer
+        return inst
 
-class AesSuccessActionDataDecrypted:
-    """
-    Wrapper for the decrypted [`AesSuccessActionData`] payload
+    async def get_request(self, url: "str",headers: "typing.Optional[dict[str, str]]") -> "RestResponse":
+        """
+        Makes a GET request and logs on DEBUG.
+        ### Arguments
+        - `url`: the URL on which GET will be called
+        - `headers`: optional headers that will be set on the request
+        """
+
+        _UniffiConverterString.check_lower(url)
+        
+        _UniffiConverterOptionalMapStringString.check_lower(headers)
+        
+        return await _uniffi_rust_call_async(
+            _UniffiLib.uniffi_breez_sdk_common_fn_method_restclient_get_request(
+                self._uniffi_clone_pointer(), 
+        _UniffiConverterString.lower(url),
+        _UniffiConverterOptionalMapStringString.lower(headers)
+            ),
+            _UniffiLib.ffi_breez_sdk_common_rust_future_poll_rust_buffer,
+            _UniffiLib.ffi_breez_sdk_common_rust_future_complete_rust_buffer,
+            _UniffiLib.ffi_breez_sdk_common_rust_future_free_rust_buffer,
+            # lift function
+            _UniffiConverterTypeRestResponse.lift,
+            
+    # Error FFI converter
+_UniffiConverterTypeServiceConnectivityError,
+
+        )
+
+
+
+    async def post_request(self, url: "str",headers: "typing.Optional[dict[str, str]]",body: "typing.Optional[str]") -> "RestResponse":
+        """
+        Makes a POST request, and logs on DEBUG.
+        ### Arguments
+        - `url`: the URL on which POST will be called
+        - `headers`: the optional POST headers
+        - `body`: the optional POST body
+        """
+
+        _UniffiConverterString.check_lower(url)
+        
+        _UniffiConverterOptionalMapStringString.check_lower(headers)
+        
+        _UniffiConverterOptionalString.check_lower(body)
+        
+        return await _uniffi_rust_call_async(
+            _UniffiLib.uniffi_breez_sdk_common_fn_method_restclient_post_request(
+                self._uniffi_clone_pointer(), 
+        _UniffiConverterString.lower(url),
+        _UniffiConverterOptionalMapStringString.lower(headers),
+        _UniffiConverterOptionalString.lower(body)
+            ),
+            _UniffiLib.ffi_breez_sdk_common_rust_future_poll_rust_buffer,
+            _UniffiLib.ffi_breez_sdk_common_rust_future_complete_rust_buffer,
+            _UniffiLib.ffi_breez_sdk_common_rust_future_free_rust_buffer,
+            # lift function
+            _UniffiConverterTypeRestResponse.lift,
+            
+    # Error FFI converter
+_UniffiConverterTypeServiceConnectivityError,
+
+        )
+
+
+
+    async def delete_request(self, url: "str",headers: "typing.Optional[dict[str, str]]",body: "typing.Optional[str]") -> "RestResponse":
+        """
+        Makes a DELETE request, and logs on DEBUG.
+        ### Arguments
+        - `url`: the URL on which DELETE will be called
+        - `headers`: the optional DELETE headers
+        - `body`: the optional DELETE body
+        """
+
+        _UniffiConverterString.check_lower(url)
+        
+        _UniffiConverterOptionalMapStringString.check_lower(headers)
+        
+        _UniffiConverterOptionalString.check_lower(body)
+        
+        return await _uniffi_rust_call_async(
+            _UniffiLib.uniffi_breez_sdk_common_fn_method_restclient_delete_request(
+                self._uniffi_clone_pointer(), 
+        _UniffiConverterString.lower(url),
+        _UniffiConverterOptionalMapStringString.lower(headers),
+        _UniffiConverterOptionalString.lower(body)
+            ),
+            _UniffiLib.ffi_breez_sdk_common_rust_future_poll_rust_buffer,
+            _UniffiLib.ffi_breez_sdk_common_rust_future_complete_rust_buffer,
+            _UniffiLib.ffi_breez_sdk_common_rust_future_free_rust_buffer,
+            # lift function
+            _UniffiConverterTypeRestResponse.lift,
+            
+    # Error FFI converter
+_UniffiConverterTypeServiceConnectivityError,
+
+        )
+
+
+
+
+# Put all the bits inside a class to keep the top-level namespace clean
+class _UniffiTraitImplRestClient:
+    # For each method, generate a callback function to pass to Rust
+
+    @_UNIFFI_CALLBACK_INTERFACE_REST_CLIENT_METHOD0
+    def get_request(
+            uniffi_handle,
+            url,
+            headers,
+            uniffi_future_callback,
+            uniffi_callback_data,
+            uniffi_out_return,
+        ):
+        uniffi_obj = _UniffiConverterTypeRestClient._handle_map.get(uniffi_handle)
+        def make_call():
+            args = (_UniffiConverterString.lift(url), _UniffiConverterOptionalMapStringString.lift(headers), )
+            method = uniffi_obj.get_request
+            return method(*args)
+
+        
+        def handle_success(return_value):
+            uniffi_future_callback(
+                uniffi_callback_data,
+                _UniffiForeignFutureStructRustBuffer(
+                    _UniffiConverterTypeRestResponse.lower(return_value),
+                    _UniffiRustCallStatus.default()
+                )
+            )
+
+        def handle_error(status_code, rust_buffer):
+            uniffi_future_callback(
+                uniffi_callback_data,
+                _UniffiForeignFutureStructRustBuffer(
+                    _UniffiRustBuffer.default(),
+                    _UniffiRustCallStatus(status_code, rust_buffer),
+                )
+            )
+        uniffi_out_return[0] = _uniffi_trait_interface_call_async_with_error(make_call, handle_success, handle_error, ServiceConnectivityError, _UniffiConverterTypeServiceConnectivityError.lower)
+
+    @_UNIFFI_CALLBACK_INTERFACE_REST_CLIENT_METHOD1
+    def post_request(
+            uniffi_handle,
+            url,
+            headers,
+            body,
+            uniffi_future_callback,
+            uniffi_callback_data,
+            uniffi_out_return,
+        ):
+        uniffi_obj = _UniffiConverterTypeRestClient._handle_map.get(uniffi_handle)
+        def make_call():
+            args = (_UniffiConverterString.lift(url), _UniffiConverterOptionalMapStringString.lift(headers), _UniffiConverterOptionalString.lift(body), )
+            method = uniffi_obj.post_request
+            return method(*args)
+
+        
+        def handle_success(return_value):
+            uniffi_future_callback(
+                uniffi_callback_data,
+                _UniffiForeignFutureStructRustBuffer(
+                    _UniffiConverterTypeRestResponse.lower(return_value),
+                    _UniffiRustCallStatus.default()
+                )
+            )
+
+        def handle_error(status_code, rust_buffer):
+            uniffi_future_callback(
+                uniffi_callback_data,
+                _UniffiForeignFutureStructRustBuffer(
+                    _UniffiRustBuffer.default(),
+                    _UniffiRustCallStatus(status_code, rust_buffer),
+                )
+            )
+        uniffi_out_return[0] = _uniffi_trait_interface_call_async_with_error(make_call, handle_success, handle_error, ServiceConnectivityError, _UniffiConverterTypeServiceConnectivityError.lower)
+
+    @_UNIFFI_CALLBACK_INTERFACE_REST_CLIENT_METHOD2
+    def delete_request(
+            uniffi_handle,
+            url,
+            headers,
+            body,
+            uniffi_future_callback,
+            uniffi_callback_data,
+            uniffi_out_return,
+        ):
+        uniffi_obj = _UniffiConverterTypeRestClient._handle_map.get(uniffi_handle)
+        def make_call():
+            args = (_UniffiConverterString.lift(url), _UniffiConverterOptionalMapStringString.lift(headers), _UniffiConverterOptionalString.lift(body), )
+            method = uniffi_obj.delete_request
+            return method(*args)
+
+        
+        def handle_success(return_value):
+            uniffi_future_callback(
+                uniffi_callback_data,
+                _UniffiForeignFutureStructRustBuffer(
+                    _UniffiConverterTypeRestResponse.lower(return_value),
+                    _UniffiRustCallStatus.default()
+                )
+            )
+
+        def handle_error(status_code, rust_buffer):
+            uniffi_future_callback(
+                uniffi_callback_data,
+                _UniffiForeignFutureStructRustBuffer(
+                    _UniffiRustBuffer.default(),
+                    _UniffiRustCallStatus(status_code, rust_buffer),
+                )
+            )
+        uniffi_out_return[0] = _uniffi_trait_interface_call_async_with_error(make_call, handle_success, handle_error, ServiceConnectivityError, _UniffiConverterTypeServiceConnectivityError.lower)
+
+    @_UNIFFI_CALLBACK_INTERFACE_FREE
+    def _uniffi_free(uniffi_handle):
+        _UniffiConverterTypeRestClient._handle_map.remove(uniffi_handle)
+
+    # Generate the FFI VTable.  This has a field for each callback interface method.
+    _uniffi_vtable = _UniffiVTableCallbackInterfaceRestClient(
+        get_request,
+        post_request,
+        delete_request,
+        _uniffi_free
+    )
+    # Send Rust a pointer to the VTable.  Note: this means we need to keep the struct alive forever,
+    # or else bad things will happen when Rust tries to access it.
+    _UniffiLib.uniffi_breez_sdk_common_fn_init_callback_vtable_restclient(ctypes.byref(_uniffi_vtable))
+
+
+
+class _UniffiConverterTypeRestClient:
+    _handle_map = _UniffiHandleMap()
+
+    @staticmethod
+    def lift(value: int):
+        return RestClientImpl._make_instance_(value)
+
+    @staticmethod
+    def check_lower(value: RestClient):
+        pass
+
+    @staticmethod
+    def lower(value: RestClient):
+        return _UniffiConverterTypeRestClient._handle_map.insert(value)
+
+    @classmethod
+    def read(cls, buf: _UniffiRustBuffer):
+        ptr = buf.read_u64()
+        if ptr == 0:
+            raise InternalError("Raw pointer value was null")
+        return cls.lift(ptr)
+
+    @classmethod
+    def write(cls, value: RestClient, buf: _UniffiRustBuffer):
+        buf.write_u64(cls.lower(value))
+
+
+
+class SyncStorage(typing.Protocol):
+    def add_outgoing_change(self, record: "UnversionedRecordChange"):
+        raise NotImplementedError
+    def complete_outgoing_sync(self, record: "Record"):
+        raise NotImplementedError
+    def get_pending_outgoing_changes(self, limit: "int"):
+        raise NotImplementedError
+    def get_last_revision(self, ):
+        """
+        Get the revision number of the last synchronized record
+        """
+
+        raise NotImplementedError
+    def insert_incoming_records(self, records: "typing.List[Record]"):
+        """
+        Insert incoming records from remote sync
+        """
+
+        raise NotImplementedError
+    def delete_incoming_record(self, record: "Record"):
+        """
+        Delete an incoming record after it has been processed
+        """
+
+        raise NotImplementedError
+    def rebase_pending_outgoing_records(self, revision: "int"):
+        """
+        Update revision numbers of pending outgoing records to be higher than the given revision
+        """
+
+        raise NotImplementedError
+    def get_incoming_records(self, limit: "int"):
+        """
+        Get incoming records that need to be processed, up to the specified limit
+        """
+
+        raise NotImplementedError
+    def get_latest_outgoing_change(self, ):
+        """
+        Get the latest outgoing record if any exists
+        """
+
+        raise NotImplementedError
+    def update_record_from_incoming(self, record: "Record"):
+        """
+        Update the sync state record from an incoming record
+        """
+
+        raise NotImplementedError
+
+
+class SyncStorageImpl:
+    _pointer: ctypes.c_void_p
+    
+    def __init__(self, *args, **kwargs):
+        raise ValueError("This class has no default constructor")
+
+    def __del__(self):
+        # In case of partial initialization of instances.
+        pointer = getattr(self, "_pointer", None)
+        if pointer is not None:
+            _uniffi_rust_call(_UniffiLib.uniffi_breez_sdk_common_fn_free_syncstorage, pointer)
+
+    def _uniffi_clone_pointer(self):
+        return _uniffi_rust_call(_UniffiLib.uniffi_breez_sdk_common_fn_clone_syncstorage, self._pointer)
+
+    # Used by alternative constructors or any methods which return this type.
+    @classmethod
+    def _make_instance_(cls, pointer):
+        # Lightly yucky way to bypass the usual __init__ logic
+        # and just create a new instance with the required pointer.
+        inst = cls.__new__(cls)
+        inst._pointer = pointer
+        return inst
+
+    async def add_outgoing_change(self, record: "UnversionedRecordChange") -> "int":
+        _UniffiConverterTypeUnversionedRecordChange.check_lower(record)
+        
+        return await _uniffi_rust_call_async(
+            _UniffiLib.uniffi_breez_sdk_common_fn_method_syncstorage_add_outgoing_change(
+                self._uniffi_clone_pointer(), 
+        _UniffiConverterTypeUnversionedRecordChange.lower(record)
+            ),
+            _UniffiLib.ffi_breez_sdk_common_rust_future_poll_u64,
+            _UniffiLib.ffi_breez_sdk_common_rust_future_complete_u64,
+            _UniffiLib.ffi_breez_sdk_common_rust_future_free_u64,
+            # lift function
+            _UniffiConverterUInt64.lift,
+            
+    # Error FFI converter
+_UniffiConverterTypeSyncStorageError,
+
+        )
+
+
+
+    async def complete_outgoing_sync(self, record: "Record") -> None:
+
+        _UniffiConverterTypeRecord.check_lower(record)
+        
+        return await _uniffi_rust_call_async(
+            _UniffiLib.uniffi_breez_sdk_common_fn_method_syncstorage_complete_outgoing_sync(
+                self._uniffi_clone_pointer(), 
+        _UniffiConverterTypeRecord.lower(record)
+            ),
+            _UniffiLib.ffi_breez_sdk_common_rust_future_poll_void,
+            _UniffiLib.ffi_breez_sdk_common_rust_future_complete_void,
+            _UniffiLib.ffi_breez_sdk_common_rust_future_free_void,
+            # lift function
+            lambda val: None,
+            
+            
+    # Error FFI converter
+_UniffiConverterTypeSyncStorageError,
+
+        )
+
+
+
+    async def get_pending_outgoing_changes(self, limit: "int") -> "typing.List[OutgoingChange]":
+        _UniffiConverterUInt32.check_lower(limit)
+        
+        return await _uniffi_rust_call_async(
+            _UniffiLib.uniffi_breez_sdk_common_fn_method_syncstorage_get_pending_outgoing_changes(
+                self._uniffi_clone_pointer(), 
+        _UniffiConverterUInt32.lower(limit)
+            ),
+            _UniffiLib.ffi_breez_sdk_common_rust_future_poll_rust_buffer,
+            _UniffiLib.ffi_breez_sdk_common_rust_future_complete_rust_buffer,
+            _UniffiLib.ffi_breez_sdk_common_rust_future_free_rust_buffer,
+            # lift function
+            _UniffiConverterSequenceTypeOutgoingChange.lift,
+            
+    # Error FFI converter
+_UniffiConverterTypeSyncStorageError,
+
+        )
+
+
+
+    async def get_last_revision(self, ) -> "int":
+        """
+        Get the revision number of the last synchronized record
+        """
+
+        return await _uniffi_rust_call_async(
+            _UniffiLib.uniffi_breez_sdk_common_fn_method_syncstorage_get_last_revision(
+                self._uniffi_clone_pointer(), 
+            ),
+            _UniffiLib.ffi_breez_sdk_common_rust_future_poll_u64,
+            _UniffiLib.ffi_breez_sdk_common_rust_future_complete_u64,
+            _UniffiLib.ffi_breez_sdk_common_rust_future_free_u64,
+            # lift function
+            _UniffiConverterUInt64.lift,
+            
+    # Error FFI converter
+_UniffiConverterTypeSyncStorageError,
+
+        )
+
+
+
+    async def insert_incoming_records(self, records: "typing.List[Record]") -> None:
+
+        """
+        Insert incoming records from remote sync
+        """
+
+        _UniffiConverterSequenceTypeRecord.check_lower(records)
+        
+        return await _uniffi_rust_call_async(
+            _UniffiLib.uniffi_breez_sdk_common_fn_method_syncstorage_insert_incoming_records(
+                self._uniffi_clone_pointer(), 
+        _UniffiConverterSequenceTypeRecord.lower(records)
+            ),
+            _UniffiLib.ffi_breez_sdk_common_rust_future_poll_void,
+            _UniffiLib.ffi_breez_sdk_common_rust_future_complete_void,
+            _UniffiLib.ffi_breez_sdk_common_rust_future_free_void,
+            # lift function
+            lambda val: None,
+            
+            
+    # Error FFI converter
+_UniffiConverterTypeSyncStorageError,
+
+        )
+
+
+
+    async def delete_incoming_record(self, record: "Record") -> None:
+
+        """
+        Delete an incoming record after it has been processed
+        """
+
+        _UniffiConverterTypeRecord.check_lower(record)
+        
+        return await _uniffi_rust_call_async(
+            _UniffiLib.uniffi_breez_sdk_common_fn_method_syncstorage_delete_incoming_record(
+                self._uniffi_clone_pointer(), 
+        _UniffiConverterTypeRecord.lower(record)
+            ),
+            _UniffiLib.ffi_breez_sdk_common_rust_future_poll_void,
+            _UniffiLib.ffi_breez_sdk_common_rust_future_complete_void,
+            _UniffiLib.ffi_breez_sdk_common_rust_future_free_void,
+            # lift function
+            lambda val: None,
+            
+            
+    # Error FFI converter
+_UniffiConverterTypeSyncStorageError,
+
+        )
+
+
+
+    async def rebase_pending_outgoing_records(self, revision: "int") -> None:
+
+        """
+        Update revision numbers of pending outgoing records to be higher than the given revision
+        """
+
+        _UniffiConverterUInt64.check_lower(revision)
+        
+        return await _uniffi_rust_call_async(
+            _UniffiLib.uniffi_breez_sdk_common_fn_method_syncstorage_rebase_pending_outgoing_records(
+                self._uniffi_clone_pointer(), 
+        _UniffiConverterUInt64.lower(revision)
+            ),
+            _UniffiLib.ffi_breez_sdk_common_rust_future_poll_void,
+            _UniffiLib.ffi_breez_sdk_common_rust_future_complete_void,
+            _UniffiLib.ffi_breez_sdk_common_rust_future_free_void,
+            # lift function
+            lambda val: None,
+            
+            
+    # Error FFI converter
+_UniffiConverterTypeSyncStorageError,
+
+        )
+
+
+
+    async def get_incoming_records(self, limit: "int") -> "typing.List[IncomingChange]":
+        """
+        Get incoming records that need to be processed, up to the specified limit
+        """
+
+        _UniffiConverterUInt32.check_lower(limit)
+        
+        return await _uniffi_rust_call_async(
+            _UniffiLib.uniffi_breez_sdk_common_fn_method_syncstorage_get_incoming_records(
+                self._uniffi_clone_pointer(), 
+        _UniffiConverterUInt32.lower(limit)
+            ),
+            _UniffiLib.ffi_breez_sdk_common_rust_future_poll_rust_buffer,
+            _UniffiLib.ffi_breez_sdk_common_rust_future_complete_rust_buffer,
+            _UniffiLib.ffi_breez_sdk_common_rust_future_free_rust_buffer,
+            # lift function
+            _UniffiConverterSequenceTypeIncomingChange.lift,
+            
+    # Error FFI converter
+_UniffiConverterTypeSyncStorageError,
+
+        )
+
+
+
+    async def get_latest_outgoing_change(self, ) -> "typing.Optional[OutgoingChange]":
+        """
+        Get the latest outgoing record if any exists
+        """
+
+        return await _uniffi_rust_call_async(
+            _UniffiLib.uniffi_breez_sdk_common_fn_method_syncstorage_get_latest_outgoing_change(
+                self._uniffi_clone_pointer(), 
+            ),
+            _UniffiLib.ffi_breez_sdk_common_rust_future_poll_rust_buffer,
+            _UniffiLib.ffi_breez_sdk_common_rust_future_complete_rust_buffer,
+            _UniffiLib.ffi_breez_sdk_common_rust_future_free_rust_buffer,
+            # lift function
+            _UniffiConverterOptionalTypeOutgoingChange.lift,
+            
+    # Error FFI converter
+_UniffiConverterTypeSyncStorageError,
+
+        )
+
+
+
+    async def update_record_from_incoming(self, record: "Record") -> None:
+
+        """
+        Update the sync state record from an incoming record
+        """
+
+        _UniffiConverterTypeRecord.check_lower(record)
+        
+        return await _uniffi_rust_call_async(
+            _UniffiLib.uniffi_breez_sdk_common_fn_method_syncstorage_update_record_from_incoming(
+                self._uniffi_clone_pointer(), 
+        _UniffiConverterTypeRecord.lower(record)
+            ),
+            _UniffiLib.ffi_breez_sdk_common_rust_future_poll_void,
+            _UniffiLib.ffi_breez_sdk_common_rust_future_complete_void,
+            _UniffiLib.ffi_breez_sdk_common_rust_future_free_void,
+            # lift function
+            lambda val: None,
+            
+            
+    # Error FFI converter
+_UniffiConverterTypeSyncStorageError,
+
+        )
+
+
+
+
+# Put all the bits inside a class to keep the top-level namespace clean
+class _UniffiTraitImplSyncStorage:
+    # For each method, generate a callback function to pass to Rust
+
+    @_UNIFFI_CALLBACK_INTERFACE_SYNC_STORAGE_METHOD0
+    def add_outgoing_change(
+            uniffi_handle,
+            record,
+            uniffi_future_callback,
+            uniffi_callback_data,
+            uniffi_out_return,
+        ):
+        uniffi_obj = _UniffiConverterTypeSyncStorage._handle_map.get(uniffi_handle)
+        def make_call():
+            args = (_UniffiConverterTypeUnversionedRecordChange.lift(record), )
+            method = uniffi_obj.add_outgoing_change
+            return method(*args)
+
+        
+        def handle_success(return_value):
+            uniffi_future_callback(
+                uniffi_callback_data,
+                _UniffiForeignFutureStructU64(
+                    _UniffiConverterUInt64.lower(return_value),
+                    _UniffiRustCallStatus.default()
+                )
+            )
+
+        def handle_error(status_code, rust_buffer):
+            uniffi_future_callback(
+                uniffi_callback_data,
+                _UniffiForeignFutureStructU64(
+                    0,
+                    _UniffiRustCallStatus(status_code, rust_buffer),
+                )
+            )
+        uniffi_out_return[0] = _uniffi_trait_interface_call_async_with_error(make_call, handle_success, handle_error, SyncStorageError, _UniffiConverterTypeSyncStorageError.lower)
+
+    @_UNIFFI_CALLBACK_INTERFACE_SYNC_STORAGE_METHOD1
+    def complete_outgoing_sync(
+            uniffi_handle,
+            record,
+            uniffi_future_callback,
+            uniffi_callback_data,
+            uniffi_out_return,
+        ):
+        uniffi_obj = _UniffiConverterTypeSyncStorage._handle_map.get(uniffi_handle)
+        def make_call():
+            args = (_UniffiConverterTypeRecord.lift(record), )
+            method = uniffi_obj.complete_outgoing_sync
+            return method(*args)
+
+        
+        def handle_success(return_value):
+            uniffi_future_callback(
+                uniffi_callback_data,
+                _UniffiForeignFutureStructVoid(
+                    _UniffiRustCallStatus.default()
+                )
+            )
+
+        def handle_error(status_code, rust_buffer):
+            uniffi_future_callback(
+                uniffi_callback_data,
+                _UniffiForeignFutureStructVoid(
+                    _UniffiRustCallStatus(status_code, rust_buffer),
+                )
+            )
+        uniffi_out_return[0] = _uniffi_trait_interface_call_async_with_error(make_call, handle_success, handle_error, SyncStorageError, _UniffiConverterTypeSyncStorageError.lower)
+
+    @_UNIFFI_CALLBACK_INTERFACE_SYNC_STORAGE_METHOD2
+    def get_pending_outgoing_changes(
+            uniffi_handle,
+            limit,
+            uniffi_future_callback,
+            uniffi_callback_data,
+            uniffi_out_return,
+        ):
+        uniffi_obj = _UniffiConverterTypeSyncStorage._handle_map.get(uniffi_handle)
+        def make_call():
+            args = (_UniffiConverterUInt32.lift(limit), )
+            method = uniffi_obj.get_pending_outgoing_changes
+            return method(*args)
+
+        
+        def handle_success(return_value):
+            uniffi_future_callback(
+                uniffi_callback_data,
+                _UniffiForeignFutureStructRustBuffer(
+                    _UniffiConverterSequenceTypeOutgoingChange.lower(return_value),
+                    _UniffiRustCallStatus.default()
+                )
+            )
+
+        def handle_error(status_code, rust_buffer):
+            uniffi_future_callback(
+                uniffi_callback_data,
+                _UniffiForeignFutureStructRustBuffer(
+                    _UniffiRustBuffer.default(),
+                    _UniffiRustCallStatus(status_code, rust_buffer),
+                )
+            )
+        uniffi_out_return[0] = _uniffi_trait_interface_call_async_with_error(make_call, handle_success, handle_error, SyncStorageError, _UniffiConverterTypeSyncStorageError.lower)
+
+    @_UNIFFI_CALLBACK_INTERFACE_SYNC_STORAGE_METHOD3
+    def get_last_revision(
+            uniffi_handle,
+            uniffi_future_callback,
+            uniffi_callback_data,
+            uniffi_out_return,
+        ):
+        uniffi_obj = _UniffiConverterTypeSyncStorage._handle_map.get(uniffi_handle)
+        def make_call():
+            args = ()
+            method = uniffi_obj.get_last_revision
+            return method(*args)
+
+        
+        def handle_success(return_value):
+            uniffi_future_callback(
+                uniffi_callback_data,
+                _UniffiForeignFutureStructU64(
+                    _UniffiConverterUInt64.lower(return_value),
+                    _UniffiRustCallStatus.default()
+                )
+            )
+
+        def handle_error(status_code, rust_buffer):
+            uniffi_future_callback(
+                uniffi_callback_data,
+                _UniffiForeignFutureStructU64(
+                    0,
+                    _UniffiRustCallStatus(status_code, rust_buffer),
+                )
+            )
+        uniffi_out_return[0] = _uniffi_trait_interface_call_async_with_error(make_call, handle_success, handle_error, SyncStorageError, _UniffiConverterTypeSyncStorageError.lower)
+
+    @_UNIFFI_CALLBACK_INTERFACE_SYNC_STORAGE_METHOD4
+    def insert_incoming_records(
+            uniffi_handle,
+            records,
+            uniffi_future_callback,
+            uniffi_callback_data,
+            uniffi_out_return,
+        ):
+        uniffi_obj = _UniffiConverterTypeSyncStorage._handle_map.get(uniffi_handle)
+        def make_call():
+            args = (_UniffiConverterSequenceTypeRecord.lift(records), )
+            method = uniffi_obj.insert_incoming_records
+            return method(*args)
+
+        
+        def handle_success(return_value):
+            uniffi_future_callback(
+                uniffi_callback_data,
+                _UniffiForeignFutureStructVoid(
+                    _UniffiRustCallStatus.default()
+                )
+            )
+
+        def handle_error(status_code, rust_buffer):
+            uniffi_future_callback(
+                uniffi_callback_data,
+                _UniffiForeignFutureStructVoid(
+                    _UniffiRustCallStatus(status_code, rust_buffer),
+                )
+            )
+        uniffi_out_return[0] = _uniffi_trait_interface_call_async_with_error(make_call, handle_success, handle_error, SyncStorageError, _UniffiConverterTypeSyncStorageError.lower)
+
+    @_UNIFFI_CALLBACK_INTERFACE_SYNC_STORAGE_METHOD5
+    def delete_incoming_record(
+            uniffi_handle,
+            record,
+            uniffi_future_callback,
+            uniffi_callback_data,
+            uniffi_out_return,
+        ):
+        uniffi_obj = _UniffiConverterTypeSyncStorage._handle_map.get(uniffi_handle)
+        def make_call():
+            args = (_UniffiConverterTypeRecord.lift(record), )
+            method = uniffi_obj.delete_incoming_record
+            return method(*args)
+
+        
+        def handle_success(return_value):
+            uniffi_future_callback(
+                uniffi_callback_data,
+                _UniffiForeignFutureStructVoid(
+                    _UniffiRustCallStatus.default()
+                )
+            )
+
+        def handle_error(status_code, rust_buffer):
+            uniffi_future_callback(
+                uniffi_callback_data,
+                _UniffiForeignFutureStructVoid(
+                    _UniffiRustCallStatus(status_code, rust_buffer),
+                )
+            )
+        uniffi_out_return[0] = _uniffi_trait_interface_call_async_with_error(make_call, handle_success, handle_error, SyncStorageError, _UniffiConverterTypeSyncStorageError.lower)
+
+    @_UNIFFI_CALLBACK_INTERFACE_SYNC_STORAGE_METHOD6
+    def rebase_pending_outgoing_records(
+            uniffi_handle,
+            revision,
+            uniffi_future_callback,
+            uniffi_callback_data,
+            uniffi_out_return,
+        ):
+        uniffi_obj = _UniffiConverterTypeSyncStorage._handle_map.get(uniffi_handle)
+        def make_call():
+            args = (_UniffiConverterUInt64.lift(revision), )
+            method = uniffi_obj.rebase_pending_outgoing_records
+            return method(*args)
+
+        
+        def handle_success(return_value):
+            uniffi_future_callback(
+                uniffi_callback_data,
+                _UniffiForeignFutureStructVoid(
+                    _UniffiRustCallStatus.default()
+                )
+            )
+
+        def handle_error(status_code, rust_buffer):
+            uniffi_future_callback(
+                uniffi_callback_data,
+                _UniffiForeignFutureStructVoid(
+                    _UniffiRustCallStatus(status_code, rust_buffer),
+                )
+            )
+        uniffi_out_return[0] = _uniffi_trait_interface_call_async_with_error(make_call, handle_success, handle_error, SyncStorageError, _UniffiConverterTypeSyncStorageError.lower)
+
+    @_UNIFFI_CALLBACK_INTERFACE_SYNC_STORAGE_METHOD7
+    def get_incoming_records(
+            uniffi_handle,
+            limit,
+            uniffi_future_callback,
+            uniffi_callback_data,
+            uniffi_out_return,
+        ):
+        uniffi_obj = _UniffiConverterTypeSyncStorage._handle_map.get(uniffi_handle)
+        def make_call():
+            args = (_UniffiConverterUInt32.lift(limit), )
+            method = uniffi_obj.get_incoming_records
+            return method(*args)
+
+        
+        def handle_success(return_value):
+            uniffi_future_callback(
+                uniffi_callback_data,
+                _UniffiForeignFutureStructRustBuffer(
+                    _UniffiConverterSequenceTypeIncomingChange.lower(return_value),
+                    _UniffiRustCallStatus.default()
+                )
+            )
+
+        def handle_error(status_code, rust_buffer):
+            uniffi_future_callback(
+                uniffi_callback_data,
+                _UniffiForeignFutureStructRustBuffer(
+                    _UniffiRustBuffer.default(),
+                    _UniffiRustCallStatus(status_code, rust_buffer),
+                )
+            )
+        uniffi_out_return[0] = _uniffi_trait_interface_call_async_with_error(make_call, handle_success, handle_error, SyncStorageError, _UniffiConverterTypeSyncStorageError.lower)
+
+    @_UNIFFI_CALLBACK_INTERFACE_SYNC_STORAGE_METHOD8
+    def get_latest_outgoing_change(
+            uniffi_handle,
+            uniffi_future_callback,
+            uniffi_callback_data,
+            uniffi_out_return,
+        ):
+        uniffi_obj = _UniffiConverterTypeSyncStorage._handle_map.get(uniffi_handle)
+        def make_call():
+            args = ()
+            method = uniffi_obj.get_latest_outgoing_change
+            return method(*args)
+
+        
+        def handle_success(return_value):
+            uniffi_future_callback(
+                uniffi_callback_data,
+                _UniffiForeignFutureStructRustBuffer(
+                    _UniffiConverterOptionalTypeOutgoingChange.lower(return_value),
+                    _UniffiRustCallStatus.default()
+                )
+            )
+
+        def handle_error(status_code, rust_buffer):
+            uniffi_future_callback(
+                uniffi_callback_data,
+                _UniffiForeignFutureStructRustBuffer(
+                    _UniffiRustBuffer.default(),
+                    _UniffiRustCallStatus(status_code, rust_buffer),
+                )
+            )
+        uniffi_out_return[0] = _uniffi_trait_interface_call_async_with_error(make_call, handle_success, handle_error, SyncStorageError, _UniffiConverterTypeSyncStorageError.lower)
+
+    @_UNIFFI_CALLBACK_INTERFACE_SYNC_STORAGE_METHOD9
+    def update_record_from_incoming(
+            uniffi_handle,
+            record,
+            uniffi_future_callback,
+            uniffi_callback_data,
+            uniffi_out_return,
+        ):
+        uniffi_obj = _UniffiConverterTypeSyncStorage._handle_map.get(uniffi_handle)
+        def make_call():
+            args = (_UniffiConverterTypeRecord.lift(record), )
+            method = uniffi_obj.update_record_from_incoming
+            return method(*args)
+
+        
+        def handle_success(return_value):
+            uniffi_future_callback(
+                uniffi_callback_data,
+                _UniffiForeignFutureStructVoid(
+                    _UniffiRustCallStatus.default()
+                )
+            )
+
+        def handle_error(status_code, rust_buffer):
+            uniffi_future_callback(
+                uniffi_callback_data,
+                _UniffiForeignFutureStructVoid(
+                    _UniffiRustCallStatus(status_code, rust_buffer),
+                )
+            )
+        uniffi_out_return[0] = _uniffi_trait_interface_call_async_with_error(make_call, handle_success, handle_error, SyncStorageError, _UniffiConverterTypeSyncStorageError.lower)
+
+    @_UNIFFI_CALLBACK_INTERFACE_FREE
+    def _uniffi_free(uniffi_handle):
+        _UniffiConverterTypeSyncStorage._handle_map.remove(uniffi_handle)
+
+    # Generate the FFI VTable.  This has a field for each callback interface method.
+    _uniffi_vtable = _UniffiVTableCallbackInterfaceSyncStorage(
+        add_outgoing_change,
+        complete_outgoing_sync,
+        get_pending_outgoing_changes,
+        get_last_revision,
+        insert_incoming_records,
+        delete_incoming_record,
+        rebase_pending_outgoing_records,
+        get_incoming_records,
+        get_latest_outgoing_change,
+        update_record_from_incoming,
+        _uniffi_free
+    )
+    # Send Rust a pointer to the VTable.  Note: this means we need to keep the struct alive forever,
+    # or else bad things will happen when Rust tries to access it.
+    _UniffiLib.uniffi_breez_sdk_common_fn_init_callback_vtable_syncstorage(ctypes.byref(_uniffi_vtable))
+
+
+
+class _UniffiConverterTypeSyncStorage:
+    _handle_map = _UniffiHandleMap()
+
+    @staticmethod
+    def lift(value: int):
+        return SyncStorageImpl._make_instance_(value)
+
+    @staticmethod
+    def check_lower(value: SyncStorage):
+        pass
+
+    @staticmethod
+    def lower(value: SyncStorage):
+        return _UniffiConverterTypeSyncStorage._handle_map.insert(value)
+
+    @classmethod
+    def read(cls, buf: _UniffiRustBuffer):
+        ptr = buf.read_u64()
+        if ptr == 0:
+            raise InternalError("Raw pointer value was null")
+        return cls.lift(ptr)
+
+    @classmethod
+    def write(cls, value: SyncStorage, buf: _UniffiRustBuffer):
+        buf.write_u64(cls.lower(value))
+
+
+class AesSuccessActionData:
+    """
+    Payload of the AES success action, as received from the LNURL endpoint
+
+    See [`AesSuccessActionDataDecrypted`] for a similar wrapper containing the decrypted payload
+    """
+
+    description: "str"
+    """
+    Contents description, up to 144 characters
+    """
+
+    ciphertext: "str"
+    """
+    Base64, AES-encrypted data where encryption key is payment preimage, up to 4kb of characters
+    """
+
+    iv: "str"
+    """
+    Base64, initialization vector, exactly 24 characters
+    """
+
+    def __init__(self, *, description: "str", ciphertext: "str", iv: "str"):
+        self.description = description
+        self.ciphertext = ciphertext
+        self.iv = iv
+
+    def __str__(self):
+        return "AesSuccessActionData(description={}, ciphertext={}, iv={})".format(self.description, self.ciphertext, self.iv)
+
+    def __eq__(self, other):
+        if self.description != other.description:
+            return False
+        if self.ciphertext != other.ciphertext:
+            return False
+        if self.iv != other.iv:
+            return False
+        return True
+
+class _UniffiConverterTypeAesSuccessActionData(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        return AesSuccessActionData(
+            description=_UniffiConverterString.read(buf),
+            ciphertext=_UniffiConverterString.read(buf),
+            iv=_UniffiConverterString.read(buf),
+        )
+
+    @staticmethod
+    def check_lower(value):
+        _UniffiConverterString.check_lower(value.description)
+        _UniffiConverterString.check_lower(value.ciphertext)
+        _UniffiConverterString.check_lower(value.iv)
+
+    @staticmethod
+    def write(value, buf):
+        _UniffiConverterString.write(value.description, buf)
+        _UniffiConverterString.write(value.ciphertext, buf)
+        _UniffiConverterString.write(value.iv, buf)
+
+
+class AesSuccessActionDataDecrypted:
+    """
+    Wrapper for the decrypted [`AesSuccessActionData`] payload
     """
 
     description: "str"
@@ -2095,6 +3288,66 @@ class _UniffiConverterTypeCurrencyInfo(_UniffiConverterRustBuffer):
         _UniffiConverterSequenceTypeLocaleOverrides.write(value.locale_overrides, buf)
 
 
+class ExternalInputParser:
+    """
+    Configuration for an external input parser
+    """
+
+    provider_id: "str"
+    """
+    An arbitrary parser provider id
+    """
+
+    input_regex: "str"
+    """
+    The external parser will be used when an input conforms to this regex
+    """
+
+    parser_url: "str"
+    """
+    The URL of the parser containing a placeholder `<input>` that will be replaced with the
+    input to be parsed. The input is sanitized using percent encoding.
+    """
+
+    def __init__(self, *, provider_id: "str", input_regex: "str", parser_url: "str"):
+        self.provider_id = provider_id
+        self.input_regex = input_regex
+        self.parser_url = parser_url
+
+    def __str__(self):
+        return "ExternalInputParser(provider_id={}, input_regex={}, parser_url={})".format(self.provider_id, self.input_regex, self.parser_url)
+
+    def __eq__(self, other):
+        if self.provider_id != other.provider_id:
+            return False
+        if self.input_regex != other.input_regex:
+            return False
+        if self.parser_url != other.parser_url:
+            return False
+        return True
+
+class _UniffiConverterTypeExternalInputParser(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        return ExternalInputParser(
+            provider_id=_UniffiConverterString.read(buf),
+            input_regex=_UniffiConverterString.read(buf),
+            parser_url=_UniffiConverterString.read(buf),
+        )
+
+    @staticmethod
+    def check_lower(value):
+        _UniffiConverterString.check_lower(value.provider_id)
+        _UniffiConverterString.check_lower(value.input_regex)
+        _UniffiConverterString.check_lower(value.parser_url)
+
+    @staticmethod
+    def write(value, buf):
+        _UniffiConverterString.write(value.provider_id, buf)
+        _UniffiConverterString.write(value.input_regex, buf)
+        _UniffiConverterString.write(value.parser_url, buf)
+
+
 class FiatCurrency:
     """
     Wrapper around the [`CurrencyInfo`] of a fiat currency
@@ -2135,6 +3388,42 @@ class _UniffiConverterTypeFiatCurrency(_UniffiConverterRustBuffer):
         _UniffiConverterTypeCurrencyInfo.write(value.info, buf)
 
 
+class IncomingChange:
+    new_state: "Record"
+    old_state: "typing.Optional[Record]"
+    def __init__(self, *, new_state: "Record", old_state: "typing.Optional[Record]"):
+        self.new_state = new_state
+        self.old_state = old_state
+
+    def __str__(self):
+        return "IncomingChange(new_state={}, old_state={})".format(self.new_state, self.old_state)
+
+    def __eq__(self, other):
+        if self.new_state != other.new_state:
+            return False
+        if self.old_state != other.old_state:
+            return False
+        return True
+
+class _UniffiConverterTypeIncomingChange(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        return IncomingChange(
+            new_state=_UniffiConverterTypeRecord.read(buf),
+            old_state=_UniffiConverterOptionalTypeRecord.read(buf),
+        )
+
+    @staticmethod
+    def check_lower(value):
+        _UniffiConverterTypeRecord.check_lower(value.new_state)
+        _UniffiConverterOptionalTypeRecord.check_lower(value.old_state)
+
+    @staticmethod
+    def write(value, buf):
+        _UniffiConverterTypeRecord.write(value.new_state, buf)
+        _UniffiConverterOptionalTypeRecord.write(value.old_state, buf)
+
+
 class LightningAddressDetails:
     address: "str"
     pay_request: "LnurlPayRequestDetails"
@@ -2319,7 +3608,7 @@ class LnurlPayRequestDetails:
     Optional lightning address if that was used to resolve the lnurl.
     """
 
-    allows_nostr: "bool"
+    allows_nostr: "typing.Optional[bool]"
     """
     Value indicating whether the recipient supports Nostr Zaps through NIP-57.
 
@@ -2335,7 +3624,7 @@ class LnurlPayRequestDetails:
     See <https://github.com/bitcoin/bips/blob/master/bip-0340.mediawiki>
     """
 
-    def __init__(self, *, callback: "str", min_sendable: "int", max_sendable: "int", metadata_str: "str", comment_allowed: "int", domain: "str", url: "str", address: "typing.Optional[str]", allows_nostr: "bool", nostr_pubkey: "typing.Optional[str]"):
+    def __init__(self, *, callback: "str", min_sendable: "int", max_sendable: "int", metadata_str: "str", comment_allowed: "int", domain: "str", url: "str", address: "typing.Optional[str]", allows_nostr: "typing.Optional[bool]", nostr_pubkey: "typing.Optional[str]"):
         self.callback = callback
         self.min_sendable = min_sendable
         self.max_sendable = max_sendable
@@ -2385,7 +3674,7 @@ class _UniffiConverterTypeLnurlPayRequestDetails(_UniffiConverterRustBuffer):
             domain=_UniffiConverterString.read(buf),
             url=_UniffiConverterString.read(buf),
             address=_UniffiConverterOptionalString.read(buf),
-            allows_nostr=_UniffiConverterBool.read(buf),
+            allows_nostr=_UniffiConverterOptionalBool.read(buf),
             nostr_pubkey=_UniffiConverterOptionalString.read(buf),
         )
 
@@ -2399,7 +3688,7 @@ class _UniffiConverterTypeLnurlPayRequestDetails(_UniffiConverterRustBuffer):
         _UniffiConverterString.check_lower(value.domain)
         _UniffiConverterString.check_lower(value.url)
         _UniffiConverterOptionalString.check_lower(value.address)
-        _UniffiConverterBool.check_lower(value.allows_nostr)
+        _UniffiConverterOptionalBool.check_lower(value.allows_nostr)
         _UniffiConverterOptionalString.check_lower(value.nostr_pubkey)
 
     @staticmethod
@@ -2412,7 +3701,7 @@ class _UniffiConverterTypeLnurlPayRequestDetails(_UniffiConverterRustBuffer):
         _UniffiConverterString.write(value.domain, buf)
         _UniffiConverterString.write(value.url, buf)
         _UniffiConverterOptionalString.write(value.address, buf)
-        _UniffiConverterBool.write(value.allows_nostr, buf)
+        _UniffiConverterOptionalBool.write(value.allows_nostr, buf)
         _UniffiConverterOptionalString.write(value.nostr_pubkey, buf)
 
 
@@ -2597,6 +3886,42 @@ class _UniffiConverterTypeMessageSuccessActionData(_UniffiConverterRustBuffer):
         _UniffiConverterString.write(value.message, buf)
 
 
+class OutgoingChange:
+    change: "RecordChange"
+    parent: "typing.Optional[Record]"
+    def __init__(self, *, change: "RecordChange", parent: "typing.Optional[Record]"):
+        self.change = change
+        self.parent = parent
+
+    def __str__(self):
+        return "OutgoingChange(change={}, parent={})".format(self.change, self.parent)
+
+    def __eq__(self, other):
+        if self.change != other.change:
+            return False
+        if self.parent != other.parent:
+            return False
+        return True
+
+class _UniffiConverterTypeOutgoingChange(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        return OutgoingChange(
+            change=_UniffiConverterTypeRecordChange.read(buf),
+            parent=_UniffiConverterOptionalTypeRecord.read(buf),
+        )
+
+    @staticmethod
+    def check_lower(value):
+        _UniffiConverterTypeRecordChange.check_lower(value.change)
+        _UniffiConverterOptionalTypeRecord.check_lower(value.parent)
+
+    @staticmethod
+    def write(value, buf):
+        _UniffiConverterTypeRecordChange.write(value.change, buf)
+        _UniffiConverterOptionalTypeRecord.write(value.parent, buf)
+
+
 class PaymentRequestSource:
     bip_21_uri: "typing.Optional[str]"
     bip_353_address: "typing.Optional[str]"
@@ -2673,6 +3998,142 @@ class _UniffiConverterTypeRate(_UniffiConverterRustBuffer):
         _UniffiConverterDouble.write(value.value, buf)
 
 
+class Record:
+    id: "RecordId"
+    revision: "int"
+    schema_version: "str"
+    data: "dict[str, str]"
+    def __init__(self, *, id: "RecordId", revision: "int", schema_version: "str", data: "dict[str, str]"):
+        self.id = id
+        self.revision = revision
+        self.schema_version = schema_version
+        self.data = data
+
+    def __str__(self):
+        return "Record(id={}, revision={}, schema_version={}, data={})".format(self.id, self.revision, self.schema_version, self.data)
+
+    def __eq__(self, other):
+        if self.id != other.id:
+            return False
+        if self.revision != other.revision:
+            return False
+        if self.schema_version != other.schema_version:
+            return False
+        if self.data != other.data:
+            return False
+        return True
+
+class _UniffiConverterTypeRecord(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        return Record(
+            id=_UniffiConverterTypeRecordId.read(buf),
+            revision=_UniffiConverterUInt64.read(buf),
+            schema_version=_UniffiConverterString.read(buf),
+            data=_UniffiConverterMapStringString.read(buf),
+        )
+
+    @staticmethod
+    def check_lower(value):
+        _UniffiConverterTypeRecordId.check_lower(value.id)
+        _UniffiConverterUInt64.check_lower(value.revision)
+        _UniffiConverterString.check_lower(value.schema_version)
+        _UniffiConverterMapStringString.check_lower(value.data)
+
+    @staticmethod
+    def write(value, buf):
+        _UniffiConverterTypeRecordId.write(value.id, buf)
+        _UniffiConverterUInt64.write(value.revision, buf)
+        _UniffiConverterString.write(value.schema_version, buf)
+        _UniffiConverterMapStringString.write(value.data, buf)
+
+
+class RecordChange:
+    id: "RecordId"
+    schema_version: "str"
+    updated_fields: "dict[str, str]"
+    revision: "int"
+    def __init__(self, *, id: "RecordId", schema_version: "str", updated_fields: "dict[str, str]", revision: "int"):
+        self.id = id
+        self.schema_version = schema_version
+        self.updated_fields = updated_fields
+        self.revision = revision
+
+    def __str__(self):
+        return "RecordChange(id={}, schema_version={}, updated_fields={}, revision={})".format(self.id, self.schema_version, self.updated_fields, self.revision)
+
+    def __eq__(self, other):
+        if self.id != other.id:
+            return False
+        if self.schema_version != other.schema_version:
+            return False
+        if self.updated_fields != other.updated_fields:
+            return False
+        if self.revision != other.revision:
+            return False
+        return True
+
+class _UniffiConverterTypeRecordChange(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        return RecordChange(
+            id=_UniffiConverterTypeRecordId.read(buf),
+            schema_version=_UniffiConverterString.read(buf),
+            updated_fields=_UniffiConverterMapStringString.read(buf),
+            revision=_UniffiConverterUInt64.read(buf),
+        )
+
+    @staticmethod
+    def check_lower(value):
+        _UniffiConverterTypeRecordId.check_lower(value.id)
+        _UniffiConverterString.check_lower(value.schema_version)
+        _UniffiConverterMapStringString.check_lower(value.updated_fields)
+        _UniffiConverterUInt64.check_lower(value.revision)
+
+    @staticmethod
+    def write(value, buf):
+        _UniffiConverterTypeRecordId.write(value.id, buf)
+        _UniffiConverterString.write(value.schema_version, buf)
+        _UniffiConverterMapStringString.write(value.updated_fields, buf)
+        _UniffiConverterUInt64.write(value.revision, buf)
+
+
+class RecordId:
+    type: "str"
+    data_id: "str"
+    def __init__(self, *, type: "str", data_id: "str"):
+        self.type = type
+        self.data_id = data_id
+
+    def __str__(self):
+        return "RecordId(type={}, data_id={})".format(self.type, self.data_id)
+
+    def __eq__(self, other):
+        if self.type != other.type:
+            return False
+        if self.data_id != other.data_id:
+            return False
+        return True
+
+class _UniffiConverterTypeRecordId(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        return RecordId(
+            type=_UniffiConverterString.read(buf),
+            data_id=_UniffiConverterString.read(buf),
+        )
+
+    @staticmethod
+    def check_lower(value):
+        _UniffiConverterString.check_lower(value.type)
+        _UniffiConverterString.check_lower(value.data_id)
+
+    @staticmethod
+    def write(value, buf):
+        _UniffiConverterString.write(value.type, buf)
+        _UniffiConverterString.write(value.data_id, buf)
+
+
 class RestResponse:
     status: "int"
     body: "str"
@@ -2681,60 +4142,116 @@ class RestResponse:
         self.body = body
 
     def __str__(self):
-        return "RestResponse(status={}, body={})".format(self.status, self.body)
+        return "RestResponse(status={}, body={})".format(self.status, self.body)
+
+    def __eq__(self, other):
+        if self.status != other.status:
+            return False
+        if self.body != other.body:
+            return False
+        return True
+
+class _UniffiConverterTypeRestResponse(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        return RestResponse(
+            status=_UniffiConverterUInt16.read(buf),
+            body=_UniffiConverterString.read(buf),
+        )
+
+    @staticmethod
+    def check_lower(value):
+        _UniffiConverterUInt16.check_lower(value.status)
+        _UniffiConverterString.check_lower(value.body)
+
+    @staticmethod
+    def write(value, buf):
+        _UniffiConverterUInt16.write(value.status, buf)
+        _UniffiConverterString.write(value.body, buf)
+
+
+class SilentPaymentAddressDetails:
+    address: "str"
+    network: "BitcoinNetwork"
+    source: "PaymentRequestSource"
+    def __init__(self, *, address: "str", network: "BitcoinNetwork", source: "PaymentRequestSource"):
+        self.address = address
+        self.network = network
+        self.source = source
+
+    def __str__(self):
+        return "SilentPaymentAddressDetails(address={}, network={}, source={})".format(self.address, self.network, self.source)
 
     def __eq__(self, other):
-        if self.status != other.status:
+        if self.address != other.address:
             return False
-        if self.body != other.body:
+        if self.network != other.network:
+            return False
+        if self.source != other.source:
             return False
         return True
 
-class _UniffiConverterTypeRestResponse(_UniffiConverterRustBuffer):
+class _UniffiConverterTypeSilentPaymentAddressDetails(_UniffiConverterRustBuffer):
     @staticmethod
     def read(buf):
-        return RestResponse(
-            status=_UniffiConverterUInt16.read(buf),
-            body=_UniffiConverterString.read(buf),
+        return SilentPaymentAddressDetails(
+            address=_UniffiConverterString.read(buf),
+            network=_UniffiConverterTypeBitcoinNetwork.read(buf),
+            source=_UniffiConverterTypePaymentRequestSource.read(buf),
         )
 
     @staticmethod
     def check_lower(value):
-        _UniffiConverterUInt16.check_lower(value.status)
-        _UniffiConverterString.check_lower(value.body)
+        _UniffiConverterString.check_lower(value.address)
+        _UniffiConverterTypeBitcoinNetwork.check_lower(value.network)
+        _UniffiConverterTypePaymentRequestSource.check_lower(value.source)
 
     @staticmethod
     def write(value, buf):
-        _UniffiConverterUInt16.write(value.status, buf)
-        _UniffiConverterString.write(value.body, buf)
+        _UniffiConverterString.write(value.address, buf)
+        _UniffiConverterTypeBitcoinNetwork.write(value.network, buf)
+        _UniffiConverterTypePaymentRequestSource.write(value.source, buf)
 
 
-class SilentPaymentAddressDetails:
+class SparkAddressDetails:
     address: "str"
+    """
+    The raw address string
+    """
+
+    identity_public_key: "str"
+    """
+    The identity public key of the address owner
+    """
+
     network: "BitcoinNetwork"
     source: "PaymentRequestSource"
-    def __init__(self, *, address: "str", network: "BitcoinNetwork", source: "PaymentRequestSource"):
+    def __init__(self, *, address: "str", identity_public_key: "str", network: "BitcoinNetwork", source: "PaymentRequestSource"):
         self.address = address
+        self.identity_public_key = identity_public_key
         self.network = network
         self.source = source
 
     def __str__(self):
-        return "SilentPaymentAddressDetails(address={}, network={}, source={})".format(self.address, self.network, self.source)
+        return "SparkAddressDetails(address={}, identity_public_key={}, network={}, source={})".format(self.address, self.identity_public_key, self.network, self.source)
 
     def __eq__(self, other):
         if self.address != other.address:
             return False
+        if self.identity_public_key != other.identity_public_key:
+            return False
         if self.network != other.network:
             return False
         if self.source != other.source:
             return False
         return True
 
-class _UniffiConverterTypeSilentPaymentAddressDetails(_UniffiConverterRustBuffer):
+class _UniffiConverterTypeSparkAddressDetails(_UniffiConverterRustBuffer):
     @staticmethod
     def read(buf):
-        return SilentPaymentAddressDetails(
+        return SparkAddressDetails(
             address=_UniffiConverterString.read(buf),
+            identity_public_key=_UniffiConverterString.read(buf),
             network=_UniffiConverterTypeBitcoinNetwork.read(buf),
             source=_UniffiConverterTypePaymentRequestSource.read(buf),
         )
@@ -2742,16 +4259,124 @@ class _UniffiConverterTypeSilentPaymentAddressDetails(_UniffiConverterRustBuffer
     @staticmethod
     def check_lower(value):
         _UniffiConverterString.check_lower(value.address)
+        _UniffiConverterString.check_lower(value.identity_public_key)
         _UniffiConverterTypeBitcoinNetwork.check_lower(value.network)
         _UniffiConverterTypePaymentRequestSource.check_lower(value.source)
 
     @staticmethod
     def write(value, buf):
         _UniffiConverterString.write(value.address, buf)
+        _UniffiConverterString.write(value.identity_public_key, buf)
         _UniffiConverterTypeBitcoinNetwork.write(value.network, buf)
         _UniffiConverterTypePaymentRequestSource.write(value.source, buf)
 
 
+class SparkInvoiceDetails:
+    invoice: "str"
+    """
+    The raw invoice string
+    """
+
+    identity_public_key: "str"
+    """
+    The identity public key of the invoice issuer
+    """
+
+    network: "BitcoinNetwork"
+    amount: "typing.Optional[CommonU128]"
+    """
+    Optional amount denominated in sats if `token_identifier` is absent, otherwise in the token base units
+    """
+
+    token_identifier: "typing.Optional[str]"
+    """
+    The token identifier of the token payment. Absence indicates a Bitcoin payment.
+    """
+
+    expiry_time: "typing.Optional[int]"
+    """
+    Optional expiry time. If not provided, the invoice will never expire.
+    """
+
+    description: "typing.Optional[str]"
+    """
+    Optional description.
+    """
+
+    sender_public_key: "typing.Optional[str]"
+    """
+    If set, the invoice may only be fulfilled by a payer with this public key.
+    """
+
+    def __init__(self, *, invoice: "str", identity_public_key: "str", network: "BitcoinNetwork", amount: "typing.Optional[CommonU128]", token_identifier: "typing.Optional[str]", expiry_time: "typing.Optional[int]", description: "typing.Optional[str]", sender_public_key: "typing.Optional[str]"):
+        self.invoice = invoice
+        self.identity_public_key = identity_public_key
+        self.network = network
+        self.amount = amount
+        self.token_identifier = token_identifier
+        self.expiry_time = expiry_time
+        self.description = description
+        self.sender_public_key = sender_public_key
+
+    def __str__(self):
+        return "SparkInvoiceDetails(invoice={}, identity_public_key={}, network={}, amount={}, token_identifier={}, expiry_time={}, description={}, sender_public_key={})".format(self.invoice, self.identity_public_key, self.network, self.amount, self.token_identifier, self.expiry_time, self.description, self.sender_public_key)
+
+    def __eq__(self, other):
+        if self.invoice != other.invoice:
+            return False
+        if self.identity_public_key != other.identity_public_key:
+            return False
+        if self.network != other.network:
+            return False
+        if self.amount != other.amount:
+            return False
+        if self.token_identifier != other.token_identifier:
+            return False
+        if self.expiry_time != other.expiry_time:
+            return False
+        if self.description != other.description:
+            return False
+        if self.sender_public_key != other.sender_public_key:
+            return False
+        return True
+
+class _UniffiConverterTypeSparkInvoiceDetails(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        return SparkInvoiceDetails(
+            invoice=_UniffiConverterString.read(buf),
+            identity_public_key=_UniffiConverterString.read(buf),
+            network=_UniffiConverterTypeBitcoinNetwork.read(buf),
+            amount=_UniffiConverterOptionalTypeCommonU128.read(buf),
+            token_identifier=_UniffiConverterOptionalString.read(buf),
+            expiry_time=_UniffiConverterOptionalUInt64.read(buf),
+            description=_UniffiConverterOptionalString.read(buf),
+            sender_public_key=_UniffiConverterOptionalString.read(buf),
+        )
+
+    @staticmethod
+    def check_lower(value):
+        _UniffiConverterString.check_lower(value.invoice)
+        _UniffiConverterString.check_lower(value.identity_public_key)
+        _UniffiConverterTypeBitcoinNetwork.check_lower(value.network)
+        _UniffiConverterOptionalTypeCommonU128.check_lower(value.amount)
+        _UniffiConverterOptionalString.check_lower(value.token_identifier)
+        _UniffiConverterOptionalUInt64.check_lower(value.expiry_time)
+        _UniffiConverterOptionalString.check_lower(value.description)
+        _UniffiConverterOptionalString.check_lower(value.sender_public_key)
+
+    @staticmethod
+    def write(value, buf):
+        _UniffiConverterString.write(value.invoice, buf)
+        _UniffiConverterString.write(value.identity_public_key, buf)
+        _UniffiConverterTypeBitcoinNetwork.write(value.network, buf)
+        _UniffiConverterOptionalTypeCommonU128.write(value.amount, buf)
+        _UniffiConverterOptionalString.write(value.token_identifier, buf)
+        _UniffiConverterOptionalUInt64.write(value.expiry_time, buf)
+        _UniffiConverterOptionalString.write(value.description, buf)
+        _UniffiConverterOptionalString.write(value.sender_public_key, buf)
+
+
 class Symbol:
     """
     Settings for the symbol representation of a currency
@@ -2806,6 +4431,49 @@ class _UniffiConverterTypeSymbol(_UniffiConverterRustBuffer):
         _UniffiConverterOptionalUInt32.write(value.position, buf)
 
 
+class UnversionedRecordChange:
+    id: "RecordId"
+    schema_version: "str"
+    updated_fields: "dict[str, str]"
+    def __init__(self, *, id: "RecordId", schema_version: "str", updated_fields: "dict[str, str]"):
+        self.id = id
+        self.schema_version = schema_version
+        self.updated_fields = updated_fields
+
+    def __str__(self):
+        return "UnversionedRecordChange(id={}, schema_version={}, updated_fields={})".format(self.id, self.schema_version, self.updated_fields)
+
+    def __eq__(self, other):
+        if self.id != other.id:
+            return False
+        if self.schema_version != other.schema_version:
+            return False
+        if self.updated_fields != other.updated_fields:
+            return False
+        return True
+
+class _UniffiConverterTypeUnversionedRecordChange(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        return UnversionedRecordChange(
+            id=_UniffiConverterTypeRecordId.read(buf),
+            schema_version=_UniffiConverterString.read(buf),
+            updated_fields=_UniffiConverterMapStringString.read(buf),
+        )
+
+    @staticmethod
+    def check_lower(value):
+        _UniffiConverterTypeRecordId.check_lower(value.id)
+        _UniffiConverterString.check_lower(value.schema_version)
+        _UniffiConverterMapStringString.check_lower(value.updated_fields)
+
+    @staticmethod
+    def write(value, buf):
+        _UniffiConverterTypeRecordId.write(value.id, buf)
+        _UniffiConverterString.write(value.schema_version, buf)
+        _UniffiConverterMapStringString.write(value.updated_fields, buf)
+
+
 class UrlSuccessActionData:
     description: "str"
     """
@@ -3366,6 +5034,42 @@ class InputType:
             if not other.is_lnurl_withdraw():
                 return False
             return self._values == other._values
+    class SPARK_ADDRESS:
+        def __init__(self, *values):
+            if len(values) != 1:
+                raise TypeError(f"Expected 1 arguments, found {len(values)}")
+            if not isinstance(values[0], SparkAddressDetails):
+                raise TypeError(f"unexpected type for tuple element 0 - expected 'SparkAddressDetails', got '{type(values[0])}'")
+            self._values = values
+
+        def __getitem__(self, index):
+            return self._values[index]
+
+        def __str__(self):
+            return f"InputType.SPARK_ADDRESS{self._values!r}"
+
+        def __eq__(self, other):
+            if not other.is_spark_address():
+                return False
+            return self._values == other._values
+    class SPARK_INVOICE:
+        def __init__(self, *values):
+            if len(values) != 1:
+                raise TypeError(f"Expected 1 arguments, found {len(values)}")
+            if not isinstance(values[0], SparkInvoiceDetails):
+                raise TypeError(f"unexpected type for tuple element 0 - expected 'SparkInvoiceDetails', got '{type(values[0])}'")
+            self._values = values
+
+        def __getitem__(self, index):
+            return self._values[index]
+
+        def __str__(self):
+            return f"InputType.SPARK_INVOICE{self._values!r}"
+
+        def __eq__(self, other):
+            if not other.is_spark_invoice():
+                return False
+            return self._values == other._values
     
 
     # For each variant, we have an `is_NAME` method for easily checking
@@ -3394,6 +5098,10 @@ class InputType:
         return isinstance(self, InputType.BOLT12_INVOICE_REQUEST)
     def is_lnurl_withdraw(self) -> bool:
         return isinstance(self, InputType.LNURL_WITHDRAW)
+    def is_spark_address(self) -> bool:
+        return isinstance(self, InputType.SPARK_ADDRESS)
+    def is_spark_invoice(self) -> bool:
+        return isinstance(self, InputType.SPARK_INVOICE)
     
 
 # Now, a little trick - we make each nested variant class be a subclass of the main
@@ -3411,6 +5119,8 @@ InputType.URL = type("InputType.URL", (InputType.URL, InputType,), {})  # type:
 InputType.BIP21 = type("InputType.BIP21", (InputType.BIP21, InputType,), {})  # type: ignore
 InputType.BOLT12_INVOICE_REQUEST = type("InputType.BOLT12_INVOICE_REQUEST", (InputType.BOLT12_INVOICE_REQUEST, InputType,), {})  # type: ignore
 InputType.LNURL_WITHDRAW = type("InputType.LNURL_WITHDRAW", (InputType.LNURL_WITHDRAW, InputType,), {})  # type: ignore
+InputType.SPARK_ADDRESS = type("InputType.SPARK_ADDRESS", (InputType.SPARK_ADDRESS, InputType,), {})  # type: ignore
+InputType.SPARK_INVOICE = type("InputType.SPARK_INVOICE", (InputType.SPARK_INVOICE, InputType,), {})  # type: ignore
 
 
 
@@ -3467,6 +5177,14 @@ class _UniffiConverterTypeInputType(_UniffiConverterRustBuffer):
             return InputType.LNURL_WITHDRAW(
                 _UniffiConverterTypeLnurlWithdrawRequestDetails.read(buf),
             )
+        if variant == 13:
+            return InputType.SPARK_ADDRESS(
+                _UniffiConverterTypeSparkAddressDetails.read(buf),
+            )
+        if variant == 14:
+            return InputType.SPARK_INVOICE(
+                _UniffiConverterTypeSparkInvoiceDetails.read(buf),
+            )
         raise InternalError("Raw enum value doesn't match any cases")
 
     @staticmethod
@@ -3507,6 +5225,12 @@ class _UniffiConverterTypeInputType(_UniffiConverterRustBuffer):
         if value.is_lnurl_withdraw():
             _UniffiConverterTypeLnurlWithdrawRequestDetails.check_lower(value._values[0])
             return
+        if value.is_spark_address():
+            _UniffiConverterTypeSparkAddressDetails.check_lower(value._values[0])
+            return
+        if value.is_spark_invoice():
+            _UniffiConverterTypeSparkInvoiceDetails.check_lower(value._values[0])
+            return
         raise ValueError(value)
 
     @staticmethod
@@ -3547,6 +5271,12 @@ class _UniffiConverterTypeInputType(_UniffiConverterRustBuffer):
         if value.is_lnurl_withdraw():
             buf.write_i32(12)
             _UniffiConverterTypeLnurlWithdrawRequestDetails.write(value._values[0], buf)
+        if value.is_spark_address():
+            buf.write_i32(13)
+            _UniffiConverterTypeSparkAddressDetails.write(value._values[0], buf)
+        if value.is_spark_invoice():
+            buf.write_i32(14)
+            _UniffiConverterTypeSparkInvoiceDetails.write(value._values[0], buf)
 
 
 
@@ -4161,70 +5891,187 @@ class SuccessActionProcessed:
     
     
 
-    # For each variant, we have an `is_NAME` method for easily checking
-    # whether an instance is that variant.
-    def is_aes(self) -> bool:
-        return isinstance(self, SuccessActionProcessed.AES)
-    def is_message(self) -> bool:
-        return isinstance(self, SuccessActionProcessed.MESSAGE)
-    def is_url(self) -> bool:
-        return isinstance(self, SuccessActionProcessed.URL)
-    
+    # For each variant, we have an `is_NAME` method for easily checking
+    # whether an instance is that variant.
+    def is_aes(self) -> bool:
+        return isinstance(self, SuccessActionProcessed.AES)
+    def is_message(self) -> bool:
+        return isinstance(self, SuccessActionProcessed.MESSAGE)
+    def is_url(self) -> bool:
+        return isinstance(self, SuccessActionProcessed.URL)
+    
+
+# 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.
+SuccessActionProcessed.AES = type("SuccessActionProcessed.AES", (SuccessActionProcessed.AES, SuccessActionProcessed,), {})  # type: ignore
+SuccessActionProcessed.MESSAGE = type("SuccessActionProcessed.MESSAGE", (SuccessActionProcessed.MESSAGE, SuccessActionProcessed,), {})  # type: ignore
+SuccessActionProcessed.URL = type("SuccessActionProcessed.URL", (SuccessActionProcessed.URL, SuccessActionProcessed,), {})  # type: ignore
+
+
+
+
+class _UniffiConverterTypeSuccessActionProcessed(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        variant = buf.read_i32()
+        if variant == 1:
+            return SuccessActionProcessed.AES(
+                _UniffiConverterTypeAesSuccessActionDataResult.read(buf),
+            )
+        if variant == 2:
+            return SuccessActionProcessed.MESSAGE(
+                _UniffiConverterTypeMessageSuccessActionData.read(buf),
+            )
+        if variant == 3:
+            return SuccessActionProcessed.URL(
+                _UniffiConverterTypeUrlSuccessActionData.read(buf),
+            )
+        raise InternalError("Raw enum value doesn't match any cases")
+
+    @staticmethod
+    def check_lower(value):
+        if value.is_aes():
+            _UniffiConverterTypeAesSuccessActionDataResult.check_lower(value.result)
+            return
+        if value.is_message():
+            _UniffiConverterTypeMessageSuccessActionData.check_lower(value.data)
+            return
+        if value.is_url():
+            _UniffiConverterTypeUrlSuccessActionData.check_lower(value.data)
+            return
+        raise ValueError(value)
+
+    @staticmethod
+    def write(value, buf):
+        if value.is_aes():
+            buf.write_i32(1)
+            _UniffiConverterTypeAesSuccessActionDataResult.write(value.result, buf)
+        if value.is_message():
+            buf.write_i32(2)
+            _UniffiConverterTypeMessageSuccessActionData.write(value.data, buf)
+        if value.is_url():
+            buf.write_i32(3)
+            _UniffiConverterTypeUrlSuccessActionData.write(value.data, buf)
+
+
+
+
+# SyncStorageError
+# 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 SyncStorageError(Exception):
+    """
+    Errors that can occur during storage operations
+    """
+
+    pass
+
+_UniffiTempSyncStorageError = SyncStorageError
+
+class SyncStorageError:  # type: ignore
+    """
+    Errors that can occur during storage operations
+    """
+
+    class Implementation(_UniffiTempSyncStorageError):
+        def __init__(self, *values):
+            if len(values) != 1:
+                raise TypeError(f"Expected 1 arguments, found {len(values)}")
+            if not isinstance(values[0], str):
+                raise TypeError(f"unexpected type for tuple element 0 - expected 'str', got '{type(values[0])}'")
+            super().__init__(", ".join(map(repr, values)))
+            self._values = values
+
+        def __getitem__(self, index):
+            return self._values[index]
+
+        def __repr__(self):
+            return "SyncStorageError.Implementation({})".format(str(self))
+    _UniffiTempSyncStorageError.Implementation = Implementation # type: ignore
+    class InitializationError(_UniffiTempSyncStorageError):
+        """
+        Database initialization error
+        """
+
+        def __init__(self, *values):
+            if len(values) != 1:
+                raise TypeError(f"Expected 1 arguments, found {len(values)}")
+            if not isinstance(values[0], str):
+                raise TypeError(f"unexpected type for tuple element 0 - expected 'str', got '{type(values[0])}'")
+            super().__init__(", ".join(map(repr, values)))
+            self._values = values
+
+        def __getitem__(self, index):
+            return self._values[index]
 
-# 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.
-SuccessActionProcessed.AES = type("SuccessActionProcessed.AES", (SuccessActionProcessed.AES, SuccessActionProcessed,), {})  # type: ignore
-SuccessActionProcessed.MESSAGE = type("SuccessActionProcessed.MESSAGE", (SuccessActionProcessed.MESSAGE, SuccessActionProcessed,), {})  # type: ignore
-SuccessActionProcessed.URL = type("SuccessActionProcessed.URL", (SuccessActionProcessed.URL, SuccessActionProcessed,), {})  # type: ignore
+        def __repr__(self):
+            return "SyncStorageError.InitializationError({})".format(str(self))
+    _UniffiTempSyncStorageError.InitializationError = InitializationError # type: ignore
+    class Serialization(_UniffiTempSyncStorageError):
+        def __init__(self, *values):
+            if len(values) != 1:
+                raise TypeError(f"Expected 1 arguments, found {len(values)}")
+            if not isinstance(values[0], str):
+                raise TypeError(f"unexpected type for tuple element 0 - expected 'str', got '{type(values[0])}'")
+            super().__init__(", ".join(map(repr, values)))
+            self._values = values
+
+        def __getitem__(self, index):
+            return self._values[index]
 
+        def __repr__(self):
+            return "SyncStorageError.Serialization({})".format(str(self))
+    _UniffiTempSyncStorageError.Serialization = Serialization # type: ignore
 
+SyncStorageError = _UniffiTempSyncStorageError # type: ignore
+del _UniffiTempSyncStorageError
 
 
-class _UniffiConverterTypeSuccessActionProcessed(_UniffiConverterRustBuffer):
+class _UniffiConverterTypeSyncStorageError(_UniffiConverterRustBuffer):
     @staticmethod
     def read(buf):
         variant = buf.read_i32()
         if variant == 1:
-            return SuccessActionProcessed.AES(
-                _UniffiConverterTypeAesSuccessActionDataResult.read(buf),
+            return SyncStorageError.Implementation(
+                _UniffiConverterString.read(buf),
             )
         if variant == 2:
-            return SuccessActionProcessed.MESSAGE(
-                _UniffiConverterTypeMessageSuccessActionData.read(buf),
+            return SyncStorageError.InitializationError(
+                _UniffiConverterString.read(buf),
             )
         if variant == 3:
-            return SuccessActionProcessed.URL(
-                _UniffiConverterTypeUrlSuccessActionData.read(buf),
+            return SyncStorageError.Serialization(
+                _UniffiConverterString.read(buf),
             )
         raise InternalError("Raw enum value doesn't match any cases")
 
     @staticmethod
     def check_lower(value):
-        if value.is_aes():
-            _UniffiConverterTypeAesSuccessActionDataResult.check_lower(value.result)
+        if isinstance(value, SyncStorageError.Implementation):
+            _UniffiConverterString.check_lower(value._values[0])
             return
-        if value.is_message():
-            _UniffiConverterTypeMessageSuccessActionData.check_lower(value.data)
+        if isinstance(value, SyncStorageError.InitializationError):
+            _UniffiConverterString.check_lower(value._values[0])
             return
-        if value.is_url():
-            _UniffiConverterTypeUrlSuccessActionData.check_lower(value.data)
+        if isinstance(value, SyncStorageError.Serialization):
+            _UniffiConverterString.check_lower(value._values[0])
             return
-        raise ValueError(value)
 
     @staticmethod
     def write(value, buf):
-        if value.is_aes():
+        if isinstance(value, SyncStorageError.Implementation):
             buf.write_i32(1)
-            _UniffiConverterTypeAesSuccessActionDataResult.write(value.result, buf)
-        if value.is_message():
+            _UniffiConverterString.write(value._values[0], buf)
+        if isinstance(value, SyncStorageError.InitializationError):
             buf.write_i32(2)
-            _UniffiConverterTypeMessageSuccessActionData.write(value.data, buf)
-        if value.is_url():
+            _UniffiConverterString.write(value._values[0], buf)
+        if isinstance(value, SyncStorageError.Serialization):
             buf.write_i32(3)
-            _UniffiConverterTypeUrlSuccessActionData.write(value.data, buf)
-
-
+            _UniffiConverterString.write(value._values[0], buf)
 
 
 
@@ -4336,6 +6183,60 @@ class _UniffiConverterOptionalString(_UniffiConverterRustBuffer):
 
 
 
+class _UniffiConverterOptionalTypeOutgoingChange(_UniffiConverterRustBuffer):
+    @classmethod
+    def check_lower(cls, value):
+        if value is not None:
+            _UniffiConverterTypeOutgoingChange.check_lower(value)
+
+    @classmethod
+    def write(cls, value, buf):
+        if value is None:
+            buf.write_u8(0)
+            return
+
+        buf.write_u8(1)
+        _UniffiConverterTypeOutgoingChange.write(value, buf)
+
+    @classmethod
+    def read(cls, buf):
+        flag = buf.read_u8()
+        if flag == 0:
+            return None
+        elif flag == 1:
+            return _UniffiConverterTypeOutgoingChange.read(buf)
+        else:
+            raise InternalError("Unexpected flag byte for optional type")
+
+
+
+class _UniffiConverterOptionalTypeRecord(_UniffiConverterRustBuffer):
+    @classmethod
+    def check_lower(cls, value):
+        if value is not None:
+            _UniffiConverterTypeRecord.check_lower(value)
+
+    @classmethod
+    def write(cls, value, buf):
+        if value is None:
+            buf.write_u8(0)
+            return
+
+        buf.write_u8(1)
+        _UniffiConverterTypeRecord.write(value, buf)
+
+    @classmethod
+    def read(cls, buf):
+        flag = buf.read_u8()
+        if flag == 0:
+            return None
+        elif flag == 1:
+            return _UniffiConverterTypeRecord.read(buf)
+        else:
+            raise InternalError("Unexpected flag byte for optional type")
+
+
+
 class _UniffiConverterOptionalTypeSymbol(_UniffiConverterRustBuffer):
     @classmethod
     def check_lower(cls, value):
@@ -4417,6 +6318,33 @@ class _UniffiConverterOptionalMapStringString(_UniffiConverterRustBuffer):
 
 
 
+class _UniffiConverterOptionalTypeCommonU128(_UniffiConverterRustBuffer):
+    @classmethod
+    def check_lower(cls, value):
+        if value is not None:
+            _UniffiConverterTypeCommonU128.check_lower(value)
+
+    @classmethod
+    def write(cls, value, buf):
+        if value is None:
+            buf.write_u8(0)
+            return
+
+        buf.write_u8(1)
+        _UniffiConverterTypeCommonU128.write(value, buf)
+
+    @classmethod
+    def read(cls, buf):
+        flag = buf.read_u8()
+        if flag == 0:
+            return None
+        elif flag == 1:
+            return _UniffiConverterTypeCommonU128.read(buf)
+        else:
+            raise InternalError("Unexpected flag byte for optional type")
+
+
+
 class _UniffiConverterSequenceString(_UniffiConverterRustBuffer):
     @classmethod
     def check_lower(cls, value):
@@ -4542,6 +6470,56 @@ class _UniffiConverterSequenceTypeBolt12OfferBlindedPath(_UniffiConverterRustBuf
 
 
 
+class _UniffiConverterSequenceTypeFiatCurrency(_UniffiConverterRustBuffer):
+    @classmethod
+    def check_lower(cls, value):
+        for item in value:
+            _UniffiConverterTypeFiatCurrency.check_lower(item)
+
+    @classmethod
+    def write(cls, value, buf):
+        items = len(value)
+        buf.write_i32(items)
+        for item in value:
+            _UniffiConverterTypeFiatCurrency.write(item, buf)
+
+    @classmethod
+    def read(cls, buf):
+        count = buf.read_i32()
+        if count < 0:
+            raise InternalError("Unexpected negative sequence length")
+
+        return [
+            _UniffiConverterTypeFiatCurrency.read(buf) for i in range(count)
+        ]
+
+
+
+class _UniffiConverterSequenceTypeIncomingChange(_UniffiConverterRustBuffer):
+    @classmethod
+    def check_lower(cls, value):
+        for item in value:
+            _UniffiConverterTypeIncomingChange.check_lower(item)
+
+    @classmethod
+    def write(cls, value, buf):
+        items = len(value)
+        buf.write_i32(items)
+        for item in value:
+            _UniffiConverterTypeIncomingChange.write(item, buf)
+
+    @classmethod
+    def read(cls, buf):
+        count = buf.read_i32()
+        if count < 0:
+            raise InternalError("Unexpected negative sequence length")
+
+        return [
+            _UniffiConverterTypeIncomingChange.read(buf) for i in range(count)
+        ]
+
+
+
 class _UniffiConverterSequenceTypeLocaleOverrides(_UniffiConverterRustBuffer):
     @classmethod
     def check_lower(cls, value):
@@ -4592,6 +6570,81 @@ class _UniffiConverterSequenceTypeLocalizedName(_UniffiConverterRustBuffer):
 
 
 
+class _UniffiConverterSequenceTypeOutgoingChange(_UniffiConverterRustBuffer):
+    @classmethod
+    def check_lower(cls, value):
+        for item in value:
+            _UniffiConverterTypeOutgoingChange.check_lower(item)
+
+    @classmethod
+    def write(cls, value, buf):
+        items = len(value)
+        buf.write_i32(items)
+        for item in value:
+            _UniffiConverterTypeOutgoingChange.write(item, buf)
+
+    @classmethod
+    def read(cls, buf):
+        count = buf.read_i32()
+        if count < 0:
+            raise InternalError("Unexpected negative sequence length")
+
+        return [
+            _UniffiConverterTypeOutgoingChange.read(buf) for i in range(count)
+        ]
+
+
+
+class _UniffiConverterSequenceTypeRate(_UniffiConverterRustBuffer):
+    @classmethod
+    def check_lower(cls, value):
+        for item in value:
+            _UniffiConverterTypeRate.check_lower(item)
+
+    @classmethod
+    def write(cls, value, buf):
+        items = len(value)
+        buf.write_i32(items)
+        for item in value:
+            _UniffiConverterTypeRate.write(item, buf)
+
+    @classmethod
+    def read(cls, buf):
+        count = buf.read_i32()
+        if count < 0:
+            raise InternalError("Unexpected negative sequence length")
+
+        return [
+            _UniffiConverterTypeRate.read(buf) for i in range(count)
+        ]
+
+
+
+class _UniffiConverterSequenceTypeRecord(_UniffiConverterRustBuffer):
+    @classmethod
+    def check_lower(cls, value):
+        for item in value:
+            _UniffiConverterTypeRecord.check_lower(item)
+
+    @classmethod
+    def write(cls, value, buf):
+        items = len(value)
+        buf.write_i32(items)
+        for item in value:
+            _UniffiConverterTypeRecord.write(item, buf)
+
+    @classmethod
+    def read(cls, buf):
+        count = buf.read_i32()
+        if count < 0:
+            raise InternalError("Unexpected negative sequence length")
+
+        return [
+            _UniffiConverterTypeRecord.read(buf) for i in range(count)
+        ]
+
+
+
 class _UniffiConverterSequenceTypeInputType(_UniffiConverterRustBuffer):
     @classmethod
     def check_lower(cls, value):
@@ -4648,6 +6701,34 @@ class _UniffiConverterMapStringString(_UniffiConverterRustBuffer):
             d[key] = val
         return d
 
+
+class _UniffiConverterTypeCommonU128:
+    @staticmethod
+    def write(value, buf):
+        builtin_value = str(value)
+        _UniffiConverterString.write(builtin_value, buf)
+
+    @staticmethod
+    def read(buf):
+        builtin_value = _UniffiConverterString.read(buf)
+        return int(builtin_value)
+
+    @staticmethod
+    def lift(value):
+        builtin_value = _UniffiConverterString.lift(value)
+        return int(builtin_value)
+
+    @staticmethod
+    def check_lower(value):
+        builtin_value = str(value)
+        return _UniffiConverterString.check_lower(builtin_value)
+
+    @staticmethod
+    def lower(value):
+        builtin_value = str(value)
+        return _UniffiConverterString.lower(builtin_value)
+CommonU128 = str
+
 # Async support# RustFuturePoll values
 _UNIFFI_RUST_FUTURE_POLL_READY = 0
 _UNIFFI_RUST_FUTURE_POLL_MAYBE_READY = 1
@@ -4770,6 +6851,7 @@ __all__ = [
     "ServiceConnectivityError",
     "SuccessAction",
     "SuccessActionProcessed",
+    "SyncStorageError",
     "AesSuccessActionData",
     "AesSuccessActionDataDecrypted",
     "Bip21Details",
@@ -4786,7 +6868,9 @@ __all__ = [
     "Bolt12OfferBlindedPath",
     "Bolt12OfferDetails",
     "CurrencyInfo",
+    "ExternalInputParser",
     "FiatCurrency",
+    "IncomingChange",
     "LightningAddressDetails",
     "LnurlAuthRequestDetails",
     "LnurlErrorDetails",
@@ -4795,12 +6879,21 @@ __all__ = [
     "LocaleOverrides",
     "LocalizedName",
     "MessageSuccessActionData",
+    "OutgoingChange",
     "PaymentRequestSource",
     "Rate",
+    "Record",
+    "RecordChange",
+    "RecordId",
     "RestResponse",
     "SilentPaymentAddressDetails",
+    "SparkAddressDetails",
+    "SparkInvoiceDetails",
     "Symbol",
+    "UnversionedRecordChange",
     "UrlSuccessActionData",
+    "FiatService",
     "RestClient",
+    "SyncStorage",
 ]