breez-sdk-spark 0.1.9__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,11 +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_delete() != 56210:
+    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.
@@ -573,19 +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),
-        ("delete", _UNIFFI_CALLBACK_INTERFACE_REST_CLIENT_METHOD2),
+        ("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),
@@ -600,26 +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_get.restype = ctypes.c_uint64
-_UniffiLib.uniffi_breez_sdk_common_fn_method_restclient_post.argtypes = (
+_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_post.restype = ctypes.c_uint64
-_UniffiLib.uniffi_breez_sdk_common_fn_method_restclient_delete.argtypes = (
+_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_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_delete.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),
@@ -888,15 +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_restclient_get.restype = ctypes.c_uint16
-_UniffiLib.uniffi_breez_sdk_common_checksum_method_restclient_post.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_post.restype = ctypes.c_uint16
-_UniffiLib.uniffi_breez_sdk_common_checksum_method_restclient_delete.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_delete.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
@@ -1010,39 +1198,30 @@ class _UniffiConverterString:
 
 
 
-class RestClient(typing.Protocol):
-    def get(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
-        """
+class FiatService(typing.Protocol):
+    """
+    Trait covering fiat-related functionality
+    """
 
-        raise NotImplementedError
-    def post(self, url: "str",headers: "typing.Optional[dict[str, str]]",body: "typing.Optional[str]"):
+    def fetch_fiat_currencies(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
+        List all supported fiat currencies for which there is a known exchange rate.
         """
 
         raise NotImplementedError
-    def delete(self, url: "str",headers: "typing.Optional[dict[str, str]]",body: "typing.Optional[str]"):
+    def fetch_fiat_rates(self, ):
         """
-        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
+        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):
@@ -1052,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
@@ -1066,64 +1245,20 @@ class RestClientImpl:
         inst._pointer = pointer
         return inst
 
-    async def get(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(
-                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(self, url: "str",headers: "typing.Optional[dict[str, str]]",body: "typing.Optional[str]") -> "RestResponse":
+    async def fetch_fiat_currencies(self, ) -> "typing.List[FiatCurrency]":
         """
-        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
+        List all supported fiat currencies for which there is a known exchange rate.
         """
 
-        _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_currencies(
                 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,
+            _UniffiConverterSequenceTypeFiatCurrency.lift,
             
     # Error FFI converter
 _UniffiConverterTypeServiceConnectivityError,
@@ -1132,33 +1267,20 @@ _UniffiConverterTypeServiceConnectivityError,
 
 
 
-    async def delete(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 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
+        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_delete(
+            _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,
@@ -1174,48 +1296,1022 @@ _UNIFFI_CALLBACK_SUCCESS = 0
 _UNIFFI_CALLBACK_ERROR = 1
 _UNIFFI_CALLBACK_UNEXPECTED_ERROR = 2
 
-class _UniffiCallbackInterfaceFfiConverter:
-    _handle_map = _UniffiHandleMap()
+class _UniffiCallbackInterfaceFfiConverter:
+    _handle_map = _UniffiHandleMap()
+
+    @classmethod
+    def lift(cls, handle):
+        return cls._handle_map.get(handle)
+
+    @classmethod
+    def read(cls, buf):
+        handle = buf.read_u64()
+        cls.lift(handle)
+
+    @classmethod
+    def check_lower(cls, cb):
+        pass
+
+    @classmethod
+    def lower(cls, cb):
+        handle = cls._handle_map.insert(cb)
+        return handle
+
+    @classmethod
+    def write(cls, cb, buf):
+        buf.write_u64(cls.lower(cb))
+
+# Put all the bits inside a class to keep the top-level namespace clean
+class _UniffiTraitImplFiatService:
+    # For each method, generate a callback function to pass to Rust
+
+    @_UNIFFI_CALLBACK_INTERFACE_FIAT_SERVICE_METHOD0
+    def fetch_fiat_currencies(
+            uniffi_handle,
+            uniffi_future_callback,
+            uniffi_callback_data,
+            uniffi_out_return,
+        ):
+        uniffi_obj = _UniffiConverterTypeFiatService._handle_map.get(uniffi_handle)
+        def make_call():
+            args = ()
+            method = uniffi_obj.fetch_fiat_currencies
+            return method(*args)
+
+        
+        def handle_success(return_value):
+            uniffi_future_callback(
+                uniffi_callback_data,
+                _UniffiForeignFutureStructRustBuffer(
+                    _UniffiConverterSequenceTypeFiatCurrency.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_FIAT_SERVICE_METHOD1
+    def fetch_fiat_rates(
+            uniffi_handle,
+            uniffi_future_callback,
+            uniffi_callback_data,
+            uniffi_out_return,
+        ):
+        uniffi_obj = _UniffiConverterTypeFiatService._handle_map.get(uniffi_handle)
+        def make_call():
+            args = ()
+            method = uniffi_obj.fetch_fiat_rates
+            return method(*args)
+
+        
+        def handle_success(return_value):
+            uniffi_future_callback(
+                uniffi_callback_data,
+                _UniffiForeignFutureStructRustBuffer(
+                    _UniffiConverterSequenceTypeRate.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):
+        _UniffiConverterTypeFiatService._handle_map.remove(uniffi_handle)
+
+    # Generate the FFI VTable.  This has a field for each callback interface method.
+    _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_fiatservice(ctypes.byref(_uniffi_vtable))
+
+
+
+class _UniffiConverterTypeFiatService:
+    _handle_map = _UniffiHandleMap()
+
+    @staticmethod
+    def lift(value: int):
+        return FiatServiceImpl._make_instance_(value)
+
+    @staticmethod
+    def check_lower(value: FiatService):
+        pass
+
+    @staticmethod
+    def lower(value: FiatService):
+        return _UniffiConverterTypeFiatService._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: FiatService, buf: _UniffiRustBuffer):
+        buf.write_u64(cls.lower(value))
+
+
+
+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
+        """
+
+        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
+        """
+
+        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
+        """
+
+        raise NotImplementedError
+
+
+class RestClientImpl:
+    _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_restclient, pointer)
+
+    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
+
+    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()
+                )
+            )
 
-    @classmethod
-    def lift(cls, handle):
-        return cls._handle_map.get(handle)
+        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)
 
-    @classmethod
-    def read(cls, buf):
-        handle = buf.read_u64()
-        cls.lift(handle)
+    @_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)
 
-    @classmethod
-    def check_lower(cls, cb):
-        pass
+        
+        def handle_success(return_value):
+            uniffi_future_callback(
+                uniffi_callback_data,
+                _UniffiForeignFutureStructVoid(
+                    _UniffiRustCallStatus.default()
+                )
+            )
 
-    @classmethod
-    def lower(cls, cb):
-        handle = cls._handle_map.insert(cb)
-        return handle
+        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)
 
-    @classmethod
-    def write(cls, cb, buf):
-        buf.write_u64(cls.lower(cb))
+    @_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)
 
-# 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
+        
+        def handle_success(return_value):
+            uniffi_future_callback(
+                uniffi_callback_data,
+                _UniffiForeignFutureStructVoid(
+                    _UniffiRustCallStatus.default()
+                )
+            )
 
-    @_UNIFFI_CALLBACK_INTERFACE_REST_CLIENT_METHOD0
-    def get(
+        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,
-            url,
-            headers,
+            limit,
             uniffi_future_callback,
             uniffi_callback_data,
             uniffi_out_return,
         ):
-        uniffi_obj = _UniffiConverterTypeRestClient._handle_map.get(uniffi_handle)
+        uniffi_obj = _UniffiConverterTypeSyncStorage._handle_map.get(uniffi_handle)
         def make_call():
-            args = (_UniffiConverterString.lift(url), _UniffiConverterOptionalMapStringString.lift(headers), )
-            method = uniffi_obj.get
+            args = (_UniffiConverterUInt32.lift(limit), )
+            method = uniffi_obj.get_incoming_records
             return method(*args)
 
         
@@ -1223,7 +2319,7 @@ class _UniffiTraitImplRestClient:
             uniffi_future_callback(
                 uniffi_callback_data,
                 _UniffiForeignFutureStructRustBuffer(
-                    _UniffiConverterTypeRestResponse.lower(return_value),
+                    _UniffiConverterSequenceTypeIncomingChange.lower(return_value),
                     _UniffiRustCallStatus.default()
                 )
             )
@@ -1236,22 +2332,19 @@ class _UniffiTraitImplRestClient:
                     _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_out_return[0] = _uniffi_trait_interface_call_async_with_error(make_call, handle_success, handle_error, SyncStorageError, _UniffiConverterTypeSyncStorageError.lower)
 
-    @_UNIFFI_CALLBACK_INTERFACE_REST_CLIENT_METHOD1
-    def post(
+    @_UNIFFI_CALLBACK_INTERFACE_SYNC_STORAGE_METHOD8
+    def get_latest_outgoing_change(
             uniffi_handle,
-            url,
-            headers,
-            body,
             uniffi_future_callback,
             uniffi_callback_data,
             uniffi_out_return,
         ):
-        uniffi_obj = _UniffiConverterTypeRestClient._handle_map.get(uniffi_handle)
+        uniffi_obj = _UniffiConverterTypeSyncStorage._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.get_latest_outgoing_change
             return method(*args)
 
         
@@ -1259,7 +2352,7 @@ class _UniffiTraitImplRestClient:
             uniffi_future_callback(
                 uniffi_callback_data,
                 _UniffiForeignFutureStructRustBuffer(
-                    _UniffiConverterTypeRestResponse.lower(return_value),
+                    _UniffiConverterOptionalTypeOutgoingChange.lower(return_value),
                     _UniffiRustCallStatus.default()
                 )
             )
@@ -1272,30 +2365,27 @@ class _UniffiTraitImplRestClient:
                     _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_out_return[0] = _uniffi_trait_interface_call_async_with_error(make_call, handle_success, handle_error, SyncStorageError, _UniffiConverterTypeSyncStorageError.lower)
 
-    @_UNIFFI_CALLBACK_INTERFACE_REST_CLIENT_METHOD2
-    def delete(
+    @_UNIFFI_CALLBACK_INTERFACE_SYNC_STORAGE_METHOD9
+    def update_record_from_incoming(
             uniffi_handle,
-            url,
-            headers,
-            body,
+            record,
             uniffi_future_callback,
             uniffi_callback_data,
             uniffi_out_return,
         ):
-        uniffi_obj = _UniffiConverterTypeRestClient._handle_map.get(uniffi_handle)
+        uniffi_obj = _UniffiConverterTypeSyncStorage._handle_map.get(uniffi_handle)
         def make_call():
-            args = (_UniffiConverterString.lift(url), _UniffiConverterOptionalMapStringString.lift(headers), _UniffiConverterOptionalString.lift(body), )
-            method = uniffi_obj.delete
+            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,
-                _UniffiForeignFutureStructRustBuffer(
-                    _UniffiConverterTypeRestResponse.lower(return_value),
+                _UniffiForeignFutureStructVoid(
                     _UniffiRustCallStatus.default()
                 )
             )
@@ -1303,44 +2393,50 @@ class _UniffiTraitImplRestClient:
         def handle_error(status_code, rust_buffer):
             uniffi_future_callback(
                 uniffi_callback_data,
-                _UniffiForeignFutureStructRustBuffer(
-                    _UniffiRustBuffer.default(),
+                _UniffiForeignFutureStructVoid(
                     _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_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):
-        _UniffiConverterTypeRestClient._handle_map.remove(uniffi_handle)
+        _UniffiConverterTypeSyncStorage._handle_map.remove(uniffi_handle)
 
     # Generate the FFI VTable.  This has a field for each callback interface method.
-    _uniffi_vtable = _UniffiVTableCallbackInterfaceRestClient(
-        get,
-        post,
-        delete,
+    _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_restclient(ctypes.byref(_uniffi_vtable))
+    _UniffiLib.uniffi_breez_sdk_common_fn_init_callback_vtable_syncstorage(ctypes.byref(_uniffi_vtable))
 
 
 
-class _UniffiConverterTypeRestClient:
+class _UniffiConverterTypeSyncStorage:
     _handle_map = _UniffiHandleMap()
 
     @staticmethod
     def lift(value: int):
-        return RestClientImpl._make_instance_(value)
+        return SyncStorageImpl._make_instance_(value)
 
     @staticmethod
-    def check_lower(value: RestClient):
+    def check_lower(value: SyncStorage):
         pass
 
     @staticmethod
-    def lower(value: RestClient):
-        return _UniffiConverterTypeRestClient._handle_map.insert(value)
+    def lower(value: SyncStorage):
+        return _UniffiConverterTypeSyncStorage._handle_map.insert(value)
 
     @classmethod
     def read(cls, buf: _UniffiRustBuffer):
@@ -1350,7 +2446,7 @@ class _UniffiConverterTypeRestClient:
         return cls.lift(ptr)
 
     @classmethod
-    def write(cls, value: RestClient, buf: _UniffiRustBuffer):
+    def write(cls, value: SyncStorage, buf: _UniffiRustBuffer):
         buf.write_u64(cls.lower(value))
 
 
@@ -2192,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
@@ -2232,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"
@@ -2694,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]"
@@ -2751,23 +3979,159 @@ class Rate:
             return False
         return True
 
-class _UniffiConverterTypeRate(_UniffiConverterRustBuffer):
+class _UniffiConverterTypeRate(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        return Rate(
+            coin=_UniffiConverterString.read(buf),
+            value=_UniffiConverterDouble.read(buf),
+        )
+
+    @staticmethod
+    def check_lower(value):
+        _UniffiConverterString.check_lower(value.coin)
+        _UniffiConverterDouble.check_lower(value.value)
+
+    @staticmethod
+    def write(value, buf):
+        _UniffiConverterString.write(value.coin, buf)
+        _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 Rate(
-            coin=_UniffiConverterString.read(buf),
-            value=_UniffiConverterDouble.read(buf),
+        return RecordId(
+            type=_UniffiConverterString.read(buf),
+            data_id=_UniffiConverterString.read(buf),
         )
 
     @staticmethod
     def check_lower(value):
-        _UniffiConverterString.check_lower(value.coin)
-        _UniffiConverterDouble.check_lower(value.value)
+        _UniffiConverterString.check_lower(value.type)
+        _UniffiConverterString.check_lower(value.data_id)
 
     @staticmethod
     def write(value, buf):
-        _UniffiConverterString.write(value.coin, buf)
-        _UniffiConverterDouble.write(value.value, buf)
+        _UniffiConverterString.write(value.type, buf)
+        _UniffiConverterString.write(value.data_id, buf)
 
 
 class RestResponse:
@@ -2806,35 +4170,6 @@ class _UniffiConverterTypeRestResponse(_UniffiConverterRustBuffer):
         _UniffiConverterString.write(value.body, buf)
 
 
-class SatsPaymentDetails:
-    amount: "typing.Optional[int]"
-    def __init__(self, *, amount: "typing.Optional[int]"):
-        self.amount = amount
-
-    def __str__(self):
-        return "SatsPaymentDetails(amount={})".format(self.amount)
-
-    def __eq__(self, other):
-        if self.amount != other.amount:
-            return False
-        return True
-
-class _UniffiConverterTypeSatsPaymentDetails(_UniffiConverterRustBuffer):
-    @staticmethod
-    def read(buf):
-        return SatsPaymentDetails(
-            amount=_UniffiConverterOptionalUInt64.read(buf),
-        )
-
-    @staticmethod
-    def check_lower(value):
-        _UniffiConverterOptionalUInt64.check_lower(value.amount)
-
-    @staticmethod
-    def write(value, buf):
-        _UniffiConverterOptionalUInt64.write(value.amount, buf)
-
-
 class SilentPaymentAddressDetails:
     address: "str"
     network: "BitcoinNetwork"
@@ -2878,161 +4213,168 @@ class _UniffiConverterTypeSilentPaymentAddressDetails(_UniffiConverterRustBuffer
         _UniffiConverterTypePaymentRequestSource.write(value.source, buf)
 
 
-class SparkAddress:
+class SparkAddressDetails:
+    address: "str"
+    """
+    The raw address string
+    """
+
     identity_public_key: "str"
+    """
+    The identity public key of the address owner
+    """
+
     network: "BitcoinNetwork"
-    spark_invoice_fields: "typing.Optional[SparkInvoiceFields]"
-    signature: "typing.Optional[str]"
-    def __init__(self, *, identity_public_key: "str", network: "BitcoinNetwork", spark_invoice_fields: "typing.Optional[SparkInvoiceFields]", signature: "typing.Optional[str]"):
+    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.spark_invoice_fields = spark_invoice_fields
-        self.signature = signature
+        self.source = source
 
     def __str__(self):
-        return "SparkAddress(identity_public_key={}, network={}, spark_invoice_fields={}, signature={})".format(self.identity_public_key, self.network, self.spark_invoice_fields, self.signature)
+        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.spark_invoice_fields != other.spark_invoice_fields:
-            return False
-        if self.signature != other.signature:
+        if self.source != other.source:
             return False
         return True
 
-class _UniffiConverterTypeSparkAddress(_UniffiConverterRustBuffer):
+class _UniffiConverterTypeSparkAddressDetails(_UniffiConverterRustBuffer):
     @staticmethod
     def read(buf):
-        return SparkAddress(
+        return SparkAddressDetails(
+            address=_UniffiConverterString.read(buf),
             identity_public_key=_UniffiConverterString.read(buf),
             network=_UniffiConverterTypeBitcoinNetwork.read(buf),
-            spark_invoice_fields=_UniffiConverterOptionalTypeSparkInvoiceFields.read(buf),
-            signature=_UniffiConverterOptionalString.read(buf),
+            source=_UniffiConverterTypePaymentRequestSource.read(buf),
         )
 
     @staticmethod
     def check_lower(value):
+        _UniffiConverterString.check_lower(value.address)
         _UniffiConverterString.check_lower(value.identity_public_key)
         _UniffiConverterTypeBitcoinNetwork.check_lower(value.network)
-        _UniffiConverterOptionalTypeSparkInvoiceFields.check_lower(value.spark_invoice_fields)
-        _UniffiConverterOptionalString.check_lower(value.signature)
+        _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)
-        _UniffiConverterOptionalTypeSparkInvoiceFields.write(value.spark_invoice_fields, buf)
-        _UniffiConverterOptionalString.write(value.signature, buf)
-
+        _UniffiConverterTypePaymentRequestSource.write(value.source, buf)
 
-class SparkAddressDetails:
-    address: "str"
-    decoded_address: "SparkAddress"
-    source: "PaymentRequestSource"
-    def __init__(self, *, address: "str", decoded_address: "SparkAddress", source: "PaymentRequestSource"):
-        self.address = address
-        self.decoded_address = decoded_address
-        self.source = source
 
-    def __str__(self):
-        return "SparkAddressDetails(address={}, decoded_address={}, source={})".format(self.address, self.decoded_address, self.source)
+class SparkInvoiceDetails:
+    invoice: "str"
+    """
+    The raw invoice string
+    """
 
-    def __eq__(self, other):
-        if self.address != other.address:
-            return False
-        if self.decoded_address != other.decoded_address:
-            return False
-        if self.source != other.source:
-            return False
-        return True
+    identity_public_key: "str"
+    """
+    The identity public key of the invoice issuer
+    """
 
-class _UniffiConverterTypeSparkAddressDetails(_UniffiConverterRustBuffer):
-    @staticmethod
-    def read(buf):
-        return SparkAddressDetails(
-            address=_UniffiConverterString.read(buf),
-            decoded_address=_UniffiConverterTypeSparkAddress.read(buf),
-            source=_UniffiConverterTypePaymentRequestSource.read(buf),
-        )
+    network: "BitcoinNetwork"
+    amount: "typing.Optional[CommonU128]"
+    """
+    Optional amount denominated in sats if `token_identifier` is absent, otherwise in the token base units
+    """
 
-    @staticmethod
-    def check_lower(value):
-        _UniffiConverterString.check_lower(value.address)
-        _UniffiConverterTypeSparkAddress.check_lower(value.decoded_address)
-        _UniffiConverterTypePaymentRequestSource.check_lower(value.source)
+    token_identifier: "typing.Optional[str]"
+    """
+    The token identifier of the token payment. Absence indicates a Bitcoin payment.
+    """
 
-    @staticmethod
-    def write(value, buf):
-        _UniffiConverterString.write(value.address, buf)
-        _UniffiConverterTypeSparkAddress.write(value.decoded_address, buf)
-        _UniffiConverterTypePaymentRequestSource.write(value.source, buf)
+    expiry_time: "typing.Optional[int]"
+    """
+    Optional expiry time. If not provided, the invoice will never expire.
+    """
 
+    description: "typing.Optional[str]"
+    """
+    Optional description.
+    """
 
-class SparkInvoiceFields:
-    id: "str"
-    version: "int"
-    memo: "typing.Optional[str]"
     sender_public_key: "typing.Optional[str]"
-    expiry_time: "typing.Optional[int]"
-    payment_type: "typing.Optional[SparkAddressPaymentType]"
-    def __init__(self, *, id: "str", version: "int", memo: "typing.Optional[str]", sender_public_key: "typing.Optional[str]", expiry_time: "typing.Optional[int]", payment_type: "typing.Optional[SparkAddressPaymentType]"):
-        self.id = id
-        self.version = version
-        self.memo = memo
-        self.sender_public_key = sender_public_key
+    """
+    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.payment_type = payment_type
+        self.description = description
+        self.sender_public_key = sender_public_key
 
     def __str__(self):
-        return "SparkInvoiceFields(id={}, version={}, memo={}, sender_public_key={}, expiry_time={}, payment_type={})".format(self.id, self.version, self.memo, self.sender_public_key, self.expiry_time, self.payment_type)
+        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.id != other.id:
+        if self.invoice != other.invoice:
+            return False
+        if self.identity_public_key != other.identity_public_key:
             return False
-        if self.version != other.version:
+        if self.network != other.network:
             return False
-        if self.memo != other.memo:
+        if self.amount != other.amount:
             return False
-        if self.sender_public_key != other.sender_public_key:
+        if self.token_identifier != other.token_identifier:
             return False
         if self.expiry_time != other.expiry_time:
             return False
-        if self.payment_type != other.payment_type:
+        if self.description != other.description:
+            return False
+        if self.sender_public_key != other.sender_public_key:
             return False
         return True
 
-class _UniffiConverterTypeSparkInvoiceFields(_UniffiConverterRustBuffer):
+class _UniffiConverterTypeSparkInvoiceDetails(_UniffiConverterRustBuffer):
     @staticmethod
     def read(buf):
-        return SparkInvoiceFields(
-            id=_UniffiConverterString.read(buf),
-            version=_UniffiConverterUInt32.read(buf),
-            memo=_UniffiConverterOptionalString.read(buf),
-            sender_public_key=_UniffiConverterOptionalString.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),
-            payment_type=_UniffiConverterOptionalTypeSparkAddressPaymentType.read(buf),
+            description=_UniffiConverterOptionalString.read(buf),
+            sender_public_key=_UniffiConverterOptionalString.read(buf),
         )
 
     @staticmethod
     def check_lower(value):
-        _UniffiConverterString.check_lower(value.id)
-        _UniffiConverterUInt32.check_lower(value.version)
-        _UniffiConverterOptionalString.check_lower(value.memo)
-        _UniffiConverterOptionalString.check_lower(value.sender_public_key)
+        _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)
-        _UniffiConverterOptionalTypeSparkAddressPaymentType.check_lower(value.payment_type)
+        _UniffiConverterOptionalString.check_lower(value.description)
+        _UniffiConverterOptionalString.check_lower(value.sender_public_key)
 
     @staticmethod
     def write(value, buf):
-        _UniffiConverterString.write(value.id, buf)
-        _UniffiConverterUInt32.write(value.version, buf)
-        _UniffiConverterOptionalString.write(value.memo, buf)
-        _UniffiConverterOptionalString.write(value.sender_public_key, 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)
-        _UniffiConverterOptionalTypeSparkAddressPaymentType.write(value.payment_type, buf)
+        _UniffiConverterOptionalString.write(value.description, buf)
+        _UniffiConverterOptionalString.write(value.sender_public_key, buf)
 
 
 class Symbol:
@@ -3089,40 +4431,47 @@ class _UniffiConverterTypeSymbol(_UniffiConverterRustBuffer):
         _UniffiConverterOptionalUInt32.write(value.position, buf)
 
 
-class TokensPaymentDetails:
-    token_identifier: "typing.Optional[str]"
-    amount: "typing.Optional[int]"
-    def __init__(self, *, token_identifier: "typing.Optional[str]", amount: "typing.Optional[int]"):
-        self.token_identifier = token_identifier
-        self.amount = amount
+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 "TokensPaymentDetails(token_identifier={}, amount={})".format(self.token_identifier, self.amount)
+        return "UnversionedRecordChange(id={}, schema_version={}, updated_fields={})".format(self.id, self.schema_version, self.updated_fields)
 
     def __eq__(self, other):
-        if self.token_identifier != other.token_identifier:
+        if self.id != other.id:
             return False
-        if self.amount != other.amount:
+        if self.schema_version != other.schema_version:
+            return False
+        if self.updated_fields != other.updated_fields:
             return False
         return True
 
-class _UniffiConverterTypeTokensPaymentDetails(_UniffiConverterRustBuffer):
+class _UniffiConverterTypeUnversionedRecordChange(_UniffiConverterRustBuffer):
     @staticmethod
     def read(buf):
-        return TokensPaymentDetails(
-            token_identifier=_UniffiConverterOptionalString.read(buf),
-            amount=_UniffiConverterOptionalUInt64.read(buf),
+        return UnversionedRecordChange(
+            id=_UniffiConverterTypeRecordId.read(buf),
+            schema_version=_UniffiConverterString.read(buf),
+            updated_fields=_UniffiConverterMapStringString.read(buf),
         )
 
     @staticmethod
     def check_lower(value):
-        _UniffiConverterOptionalString.check_lower(value.token_identifier)
-        _UniffiConverterOptionalUInt64.check_lower(value.amount)
+        _UniffiConverterTypeRecordId.check_lower(value.id)
+        _UniffiConverterString.check_lower(value.schema_version)
+        _UniffiConverterMapStringString.check_lower(value.updated_fields)
 
     @staticmethod
     def write(value, buf):
-        _UniffiConverterOptionalString.write(value.token_identifier, buf)
-        _UniffiConverterOptionalUInt64.write(value.amount, buf)
+        _UniffiConverterTypeRecordId.write(value.id, buf)
+        _UniffiConverterString.write(value.schema_version, buf)
+        _UniffiConverterMapStringString.write(value.updated_fields, buf)
 
 
 class UrlSuccessActionData:
@@ -3703,6 +5052,24 @@ class InputType:
             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
@@ -3733,6 +5100,8 @@ class InputType:
         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
@@ -3751,6 +5120,7 @@ InputType.BIP21 = type("InputType.BIP21", (InputType.BIP21, InputType,), {})  #
 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
 
 
 
@@ -3811,6 +5181,10 @@ class _UniffiConverterTypeInputType(_UniffiConverterRustBuffer):
             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
@@ -3854,6 +5228,9 @@ class _UniffiConverterTypeInputType(_UniffiConverterRustBuffer):
         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
@@ -3897,6 +5274,9 @@ class _UniffiConverterTypeInputType(_UniffiConverterRustBuffer):
         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)
 
 
 
@@ -4273,120 +5653,21 @@ class _UniffiConverterTypeServiceConnectivityError(_UniffiConverterRustBuffer):
         if isinstance(value, ServiceConnectivityError.Request):
             buf.write_i32(5)
             _UniffiConverterString.write(value._values[0], buf)
-        if isinstance(value, ServiceConnectivityError.Connect):
-            buf.write_i32(6)
-            _UniffiConverterString.write(value._values[0], buf)
-        if isinstance(value, ServiceConnectivityError.Body):
-            buf.write_i32(7)
-            _UniffiConverterString.write(value._values[0], buf)
-        if isinstance(value, ServiceConnectivityError.Decode):
-            buf.write_i32(8)
-            _UniffiConverterString.write(value._values[0], buf)
-        if isinstance(value, ServiceConnectivityError.Json):
-            buf.write_i32(9)
-            _UniffiConverterString.write(value._values[0], buf)
-        if isinstance(value, ServiceConnectivityError.Other):
-            buf.write_i32(10)
-            _UniffiConverterString.write(value._values[0], buf)
-
-
-
-
-
-class SparkAddressPaymentType:
-    def __init__(self):
-        raise RuntimeError("SparkAddressPaymentType cannot be instantiated directly")
-
-    # Each enum variant is a nested class of the enum itself.
-    class TOKENS_PAYMENT:
-        def __init__(self, *values):
-            if len(values) != 1:
-                raise TypeError(f"Expected 1 arguments, found {len(values)}")
-            if not isinstance(values[0], TokensPaymentDetails):
-                raise TypeError(f"unexpected type for tuple element 0 - expected 'TokensPaymentDetails', got '{type(values[0])}'")
-            self._values = values
-
-        def __getitem__(self, index):
-            return self._values[index]
-
-        def __str__(self):
-            return f"SparkAddressPaymentType.TOKENS_PAYMENT{self._values!r}"
-
-        def __eq__(self, other):
-            if not other.is_tokens_payment():
-                return False
-            return self._values == other._values
-    class SATS_PAYMENT:
-        def __init__(self, *values):
-            if len(values) != 1:
-                raise TypeError(f"Expected 1 arguments, found {len(values)}")
-            if not isinstance(values[0], SatsPaymentDetails):
-                raise TypeError(f"unexpected type for tuple element 0 - expected 'SatsPaymentDetails', got '{type(values[0])}'")
-            self._values = values
-
-        def __getitem__(self, index):
-            return self._values[index]
-
-        def __str__(self):
-            return f"SparkAddressPaymentType.SATS_PAYMENT{self._values!r}"
-
-        def __eq__(self, other):
-            if not other.is_sats_payment():
-                return False
-            return self._values == other._values
-    
-
-    # For each variant, we have an `is_NAME` method for easily checking
-    # whether an instance is that variant.
-    def is_tokens_payment(self) -> bool:
-        return isinstance(self, SparkAddressPaymentType.TOKENS_PAYMENT)
-    def is_sats_payment(self) -> bool:
-        return isinstance(self, SparkAddressPaymentType.SATS_PAYMENT)
-    
-
-# 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.
-SparkAddressPaymentType.TOKENS_PAYMENT = type("SparkAddressPaymentType.TOKENS_PAYMENT", (SparkAddressPaymentType.TOKENS_PAYMENT, SparkAddressPaymentType,), {})  # type: ignore
-SparkAddressPaymentType.SATS_PAYMENT = type("SparkAddressPaymentType.SATS_PAYMENT", (SparkAddressPaymentType.SATS_PAYMENT, SparkAddressPaymentType,), {})  # type: ignore
-
-
-
-
-class _UniffiConverterTypeSparkAddressPaymentType(_UniffiConverterRustBuffer):
-    @staticmethod
-    def read(buf):
-        variant = buf.read_i32()
-        if variant == 1:
-            return SparkAddressPaymentType.TOKENS_PAYMENT(
-                _UniffiConverterTypeTokensPaymentDetails.read(buf),
-            )
-        if variant == 2:
-            return SparkAddressPaymentType.SATS_PAYMENT(
-                _UniffiConverterTypeSatsPaymentDetails.read(buf),
-            )
-        raise InternalError("Raw enum value doesn't match any cases")
-
-    @staticmethod
-    def check_lower(value):
-        if value.is_tokens_payment():
-            _UniffiConverterTypeTokensPaymentDetails.check_lower(value._values[0])
-            return
-        if value.is_sats_payment():
-            _UniffiConverterTypeSatsPaymentDetails.check_lower(value._values[0])
-            return
-        raise ValueError(value)
-
-    @staticmethod
-    def write(value, buf):
-        if value.is_tokens_payment():
-            buf.write_i32(1)
-            _UniffiConverterTypeTokensPaymentDetails.write(value._values[0], buf)
-        if value.is_sats_payment():
-            buf.write_i32(2)
-            _UniffiConverterTypeSatsPaymentDetails.write(value._values[0], buf)
-
-
+        if isinstance(value, ServiceConnectivityError.Connect):
+            buf.write_i32(6)
+            _UniffiConverterString.write(value._values[0], buf)
+        if isinstance(value, ServiceConnectivityError.Body):
+            buf.write_i32(7)
+            _UniffiConverterString.write(value._values[0], buf)
+        if isinstance(value, ServiceConnectivityError.Decode):
+            buf.write_i32(8)
+            _UniffiConverterString.write(value._values[0], buf)
+        if isinstance(value, ServiceConnectivityError.Json):
+            buf.write_i32(9)
+            _UniffiConverterString.write(value._values[0], buf)
+        if isinstance(value, ServiceConnectivityError.Other):
+            buf.write_i32(10)
+            _UniffiConverterString.write(value._values[0], buf)
 
 
 
@@ -4676,6 +5957,123 @@ class _UniffiConverterTypeSuccessActionProcessed(_UniffiConverterRustBuffer):
 
 
 
+# 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]
+
+        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 _UniffiConverterTypeSyncStorageError(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        variant = buf.read_i32()
+        if variant == 1:
+            return SyncStorageError.Implementation(
+                _UniffiConverterString.read(buf),
+            )
+        if variant == 2:
+            return SyncStorageError.InitializationError(
+                _UniffiConverterString.read(buf),
+            )
+        if variant == 3:
+            return SyncStorageError.Serialization(
+                _UniffiConverterString.read(buf),
+            )
+        raise InternalError("Raw enum value doesn't match any cases")
+
+    @staticmethod
+    def check_lower(value):
+        if isinstance(value, SyncStorageError.Implementation):
+            _UniffiConverterString.check_lower(value._values[0])
+            return
+        if isinstance(value, SyncStorageError.InitializationError):
+            _UniffiConverterString.check_lower(value._values[0])
+            return
+        if isinstance(value, SyncStorageError.Serialization):
+            _UniffiConverterString.check_lower(value._values[0])
+            return
+
+    @staticmethod
+    def write(value, buf):
+        if isinstance(value, SyncStorageError.Implementation):
+            buf.write_i32(1)
+            _UniffiConverterString.write(value._values[0], buf)
+        if isinstance(value, SyncStorageError.InitializationError):
+            buf.write_i32(2)
+            _UniffiConverterString.write(value._values[0], buf)
+        if isinstance(value, SyncStorageError.Serialization):
+            buf.write_i32(3)
+            _UniffiConverterString.write(value._values[0], buf)
+
+
 
 class _UniffiConverterOptionalUInt32(_UniffiConverterRustBuffer):
     @classmethod
@@ -4785,11 +6183,38 @@ class _UniffiConverterOptionalString(_UniffiConverterRustBuffer):
 
 
 
-class _UniffiConverterOptionalTypeSparkInvoiceFields(_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:
-            _UniffiConverterTypeSparkInvoiceFields.check_lower(value)
+            _UniffiConverterTypeRecord.check_lower(value)
 
     @classmethod
     def write(cls, value, buf):
@@ -4798,7 +6223,7 @@ class _UniffiConverterOptionalTypeSparkInvoiceFields(_UniffiConverterRustBuffer)
             return
 
         buf.write_u8(1)
-        _UniffiConverterTypeSparkInvoiceFields.write(value, buf)
+        _UniffiConverterTypeRecord.write(value, buf)
 
     @classmethod
     def read(cls, buf):
@@ -4806,7 +6231,7 @@ class _UniffiConverterOptionalTypeSparkInvoiceFields(_UniffiConverterRustBuffer)
         if flag == 0:
             return None
         elif flag == 1:
-            return _UniffiConverterTypeSparkInvoiceFields.read(buf)
+            return _UniffiConverterTypeRecord.read(buf)
         else:
             raise InternalError("Unexpected flag byte for optional type")
 
@@ -4866,11 +6291,11 @@ class _UniffiConverterOptionalTypeAmount(_UniffiConverterRustBuffer):
 
 
 
-class _UniffiConverterOptionalTypeSparkAddressPaymentType(_UniffiConverterRustBuffer):
+class _UniffiConverterOptionalMapStringString(_UniffiConverterRustBuffer):
     @classmethod
     def check_lower(cls, value):
         if value is not None:
-            _UniffiConverterTypeSparkAddressPaymentType.check_lower(value)
+            _UniffiConverterMapStringString.check_lower(value)
 
     @classmethod
     def write(cls, value, buf):
@@ -4879,7 +6304,7 @@ class _UniffiConverterOptionalTypeSparkAddressPaymentType(_UniffiConverterRustBu
             return
 
         buf.write_u8(1)
-        _UniffiConverterTypeSparkAddressPaymentType.write(value, buf)
+        _UniffiConverterMapStringString.write(value, buf)
 
     @classmethod
     def read(cls, buf):
@@ -4887,17 +6312,17 @@ class _UniffiConverterOptionalTypeSparkAddressPaymentType(_UniffiConverterRustBu
         if flag == 0:
             return None
         elif flag == 1:
-            return _UniffiConverterTypeSparkAddressPaymentType.read(buf)
+            return _UniffiConverterMapStringString.read(buf)
         else:
             raise InternalError("Unexpected flag byte for optional type")
 
 
 
-class _UniffiConverterOptionalMapStringString(_UniffiConverterRustBuffer):
+class _UniffiConverterOptionalTypeCommonU128(_UniffiConverterRustBuffer):
     @classmethod
     def check_lower(cls, value):
         if value is not None:
-            _UniffiConverterMapStringString.check_lower(value)
+            _UniffiConverterTypeCommonU128.check_lower(value)
 
     @classmethod
     def write(cls, value, buf):
@@ -4906,7 +6331,7 @@ class _UniffiConverterOptionalMapStringString(_UniffiConverterRustBuffer):
             return
 
         buf.write_u8(1)
-        _UniffiConverterMapStringString.write(value, buf)
+        _UniffiConverterTypeCommonU128.write(value, buf)
 
     @classmethod
     def read(cls, buf):
@@ -4914,7 +6339,7 @@ class _UniffiConverterOptionalMapStringString(_UniffiConverterRustBuffer):
         if flag == 0:
             return None
         elif flag == 1:
-            return _UniffiConverterMapStringString.read(buf)
+            return _UniffiConverterTypeCommonU128.read(buf)
         else:
             raise InternalError("Unexpected flag byte for optional type")
 
@@ -5045,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):
@@ -5095,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):
@@ -5151,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
@@ -5271,9 +6849,9 @@ __all__ = [
     "InputType",
     "LnurlCallbackStatus",
     "ServiceConnectivityError",
-    "SparkAddressPaymentType",
     "SuccessAction",
     "SuccessActionProcessed",
+    "SyncStorageError",
     "AesSuccessActionData",
     "AesSuccessActionDataDecrypted",
     "Bip21Details",
@@ -5290,7 +6868,9 @@ __all__ = [
     "Bolt12OfferBlindedPath",
     "Bolt12OfferDetails",
     "CurrencyInfo",
+    "ExternalInputParser",
     "FiatCurrency",
+    "IncomingChange",
     "LightningAddressDetails",
     "LnurlAuthRequestDetails",
     "LnurlErrorDetails",
@@ -5299,17 +6879,21 @@ __all__ = [
     "LocaleOverrides",
     "LocalizedName",
     "MessageSuccessActionData",
+    "OutgoingChange",
     "PaymentRequestSource",
     "Rate",
+    "Record",
+    "RecordChange",
+    "RecordId",
     "RestResponse",
-    "SatsPaymentDetails",
     "SilentPaymentAddressDetails",
-    "SparkAddress",
     "SparkAddressDetails",
-    "SparkInvoiceFields",
+    "SparkInvoiceDetails",
     "Symbol",
-    "TokensPaymentDetails",
+    "UnversionedRecordChange",
     "UrlSuccessActionData",
+    "FiatService",
     "RestClient",
+    "SyncStorage",
 ]