@dittolive/ditto 4.10.2 → 4.11.0-preview.1

package/react-native/android/dittoffi/src/dittoffi.h

@@ -175,7 +175,7 @@ void
  *
  *  The C interface of `TransportHandle` is thread-safe (`Send + Sync`).
  */
-typedef struct TransportHandle_AwdlClientPlatformEvent TransportHandle_AwdlClientPlatformEvent_t;
+typedef struct TransportHandle_AwdlPlatformEvent TransportHandle_AwdlPlatformEvent_t;
 
 /** \brief
  *  Generic enum used by crate and platforms to indicate a connection status
@@ -197,7 +197,7 @@ typedef enum ConnectState {
  */
 void
 /* fn */ awdl_client_connect_state_changed (
-    TransportHandle_AwdlClientPlatformEvent_t const * handle,
+    TransportHandle_AwdlPlatformEvent_t const * handle,
     char const * announce,
     ConnectState_t state);
 
@@ -207,27 +207,16 @@ void
  */
 void
 /* fn */ awdl_client_data_available (
-    TransportHandle_AwdlClientPlatformEvent_t const * handle,
+    TransportHandle_AwdlPlatformEvent_t const * handle,
     char const * announce);
 
-/** \brief
- *  The SDK requests to drop its handle to the AWDL Client Transport
- *
- *  At some point dropping this events channel will effectively shut down and
- *  remove the Transport. At time of writing, the Transport is still owned
- *  within Peer.
- */
-void
-/* fn */ awdl_client_free_handle (
-    TransportHandle_AwdlClientPlatformEvent_t * handle);
-
 /** \brief
  *  The platform advises Rust that a peer has been identified. We know only its
  *  announce string.
  */
 void
 /* fn */ awdl_client_platform_peer_appeared (
-    TransportHandle_AwdlClientPlatformEvent_t const * handle,
+    TransportHandle_AwdlPlatformEvent_t const * handle,
     char const * announce);
 
 /** \brief
@@ -235,7 +224,7 @@ void
  */
 void
 /* fn */ awdl_client_platform_peer_disappeared (
-    TransportHandle_AwdlClientPlatformEvent_t const * handle,
+    TransportHandle_AwdlPlatformEvent_t const * handle,
     char const * announce);
 
 /** \brief
@@ -244,7 +233,7 @@ void
  */
 void
 /* fn */ awdl_client_ready_to_send (
-    TransportHandle_AwdlClientPlatformEvent_t const * handle,
+    TransportHandle_AwdlPlatformEvent_t const * handle,
     char const * announce);
 
 /** \brief
@@ -334,43 +323,16 @@ typedef enum TransportCondition {
  */
 void
 /* fn */ awdl_client_scanning_state_changed (
-    TransportHandle_AwdlClientPlatformEvent_t const * handle,
+    TransportHandle_AwdlPlatformEvent_t const * handle,
     OnlineState_t state,
     TransportCondition_t condition);
 
-/** \brief
- *  An opaque handle for each installed transport, heap-allocated and owned by
- *  the SDK.
- *
- *  A pointer to this handle is used to send platform events over FFI. In the
- *  future this handle will be the SDK's only point of control over the
- *  transport once created. In particular, a transport will be removed by
- *  freeing the handle. The concept of online and offline will be eliminated.
- *  (i.e., if you don't want a transport, remove it.)
- *
- *  For now, the `Peer` object holds the transports and provides an API based on
- *  a numeric id assigned to each transport instance. Until that is removed, the
- *  id still exists and the SDK can request it from the opaque handle over FFI.
- *
- *  For each transport type, define an `extern "C"` function to free that
- *  specific monomorphisation of the `TransportHandle` using `Box::from_raw`,
- *  plus a function to retrieve the transport id, which will be removed later.
- *
- *  Safety: The SDK owns the `TransportHandle`. It is responsible for ensuring
- *  that it does not use the pointer to the `TransportHandle` after freeing it
- *  with its respective function. In Rust we will assume it is okay to unsafely
- *  dereference a handle.
- *
- *  The C interface of `TransportHandle` is thread-safe (`Send + Sync`).
- */
-typedef struct TransportHandle_AwdlServerPlatformEvent TransportHandle_AwdlServerPlatformEvent_t;
-
 /** \brief
  *  The platform advises Rust that advertising status changed
  */
 void
 /* fn */ awdl_server_advertising_state_changed (
-    TransportHandle_AwdlServerPlatformEvent_t const * handle,
+    TransportHandle_AwdlPlatformEvent_t const * handle,
     OnlineState_t state,
     TransportCondition_t condition);
 
@@ -380,7 +342,7 @@ void
  */
 void
 /* fn */ awdl_server_connect_state_changed (
-    TransportHandle_AwdlServerPlatformEvent_t const * handle,
+    TransportHandle_AwdlPlatformEvent_t const * handle,
     int64_t platform_id,
     ConnectState_t state);
 
@@ -390,27 +352,16 @@ void
  */
 void
 /* fn */ awdl_server_data_available (
-    TransportHandle_AwdlServerPlatformEvent_t const * handle,
+    TransportHandle_AwdlPlatformEvent_t const * handle,
     int64_t platform_id);
 
-/** \brief
- *  The SDK requests to drop its handle to the AWDL Server Transport
- *
- *  At some point dropping this events channel will effectively shut down and
- *  remove the Transport. At time of writing, the Transport is still owned
- *  within Peer.
- */
-void
-/* fn */ awdl_server_free_handle (
-    TransportHandle_AwdlServerPlatformEvent_t * handle);
-
 /** \brief
  *  The platform advises Rust that a peer has been identified. We know only its
  *  announce string.
  */
 void
 /* fn */ awdl_server_platform_peer_appeared (
-    TransportHandle_AwdlServerPlatformEvent_t const * handle,
+    TransportHandle_AwdlPlatformEvent_t const * handle,
     int64_t platform_id);
 
 /** \brief
@@ -418,7 +369,7 @@ void
  */
 void
 /* fn */ awdl_server_platform_peer_disappeared (
-    TransportHandle_AwdlServerPlatformEvent_t const * handle,
+    TransportHandle_AwdlPlatformEvent_t const * handle,
     int64_t platform_id);
 
 /** \brief
@@ -427,7 +378,7 @@ void
  */
 void
 /* fn */ awdl_server_ready_to_send (
-    TransportHandle_AwdlServerPlatformEvent_t const * handle,
+    TransportHandle_AwdlPlatformEvent_t const * handle,
     int64_t platform_id);
 
 /** \brief
@@ -455,12 +406,12 @@ void
  *
  *  The C interface of `TransportHandle` is thread-safe (`Send + Sync`).
  */
-typedef struct TransportHandle_BleServerPlatformEvent TransportHandle_BleServerPlatformEvent_t;
+typedef struct TransportHandle_BlePlatformEvent TransportHandle_BlePlatformEvent_t;
 
 /** <No documentation available> */
 void
 /* fn */ ble_advertising_state_changed (
-    TransportHandle_BleServerPlatformEvent_t const * handle,
+    TransportHandle_BlePlatformEvent_t const * handle,
     OnlineState_t state,
     TransportCondition_t result);
 
@@ -471,7 +422,7 @@ typedef struct {
 /** <No documentation available> */
 void
 /* fn */ ble_central_finished_connecting (
-    TransportHandle_BleServerPlatformEvent_t const * handle,
+    TransportHandle_BlePlatformEvent_t const * handle,
     uint8_16_array_t const * uuid,
     slice_ref_uint8_t announce,
     int32_t l2cap_available,
@@ -480,76 +431,38 @@ void
 /** <No documentation available> */
 void
 /* fn */ ble_central_l2cap_data_available (
-    TransportHandle_BleServerPlatformEvent_t const * handle,
+    TransportHandle_BlePlatformEvent_t const * handle,
     uint8_16_array_t const * uuid);
 
 /** <No documentation available> */
 void
 /* fn */ ble_central_l2cap_ready_to_send (
-    TransportHandle_BleServerPlatformEvent_t const * handle,
+    TransportHandle_BlePlatformEvent_t const * handle,
     uint8_16_array_t const * uuid);
 
 /** <No documentation available> */
 void
 /* fn */ ble_central_mtu_updated (
-    TransportHandle_BleServerPlatformEvent_t const * handle,
+    TransportHandle_BlePlatformEvent_t const * handle,
     uint8_16_array_t const * uuid,
     uint32_t mtu);
 
 /** <No documentation available> */
 void
 /* fn */ ble_central_ready_to_send (
-    TransportHandle_BleServerPlatformEvent_t const * handle,
+    TransportHandle_BlePlatformEvent_t const * handle,
     uint8_16_array_t const * uuid);
 
 /** <No documentation available> */
 void
 /* fn */ ble_central_unsubscribed (
-    TransportHandle_BleServerPlatformEvent_t const * handle,
+    TransportHandle_BlePlatformEvent_t const * handle,
     uint8_16_array_t const * central_uuid);
 
-/** \brief
- *  An opaque handle for each installed transport, heap-allocated and owned by
- *  the SDK.
- *
- *  A pointer to this handle is used to send platform events over FFI. In the
- *  future this handle will be the SDK's only point of control over the
- *  transport once created. In particular, a transport will be removed by
- *  freeing the handle. The concept of online and offline will be eliminated.
- *  (i.e., if you don't want a transport, remove it.)
- *
- *  For now, the `Peer` object holds the transports and provides an API based on
- *  a numeric id assigned to each transport instance. Until that is removed, the
- *  id still exists and the SDK can request it from the opaque handle over FFI.
- *
- *  For each transport type, define an `extern "C"` function to free that
- *  specific monomorphisation of the `TransportHandle` using `Box::from_raw`,
- *  plus a function to retrieve the transport id, which will be removed later.
- *
- *  Safety: The SDK owns the `TransportHandle`. It is responsible for ensuring
- *  that it does not use the pointer to the `TransportHandle` after freeing it
- *  with its respective function. In Rust we will assume it is okay to unsafely
- *  dereference a handle.
- *
- *  The C interface of `TransportHandle` is thread-safe (`Send + Sync`).
- */
-typedef struct TransportHandle_BleClientPlatformEvent TransportHandle_BleClientPlatformEvent_t;
-
-/** \brief
- *  The SDK requests to drop its handle to the BLE Client Transport
- *
- *  At some point dropping this events channel will effectively shut down and
- *  remove the Transport. At time of writing, the Transport is still owned
- *  within Peer.
- */
-void
-/* fn */ ble_client_free_handle (
-    TransportHandle_BleClientPlatformEvent_t * handle);
-
 /** <No documentation available> */
 void
 /* fn */ ble_connection_state_changed (
-    TransportHandle_BleClientPlatformEvent_t const * handle,
+    TransportHandle_BlePlatformEvent_t const * handle,
     uint8_16_array_t const * peripheral_uuid,
     ConnectState_t state,
     int32_t l2cap_available,
@@ -558,26 +471,26 @@ void
 /** <No documentation available> */
 void
 /* fn */ ble_peripheral_l2cap_data_available (
-    TransportHandle_BleClientPlatformEvent_t const * handle,
+    TransportHandle_BlePlatformEvent_t const * handle,
     uint8_16_array_t const * uuid);
 
 /** <No documentation available> */
 void
 /* fn */ ble_peripheral_l2cap_ready_to_send (
-    TransportHandle_BleClientPlatformEvent_t const * handle,
+    TransportHandle_BlePlatformEvent_t const * handle,
     uint8_16_array_t const * uuid);
 
 /** <No documentation available> */
 void
 /* fn */ ble_peripheral_mtu_updated (
-    TransportHandle_BleClientPlatformEvent_t const * handle,
+    TransportHandle_BlePlatformEvent_t const * handle,
     uint8_16_array_t const * uuid,
     uint32_t mtu);
 
 /** <No documentation available> */
 void
 /* fn */ ble_peripheral_ready_to_send (
-    TransportHandle_BleClientPlatformEvent_t const * handle,
+    TransportHandle_BlePlatformEvent_t const * handle,
     uint8_16_array_t const * uuid);
 
 /** \brief
@@ -603,7 +516,7 @@ typedef enum BleDataType {
 /** <No documentation available> */
 void
 /* fn */ ble_received_from_central (
-    TransportHandle_BleServerPlatformEvent_t const * handle,
+    TransportHandle_BlePlatformEvent_t const * handle,
     uint8_16_array_t const * central_uuid,
     BleDataType_t data_type,
     slice_ref_uint8_t data);
@@ -611,7 +524,7 @@ void
 /** <No documentation available> */
 void
 /* fn */ ble_received_from_peripheral (
-    TransportHandle_BleClientPlatformEvent_t const * handle,
+    TransportHandle_BlePlatformEvent_t const * handle,
     uint8_16_array_t const * peripheral_uuid,
     BleDataType_t data_type,
     slice_ref_uint8_t data);
@@ -619,21 +532,10 @@ void
 /** <No documentation available> */
 void
 /* fn */ ble_scanning_state_changed (
-    TransportHandle_BleClientPlatformEvent_t const * handle,
+    TransportHandle_BlePlatformEvent_t const * handle,
     OnlineState_t state,
     TransportCondition_t result);
 
-/** \brief
- *  The SDK requests to drop its handle to the BLE Server Transport
- *
- *  At some point dropping this events channel will effectively shut down and
- *  remove the Transport. At time of writing, the Transport is still owned
- *  within Peer.
- */
-void
-/* fn */ ble_server_free_handle (
-    TransportHandle_BleServerPlatformEvent_t * handle);
-
 /** <No documentation available> */
 typedef struct CDitto CDitto_t;
 
@@ -689,15 +591,6 @@ typedef struct AwdlClientCallbacks {
     int32_t (*read_data)(void *, char const *, slice_mut_uint8_t);
 } AwdlClientCallbacks_t;
 
-/** <No documentation available> */
-TransportHandle_AwdlClientPlatformEvent_t *
-/* fn */ ditto_add_awdl_client_transport (
-    CDitto_t const * ditto,
-    AwdlClientCallbacks_t callbacks,
-    void * ctx,
-    void (*retain)(void *),
-    void (*release)(void *));
-
 /** <No documentation available> */
 typedef struct AwdlServerCallbacks {
     /** <No documentation available> */
@@ -717,11 +610,13 @@ typedef struct AwdlServerCallbacks {
 } AwdlServerCallbacks_t;
 
 /** <No documentation available> */
-TransportHandle_AwdlServerPlatformEvent_t *
-/* fn */ ditto_add_awdl_server_transport (
+TransportHandle_AwdlPlatformEvent_t *
+/* fn */ ditto_add_awdl_transport (
     CDitto_t const * ditto,
-    AwdlServerCallbacks_t callbacks,
-    void * ctx,
+    AwdlClientCallbacks_t client_callbacks,
+    void * client_ctx,
+    AwdlServerCallbacks_t server_callbacks,
+    void * server_ctx,
     void (*retain)(void *),
     void (*release)(void *));
 
@@ -767,15 +662,6 @@ typedef struct BleClientCallbacks {
     int32_t (*send_l2cap_to_peripheral)(void *, uint8_16_array_t const *, slice_ref_uint8_t);
 } BleClientCallbacks_t;
 
-/** <No documentation available> */
-TransportHandle_BleClientPlatformEvent_t *
-/* fn */ ditto_add_ble_client_transport (
-    CDitto_t const * ditto,
-    BleClientCallbacks_t callbacks,
-    void * ctx,
-    void (*retain)(void *),
-    void (*release)(void *));
-
 /** <No documentation available> */
 typedef struct BleServerCallbacks {
     /** <No documentation available> */
@@ -798,11 +684,13 @@ typedef struct BleServerCallbacks {
 } BleServerCallbacks_t;
 
 /** <No documentation available> */
-TransportHandle_BleServerPlatformEvent_t *
-/* fn */ ditto_add_ble_server_transport (
+TransportHandle_BlePlatformEvent_t *
+/* fn */ ditto_add_ble_transport (
     CDitto_t const * ditto,
-    BleServerCallbacks_t callbacks,
-    void * ctx,
+    BleClientCallbacks_t client_callbacks,
+    void * client_ctx,
+    BleServerCallbacks_t server_callbacks,
+    void * server_ctx,
     void (*retain)(void *),
     void (*release)(void *));
 
@@ -818,42 +706,6 @@ typedef struct MdnsClientCallbacks {
     void (*resolve_service)(void *, slice_ref_uint8_t);
 } MdnsClientCallbacks_t;
 
-/** \brief
- *  An opaque handle for each installed transport, heap-allocated and owned by
- *  the SDK.
- *
- *  A pointer to this handle is used to send platform events over FFI. In the
- *  future this handle will be the SDK's only point of control over the
- *  transport once created. In particular, a transport will be removed by
- *  freeing the handle. The concept of online and offline will be eliminated.
- *  (i.e., if you don't want a transport, remove it.)
- *
- *  For now, the `Peer` object holds the transports and provides an API based on
- *  a numeric id assigned to each transport instance. Until that is removed, the
- *  id still exists and the SDK can request it from the opaque handle over FFI.
- *
- *  For each transport type, define an `extern "C"` function to free that
- *  specific monomorphisation of the `TransportHandle` using `Box::from_raw`,
- *  plus a function to retrieve the transport id, which will be removed later.
- *
- *  Safety: The SDK owns the `TransportHandle`. It is responsible for ensuring
- *  that it does not use the pointer to the `TransportHandle` after freeing it
- *  with its respective function. In Rust we will assume it is okay to unsafely
- *  dereference a handle.
- *
- *  The C interface of `TransportHandle` is thread-safe (`Send + Sync`).
- */
-typedef struct TransportHandle_MdnsClientPlatformEvent TransportHandle_MdnsClientPlatformEvent_t;
-
-/** <No documentation available> */
-TransportHandle_MdnsClientPlatformEvent_t *
-/* fn */ ditto_add_mdns_client_transport (
-    CDitto_t const * ditto,
-    MdnsClientCallbacks_t callbacks,
-    void * ctx,
-    void (*retain)(void *),
-    void (*release)(void *));
-
 /** <No documentation available> */
 typedef struct MdnsServerCallbacks {
     /** <No documentation available> */
@@ -888,13 +740,14 @@ typedef struct MdnsServerCallbacks {
  *
  *  The C interface of `TransportHandle` is thread-safe (`Send + Sync`).
  */
-typedef struct TransportHandle_MdnsServerPlatformEvent TransportHandle_MdnsServerPlatformEvent_t;
+typedef struct TransportHandle_MdnsPlatformEvent TransportHandle_MdnsPlatformEvent_t;
 
 /** <No documentation available> */
-TransportHandle_MdnsServerPlatformEvent_t *
-/* fn */ ditto_add_mdns_server_transport (
+TransportHandle_MdnsPlatformEvent_t *
+/* fn */ ditto_add_mdns_discovery (
     CDitto_t const * ditto,
-    MdnsServerCallbacks_t callbacks,
+    MdnsClientCallbacks_t client_callbacks,
+    MdnsServerCallbacks_t server_callbacks,
     void * ctx,
     void (*retain)(void *),
     void (*release)(void *));
@@ -1008,42 +861,6 @@ typedef struct WifiAwareClientCallbacks {
     void (*update_peer)(void *, char const *, ConnectState_t);
 } WifiAwareClientCallbacks_t;
 
-/** \brief
- *  An opaque handle for each installed transport, heap-allocated and owned by
- *  the SDK.
- *
- *  A pointer to this handle is used to send platform events over FFI. In the
- *  future this handle will be the SDK's only point of control over the
- *  transport once created. In particular, a transport will be removed by
- *  freeing the handle. The concept of online and offline will be eliminated.
- *  (i.e., if you don't want a transport, remove it.)
- *
- *  For now, the `Peer` object holds the transports and provides an API based on
- *  a numeric id assigned to each transport instance. Until that is removed, the
- *  id still exists and the SDK can request it from the opaque handle over FFI.
- *
- *  For each transport type, define an `extern "C"` function to free that
- *  specific monomorphisation of the `TransportHandle` using `Box::from_raw`,
- *  plus a function to retrieve the transport id, which will be removed later.
- *
- *  Safety: The SDK owns the `TransportHandle`. It is responsible for ensuring
- *  that it does not use the pointer to the `TransportHandle` after freeing it
- *  with its respective function. In Rust we will assume it is okay to unsafely
- *  dereference a handle.
- *
- *  The C interface of `TransportHandle` is thread-safe (`Send + Sync`).
- */
-typedef struct TransportHandle_WifiAwareClientPlatformEvent TransportHandle_WifiAwareClientPlatformEvent_t;
-
-/** <No documentation available> */
-TransportHandle_WifiAwareClientPlatformEvent_t *
-/* fn */ ditto_add_wifi_aware_client_transport (
-    CDitto_t const * ditto,
-    WifiAwareClientCallbacks_t callbacks,
-    void * ctx,
-    void (*retain)(void *),
-    void (*release)(void *));
-
 /** <No documentation available> */
 typedef enum dittoffi_wifi_aware_system_parameter_u64 {
     /** <No documentation available> */
@@ -1094,13 +911,14 @@ typedef struct WifiAwareServerCallbacks {
  *
  *  The C interface of `TransportHandle` is thread-safe (`Send + Sync`).
  */
-typedef struct TransportHandle_WifiAwareServerPlatformEvent TransportHandle_WifiAwareServerPlatformEvent_t;
+typedef struct TransportHandle_WifiAwarePlatformEvent TransportHandle_WifiAwarePlatformEvent_t;
 
 /** <No documentation available> */
-TransportHandle_WifiAwareServerPlatformEvent_t *
-/* fn */ ditto_add_wifi_aware_server_advertiser (
+TransportHandle_WifiAwarePlatformEvent_t *
+/* fn */ ditto_add_wifi_aware_transport (
     CDitto_t const * ditto,
-    WifiAwareServerCallbacks_t callbacks,
+    WifiAwareClientCallbacks_t client_callbacks,
+    WifiAwareServerCallbacks_t server_callbacks,
     void * ctx,
     void (*retain)(void *),
     void (*release)(void *));
@@ -1192,6 +1010,28 @@ void
     CDitto_t const * ditto,
     CLoginProvider_t * login_provider);
 
+/** \brief
+ *  The SDK requests to drop its handle to the AWDL Transport
+ *
+ *  At some point dropping this events channel will effectively shut down and
+ *  remove the Transport. At time of writing, the Transport is still owned
+ *  within Peer.
+ */
+void
+/* fn */ ditto_awdl_transport_free_handle (
+    TransportHandle_AwdlPlatformEvent_t * handle);
+
+/** \brief
+ *  The SDK requests to drop its handle to the BLE Transport
+ *
+ *  At some point dropping this events channel will effectively shut down and
+ *  remove the Transport. At time of writing, the Transport is still owned
+ *  within Peer.
+ */
+void
+/* fn */ ditto_ble_transport_free_handle (
+    TransportHandle_BlePlatformEvent_t * handle);
+
 /** \brief
  *  [`Box`][`rust::Box`]`<[T]>` (fat pointer to a slice),
  *  but with a guaranteed `#[repr(C)]` layout.
@@ -2492,24 +2332,13 @@ void
 int32_t
 /* fn */ ditto_live_query_start (
     CDitto_t const * ditto,
-    int64_t id);
+    int64_t legacy_id);
 
 /** <No documentation available> */
 void
 /* fn */ ditto_live_query_stop (
     CDitto_t const * ditto,
-    int64_t id);
-
-/** <No documentation available> */
-DocIdResult_t
-/* fn */ ditto_live_query_webhook_register_str (
-    CDitto_t const * ditto,
-    char const * coll_name,
-    char const * query,
-    slice_ref_COrderByParam_t order_by,
-    int32_t limit,
-    uint32_t offset,
-    char const * url);
+    int64_t legacy_id);
 
 /** <No documentation available> */
 typedef enum CLogLevel {
@@ -2614,6 +2443,17 @@ CDitto_t *
     CIdentityConfig_t * identity_config,
     HistoryTracking_t history_tracking);
 
+/** \brief
+ *  The SDK requests to drop its handle to the mDNS transport
+ *
+ *  At some point dropping this events channel will effectively shut down and
+ *  remove the Transport. At time of writing, the Transport is still owned
+ *  within Peer.
+ */
+void
+/* fn */ ditto_mdns_transport_free_handle (
+    TransportHandle_MdnsPlatformEvent_t * handle);
+
 /** <No documentation available> */
 typedef struct CAttachment {
     /** <No documentation available> */
@@ -3208,7 +3048,7 @@ void
 /** <No documentation available> */
 void
 /* fn */ ditto_transports_ble_advertisement_heard (
-    TransportHandle_BleClientPlatformEvent_t const * handle,
+    TransportHandle_BlePlatformEvent_t const * handle,
     uint8_16_array_t const * peripheral_uuid,
     slice_ref_uint8_t manufacturer_data,
     bool manufacturer_data_includes_id,
@@ -3278,23 +3118,12 @@ LicenseVerificationResult_t
     char const * license,
     char * * out_err_msg);
 
-/** \brief
- *  The SDK requests to drop its handle to the WifiAware discovery transport
- *
- *  At some point dropping this events channel will effectively shut down and
- *  remove the Transport. At time of writing, the Transport is still owned
- *  within Peer.
- */
-void
-/* fn */ ditto_wifi_aware_client_free_handle (
-    TransportHandle_WifiAwareClientPlatformEvent_t * handle);
-
 /** \brief
  *  The platform tells Rust that it should go offline.
  */
 void
 /* fn */ ditto_wifi_aware_client_go_offline_request (
-    TransportHandle_WifiAwareClientPlatformEvent_t const * handle);
+    TransportHandle_WifiAwarePlatformEvent_t const * handle);
 
 /** \brief
  *  The platform tells Rust that it should go online (because the platform has attached to the WiFi
@@ -3302,14 +3131,14 @@ void
  */
 void
 /* fn */ ditto_wifi_aware_client_go_online_request (
-    TransportHandle_WifiAwareClientPlatformEvent_t const * handle);
+    TransportHandle_WifiAwarePlatformEvent_t const * handle);
 
 /** \brief
  *  The platform advises Rust that we have resolved a peer's hostname and port
  */
 void
 /* fn */ ditto_wifi_aware_client_network_did_create (
-    TransportHandle_WifiAwareClientPlatformEvent_t const * handle,
+    TransportHandle_WifiAwarePlatformEvent_t const * handle,
     char const * announce_string,
     char const * hostname,
     uint16_t port);
@@ -3319,7 +3148,7 @@ void
  */
 void
 /* fn */ ditto_wifi_aware_client_peer_appeared (
-    TransportHandle_WifiAwareClientPlatformEvent_t const * handle,
+    TransportHandle_WifiAwarePlatformEvent_t const * handle,
     char const * announce_string);
 
 /** \brief
@@ -3328,7 +3157,7 @@ void
  */
 void
 /* fn */ ditto_wifi_aware_client_peer_did_not_connect (
-    TransportHandle_WifiAwareClientPlatformEvent_t const * handle,
+    TransportHandle_WifiAwarePlatformEvent_t const * handle,
     char const * announce_string);
 
 /** \brief
@@ -3336,7 +3165,7 @@ void
  */
 void
 /* fn */ ditto_wifi_aware_client_peer_disappeared (
-    TransportHandle_WifiAwareClientPlatformEvent_t const * handle,
+    TransportHandle_WifiAwarePlatformEvent_t const * handle,
     char const * announce_string);
 
 /** \brief
@@ -3345,7 +3174,7 @@ void
  */
 void
 /* fn */ ditto_wifi_aware_client_scanning_state_changed (
-    TransportHandle_WifiAwareClientPlatformEvent_t const * handle,
+    TransportHandle_WifiAwarePlatformEvent_t const * handle,
     OnlineState_t state,
     TransportCondition_t condition);
 
@@ -3355,26 +3184,16 @@ void
  */
 void
 /* fn */ ditto_wifi_aware_server_advertising_state_changed (
-    TransportHandle_WifiAwareServerPlatformEvent_t const * handle,
+    TransportHandle_WifiAwarePlatformEvent_t const * handle,
     OnlineState_t state,
     TransportCondition_t condition);
 
-/** \brief
- *  The SDK requests to drop its handle to the WifiAware advertising service.
- *
- *  Ideally this should remove the advertiser automatically.
- *  At time of writing now this must be done manually through Peer.
- */
-void
-/* fn */ ditto_wifi_aware_server_free_handle (
-    TransportHandle_WifiAwareServerPlatformEvent_t * handle);
-
 /** \brief
  *  The platform tells Rust that it should go offline.
  */
 void
 /* fn */ ditto_wifi_aware_server_go_offline_request (
-    TransportHandle_WifiAwareServerPlatformEvent_t const * handle);
+    TransportHandle_WifiAwarePlatformEvent_t const * handle);
 
 /** \brief
  *  The platform tells Rust that it should go online (because the platform has attached to the WiFi
@@ -3382,7 +3201,34 @@ void
  */
 void
 /* fn */ ditto_wifi_aware_server_go_online_request (
-    TransportHandle_WifiAwareServerPlatformEvent_t const * handle);
+    TransportHandle_WifiAwarePlatformEvent_t const * handle);
+
+/** \brief
+ *  The platform tells Rust that a WiFi Aware network has been added
+ */
+void
+/* fn */ ditto_wifi_aware_server_network_scope_id_added (
+    TransportHandle_WifiAwarePlatformEvent_t const * handle,
+    uint32_t scope_id);
+
+/** \brief
+ *  The platform tells Rust that a WiFi Aware network has been removed
+ */
+void
+/* fn */ ditto_wifi_aware_server_network_scope_id_removed (
+    TransportHandle_WifiAwarePlatformEvent_t const * handle,
+    uint32_t scope_id);
+
+/** \brief
+ *  The SDK requests to drop its handle to the WifiAware transport
+ *
+ *  At some point dropping this events channel will effectively shut down and
+ *  remove the Transport. At time of writing, the Transport is still owned
+ *  within Peer.
+ */
+void
+/* fn */ ditto_wifi_aware_transport_free_handle (
+    TransportHandle_WifiAwarePlatformEvent_t * handle);
 
 /** <No documentation available> */
 typedef struct CWriteTransactionResult {
@@ -3453,6 +3299,13 @@ int32_t
     CDitto_t const * _ditto,
     CWriteTransaction_t * transaction);
 
+/** \brief
+ *  This is not meant to be part of the SDK surface: it's a shared secret that SDKs use when
+ *  constructing a "login provider" for development (fka "online playground").
+ */
+char const *
+/* fn */ dittoffi_DITTO_DEVELOPMENT_PROVIDER (void);
+
 /** <No documentation available> */
 void
 /* fn */ dittoffi_authentication_register_local_server_backend (
@@ -3606,36 +3459,167 @@ char *
 /* fn */ dittoffi_crypto_generate_secure_random_token (void);
 
 /** \brief
- *  Internal helper function to do integration testing of stacktrace generation in the SDKs.
+ *  An FFI appropriate, opaque representation of a differ.
  */
-char *
-/* fn */ dittoffi_ditto_capture_stack_trace_string_internal (void);
+typedef struct dittoffi_differ dittoffi_differ_t;
 
 /** \brief
- *  The ditto error type, opaque.
+ *  An individual result item from a query result (which holds a list of these items).
  */
-typedef struct dittoffi_error dittoffi_error_t;
-
-/** <No documentation available> */
-typedef struct dittoffi_result_uint64 {
-    /** \brief
-     *  Non-`NULL` pointer to opaque object on error, `NULL` otherwise.
-     */
-    dittoffi_error_t * error;
-
-    /** \brief
-     *  When no error occurred, the success value payload can be retrieved here.
-     *
-     *  Otherwise, the value is to be ignored.
-     */
-    uint64_t success;
-} dittoffi_result_uint64_t;
+typedef struct dittoffi_query_result_item dittoffi_query_result_item_t;
 
-/** <No documentation available> */
-dittoffi_result_uint64_t
-/* fn */ dittoffi_ditto_get_system_parameter_u64 (
-    CDitto_t const * ditto,
-    char const * parameter_name);
+/** \brief
+ *  `&'lt [T]` but with a guaranteed `#[repr(C)]` layout.
+ *
+ *  # C layout (for some given type T)
+ *
+ *  ```c
+ *  typedef struct {
+ *  // Cannot be NULL
+ *  T * ptr;
+ *  size_t len;
+ *  } slice_T;
+ *  ```
+ *
+ *  # Nullable pointer?
+ *
+ *  If you want to support the above typedef, but where the `ptr` field is
+ *  allowed to be `NULL` (with the contents of `len` then being undefined)
+ *  use the `Option< slice_ptr<_> >` type.
+ */
+typedef struct slice_ref_dittoffi_query_result_item_ptr {
+    /** \brief
+     *  Pointer to the first element (if any).
+     */
+    dittoffi_query_result_item_t * const * ptr;
+
+    /** \brief
+     *  Element count
+     */
+    size_t len;
+} slice_ref_dittoffi_query_result_item_ptr_t;
+
+/** <No documentation available> */
+typedef slice_boxed_uint8_t dittoffi_cbor_data_t;
+
+/** \brief
+ *  Generate a diff between the given items and the differ's current list of items.
+ *
+ *  The diff is returned as a CBOR serialized object, in the form of an object like this:
+ *
+ *  ```json
+ *  {
+ *  "insertions": [0, 1],
+ *  "deletions": [2, 3],
+ *  "updates": [4, 5],
+ *  "moves": [[6, 7], [8, 9]]
+ *  }
+ *  ```
+ *
+ *  Note that the `moves` array is an array of arrays, where each inner array is a pair of indices
+ *  representing `from` and `to` indices. The `from` index is the first element in the array and the
+ *  `to` index is the second element in the array, for each array in the `moves` array.
+ */
+dittoffi_cbor_data_t
+/* fn */ dittoffi_differ_diff (
+    dittoffi_differ_t const * differ,
+    slice_ref_dittoffi_query_result_item_ptr_t items);
+
+/** \brief
+ *  Free the differ.
+ */
+void
+/* fn */ dittoffi_differ_free (
+    dittoffi_differ_t * differ);
+
+/** \brief
+ *  Returns the identity key path at the given index in the differ's list of identity key paths.
+ *
+ *  # Safety
+ *
+ *  The caller must ensure that the index is valid (i.e. less than the count of identity key paths).
+ */
+char *
+/* fn */ dittoffi_differ_identity_key_path_at (
+    dittoffi_differ_t const * differ,
+    size_t idx);
+
+/** \brief
+ *  Returns the number of identity key paths in use by the differ.
+ */
+size_t
+/* fn */ dittoffi_differ_identity_key_path_count (
+    dittoffi_differ_t const * differ);
+
+/** \brief
+ *  Create a new differ.
+ *
+ *  This differ will use the default identity key paths list, which is just `["_id"]`. This is the
+ *  default because the legacy query builder differ code uses the equivalent to this.
+ */
+dittoffi_differ_t *
+/* fn */ dittoffi_differ_new (void);
+
+/** \brief
+ *  The ditto error type, opaque.
+ */
+typedef struct dittoffi_error dittoffi_error_t;
+
+/** <No documentation available> */
+typedef struct dittoffi_result_dittoffi_differ_ptr {
+    /** \brief
+     *  Non-`NULL` pointer to opaque object on error, `NULL` otherwise.
+     */
+    dittoffi_error_t * error;
+
+    /** \brief
+     *  When no error occurred, the success value payload can be retrieved here.
+     *
+     *  Otherwise, the value is to be ignored.
+     */
+    dittoffi_differ_t * success;
+} dittoffi_result_dittoffi_differ_ptr_t;
+
+/** \brief
+ *  Create a new differ using the provided identity key paths.
+ */
+dittoffi_result_dittoffi_differ_ptr_t
+/* fn */ dittoffi_differ_new_with_identity_key_paths_throws (
+    slice_ref_char_const_ptr_t identity_key_paths);
+
+/** \brief
+ *  Internal helper function to do integration testing of stacktrace generation in the SDKs.
+ */
+char *
+/* fn */ dittoffi_ditto_capture_stack_trace_string_internal (void);
+
+/** \brief
+ *  Getter for `DittoConfig` serialized as CBOR, according to the DittoConfig.schema.json schema.
+ */
+slice_boxed_uint8_t
+/* fn */ dittoffi_ditto_config (
+    CDitto_t const * ditto);
+
+/** <No documentation available> */
+typedef struct dittoffi_result_uint64 {
+    /** \brief
+     *  Non-`NULL` pointer to opaque object on error, `NULL` otherwise.
+     */
+    dittoffi_error_t * error;
+
+    /** \brief
+     *  When no error occurred, the success value payload can be retrieved here.
+     *
+     *  Otherwise, the value is to be ignored.
+     */
+    uint64_t success;
+} dittoffi_result_uint64_t;
+
+/** <No documentation available> */
+dittoffi_result_uint64_t
+/* fn */ dittoffi_ditto_get_system_parameter_u64 (
+    CDitto_t const * ditto,
+    char const * parameter_name);
 
 /** \brief
  *  Returns whether or not the Ditto instance has been activated with a valid license token.
@@ -3651,6 +3635,99 @@ bool
 /* fn */ dittoffi_ditto_is_sync_active (
     CDitto_t const * ditto);
 
+/** \brief
+ *  Whether or not the default values for parts of a `TransportConfig` that could be
+ *  platform-dependent should be determined based on the platform that the SDK is running on.
+ *
+ *  For example, if `PlatformDependent` is chosen for the `TransportConfigMode`, then the default
+ *  value for whether AWDL would be enabled would be based on whether the SDK is running on an Apple
+ *  platform. Specifically, if you were running on an iOS device, for example, then AWDL would
+ *  default to enabled, but if you were using the .NET SDK running on a Windows machine then AWDL
+ *  would default to false.
+ *
+ *  If `TransportConfigMode::PlatformIndependent` is chosen, then the default value would always be
+ *  true (at least in the case of whether or not AWDL is enabled).
+ *
+ *  This really only exists to cater for the difference in behavior between the JS (and Flutter) and
+ *  other SDKs. The JS SDK's default value for platform-specific transports will be determined by
+ *  the platform that the JS SDK is running on, whereas the other SDKs will default to the same
+ *  value regardless of the platform that they are running on.
+ */
+typedef enum TransportConfigMode {
+    /** <No documentation available> */
+    TRANSPORT_CONFIG_MODE_PLATFORM_DEPENDENT,
+    /** <No documentation available> */
+    TRANSPORT_CONFIG_MODE_PLATFORM_INDEPENDENT,
+} TransportConfigMode_t;
+
+/** <No documentation available> */
+typedef struct dittoffi_result_CDitto_ptr {
+    /** \brief
+     *  Non-`NULL` pointer to opaque object on error, `NULL` otherwise.
+     */
+    dittoffi_error_t * error;
+
+    /** \brief
+     *  When no error occurred, the success value payload can be retrieved here.
+     *
+     *  Otherwise, the value is to be ignored.
+     */
+    CDitto_t * success;
+} dittoffi_result_CDitto_ptr_t;
+
+/** \brief
+ *  `Box<dyn 'static + Send + FnMut(A1) -> Ret>`
+ */
+typedef struct BoxDynFnMut1_void_dittoffi_result_CDitto_ptr {
+    /** <No documentation available> */
+    void * env_ptr;
+
+    /** <No documentation available> */
+    void (*call)(void *, dittoffi_result_CDitto_ptr_t);
+
+    /** <No documentation available> */
+    void (*free)(void *);
+} BoxDynFnMut1_void_dittoffi_result_CDitto_ptr_t;
+
+/** \brief
+ *  Continuation (`repr_c::Box<dyn FnMut(…)>` FFI-safe callback) to be used as
+ *  the *completion handler* for conceptually-`async` APIs.
+ */
+typedef BoxDynFnMut1_void_dittoffi_result_CDitto_ptr_t continuation_dittoffi_result_CDitto_ptr_t;
+
+/** \brief
+ *  One of the two supported factory functions / constructors for opening a Ditto instance.
+ *
+ *  * `config_cbor` - `DittoConfig` serialized as CBOR, according to the DittoConfig.schema.json
+ *  schema
+ *
+ *  Nothing interesting happens in this function: it simply calls `Ditto::new` after creating a
+ *  `TaskRuntime`.
+ *
+ *  See: `dittoffi_ditto_open_throws` for a synchronous version.
+ */
+void
+/* fn */ dittoffi_ditto_open_async_throws (
+    slice_ref_uint8_t config_cbor,
+    TransportConfigMode_t transport_config_mode,
+    continuation_dittoffi_result_CDitto_ptr_t continuation);
+
+/** \brief
+ *  One of the two supported factory functions / constructors for opening a Ditto instance.
+ *
+ *  * `config_cbor` - `DittoConfig` serialized as CBOR, according to the DittoConfig.schema.json
+ *  schema
+ *
+ *  Nothing interesting happens in this function: it simply calls *and blocks on* `Ditto::new` after
+ *  creating a `TaskRuntime`.
+ *
+ *  See: `dittoffi_ditto_open_async_throws` for an asynchronous version.
+ */
+dittoffi_result_CDitto_ptr_t
+/* fn */ dittoffi_ditto_open_throws (
+    slice_ref_uint8_t config_cbor,
+    TransportConfigMode_t transport_config_mode);
+
 /** \brief
  *  `Box<dyn 'static + Send + FnMut(A1) -> Ret>`
  */
@@ -3766,46 +3843,6 @@ int32_t
 void
 /* fn */ dittoffi_ditto_trigger_test_panic_in_background (void);
 
-/** \brief
- *  Whether or not the default values for parts of a `TransportConfig` that could be
- *  platform-dependent should be determined based on the platform that the SDK is running on.
- *
- *  For example, if `PlatformDependent` is chosen for the `TransportConfigMode`, then the default
- *  value for whether AWDL would be enabled would be based on whether the SDK is running on an Apple
- *  platform. Specifically, if you were running on an iOS device, for example, then AWDL would
- *  default to enabled, but if you were using the .NET SDK running on a Windows machine then AWDL
- *  would default to false.
- *
- *  If `TransportConfigMode::PlatformIndependent` is chosen, then the default value would always be
- *  true (at least in the case of whether or not AWDL is enabled).
- *
- *  This really only exists to cater for the difference in behavior between the JS (and Flutter) and
- *  other SDKs. The JS SDK's default value for platform-specific transports will be determined by
- *  the platform that the JS SDK is running on, whereas the other SDKs will default to the same
- *  value regardless of the platform that they are running on.
- */
-typedef enum TransportConfigMode {
-    /** <No documentation available> */
-    TRANSPORT_CONFIG_MODE_PLATFORM_DEPENDENT,
-    /** <No documentation available> */
-    TRANSPORT_CONFIG_MODE_PLATFORM_INDEPENDENT,
-} TransportConfigMode_t;
-
-/** <No documentation available> */
-typedef struct dittoffi_result_CDitto_ptr {
-    /** \brief
-     *  Non-`NULL` pointer to opaque object on error, `NULL` otherwise.
-     */
-    dittoffi_error_t * error;
-
-    /** \brief
-     *  When no error occurred, the success value payload can be retrieved here.
-     *
-     *  Otherwise, the value is to be ignored.
-     */
-    CDitto_t * success;
-} dittoffi_result_CDitto_ptr_t;
-
 /** \brief
  *  Same as `ditto_make`, but properly fallible (but not yet `async`).
  */
@@ -3889,6 +3926,8 @@ typedef enum dittoffi_error_code {
     DITTOFFI_ERROR_CODE_CBOR_UNSUPPORTED,
     /** <No documentation available> */
     DITTOFFI_ERROR_CODE_CRDT,
+    /** <No documentation available> */
+    DITTOFFI_ERROR_CODE_DIFFER_IDENTITY_KEY_PATH_INVALID,
     /** \brief
      *  Dql query execution failed in flight.
      */
@@ -4173,9 +4212,6 @@ void
 /* fn */ dittoffi_query_result_free (
     dittoffi_query_result_t * result);
 
-/** <No documentation available> */
-typedef struct dittoffi_query_result_item dittoffi_query_result_item_t;
-
 /** <No documentation available> */
 dittoffi_query_result_item_t *
 /* fn */ dittoffi_query_result_item_at (
@@ -4202,6 +4238,34 @@ char *
 /* fn */ dittoffi_query_result_item_json (
     dittoffi_query_result_item_t const * item);
 
+/** <No documentation available> */
+typedef struct dittoffi_result_dittoffi_query_result_item_ptr {
+    /** \brief
+     *  Non-`NULL` pointer to opaque object on error, `NULL` otherwise.
+     */
+    dittoffi_error_t * error;
+
+    /** \brief
+     *  When no error occurred, the success value payload can be retrieved here.
+     *
+     *  Otherwise, the value is to be ignored.
+     */
+    dittoffi_query_result_item_t * success;
+} dittoffi_result_dittoffi_query_result_item_ptr_t;
+
+/** \brief
+ *  Create a query result item from JSON data.
+ *
+ *  `query_result_item` is expected to represent the UTF-8 bytes of a serialized JSON instead of
+ *  CBOR.
+ *
+ *  Note that this is only expected to be called by SDKs as part of generating test data, e.g. for
+ *  testing behaviour of the differ.
+ */
+dittoffi_result_dittoffi_query_result_item_ptr_t
+/* fn */ dittoffi_query_result_item_new (
+    slice_ref_uint8_t query_result_item);
+
 /** <No documentation available> */
 slice_boxed_uint8_t
 /* fn */ dittoffi_query_result_mutated_document_id_at (
@@ -4216,6 +4280,10 @@ size_t
 /** \brief
  *  Alias for `Ditto`, to better convey the notion of a store handle for store APIs,
  *  TownHouse™-style.
+ *
+ *  SDK code casts references to `Ditto`s into references to `FfiStore`s, so it's important for
+ *  safety that FfiStore doesn't add future invariants without checking `Transaction::store_ptr`
+ *  (and potentially other places too) to make sure those invariants are upheld.
  */
 typedef CDitto_t dittoffi_store_t;
 
@@ -4286,8 +4354,143 @@ void
 dittoffi_store_begin_transaction_options_t
 /* fn */ dittoffi_store_begin_transaction_options_make (void);
 
+/** \brief
+ *  An opaque, unique handle for a `StoreObserver`.
+ *
+ *  This handle will be held by SDK callers above the FFI boundary. It is a required input to most
+ *  of the other FFI store observer functions.
+ */
+typedef struct dittoffi_store_observer dittoffi_store_observer_t;
+
+/** \brief
+ *  Cancels the observer and removes it from the list of registered observers.
+ */
+void
+/* fn */ dittoffi_store_observer_cancel (
+    dittoffi_store_observer_t const * observer);
+
+/** \brief
+ *  Free an [`FfiStoreObserver`].
+ */
+void
+/* fn */ dittoffi_store_observer_free (
+    dittoffi_store_observer_t * _observer);
+
+/** \brief
+ *  Same as [`Vec<T>`][`rust::Vec`], but with guaranteed `#[repr(C)]` layout
+ */
+typedef struct Vec_dittoffi_store_observer_ptr {
+    /** <No documentation available> */
+    dittoffi_store_observer_t * * ptr;
+
+    /** <No documentation available> */
+    size_t len;
+
+    /** <No documentation available> */
+    size_t cap;
+} Vec_dittoffi_store_observer_ptr_t;
+
+/** \brief
+ *  Free a Vec of [`FfiStoreObserver`]
+ */
+void
+/* fn */ dittoffi_store_observer_free_sparse (
+    Vec_dittoffi_store_observer_ptr_t _vec);
+
+/** \brief
+ *  Returns the inner ID of the given observer.
+ *
+ *  This is an implementation detail and should not be relied upon by third parties.
+ */
+slice_boxed_uint8_t
+/* fn */ dittoffi_store_observer_id (
+    dittoffi_store_observer_t const * observer);
+
+/** \brief
+ *  Returns true if the given observer is cancelled.
+ */
+bool
+/* fn */ dittoffi_store_observer_is_cancelled (
+    dittoffi_store_observer_t const * observer);
+
+/** \brief
+ *  Returns the DQL query arguments of the given observer, if any were given.
+ */
+slice_boxed_uint8_t
+/* fn */ dittoffi_store_observer_query_arguments (
+    dittoffi_store_observer_t const * observer);
+
+/** \brief
+ *  Returns the DQL query string of the given observer.
+ */
+char *
+/* fn */ dittoffi_store_observer_query_string (
+    dittoffi_store_observer_t const * observer);
+
+/** \brief
+ *  Returns a list of all registered observers.
+ */
+Vec_dittoffi_store_observer_ptr_t
+/* fn */ dittoffi_store_observers (
+    CDitto_t const * ditto);
+
+/** \brief
+ *  `Arc<dyn Send + Sync + Fn() -> Ret>`
+ */
+typedef struct ArcDynFn0_void {
+    /** <No documentation available> */
+    void * env_ptr;
+
+    /** <No documentation available> */
+    void (*call)(void *);
+
+    /** <No documentation available> */
+    void (*release)(void *);
+
+    /** <No documentation available> */
+    void (*retain)(void *);
+} ArcDynFn0_void_t;
+
+/** \brief
+ *  `Box<dyn 'static + Send + FnMut(A2, A1) -> Ret>`
+ */
+typedef struct BoxDynFnMut2_void_dittoffi_query_result_ptr_ArcDynFn0_void {
+    /** <No documentation available> */
+    void * env_ptr;
+
+    /** <No documentation available> */
+    void (*call)(void *, dittoffi_query_result_t *, ArcDynFn0_void_t);
+
+    /** <No documentation available> */
+    void (*free)(void *);
+} BoxDynFnMut2_void_dittoffi_query_result_ptr_ArcDynFn0_void_t;
+
 /** <No documentation available> */
-typedef slice_boxed_uint8_t dittoffi_cbor_data_t;
+typedef struct dittoffi_result_dittoffi_store_observer_ptr {
+    /** \brief
+     *  Non-`NULL` pointer to opaque object on error, `NULL` otherwise.
+     */
+    dittoffi_error_t * error;
+
+    /** \brief
+     *  When no error occurred, the success value payload can be retrieved here.
+     *
+     *  Otherwise, the value is to be ignored.
+     */
+    dittoffi_store_observer_t * success;
+} dittoffi_result_dittoffi_store_observer_ptr_t;
+
+/** \brief
+ *  Registers a new `StoreObserver` for the given DQL query and arguments.
+ *
+ *  The observer will be notified of changes to the query results.
+ */
+dittoffi_result_dittoffi_store_observer_ptr_t
+/* fn */ dittoffi_store_register_observer_throws (
+    CDitto_t const * ditto,
+    char const * query,
+    slice_ref_uint8_t query_args_cbor,
+    BoxDynFnMut2_void_dittoffi_query_result_ptr_ArcDynFn0_void_t callback);
 
 /** \brief
  *  Returns all transactions currently in flight.
@@ -4296,7 +4499,9 @@ dittoffi_cbor_data_t
 /* fn */ dittoffi_store_transactions (
     dittoffi_store_t const * ffi_store);
 
-/** <No documentation available> */
+/** \brief
+ *  An object that causes Ditto to continuously sync documents that match a query from other peers.
+ */
 typedef struct dittoffi_sync_subscription dittoffi_sync_subscription_t;
 
 /** <No documentation available> */
@@ -4314,17 +4519,25 @@ typedef struct dittoffi_result_dittoffi_sync_subscription_ptr {
     dittoffi_sync_subscription_t * success;
 } dittoffi_result_dittoffi_sync_subscription_ptr_t;
 
-/** <No documentation available> */
+/** \brief
+ *  Create a new [`FfiSyncSubscription`] from a DQL query and arguments.
+ *
+ *  Until the subscription is cancelled, Ditto will continue to sync data matching the
+ *  subscription's query from other peers.
+ */
 dittoffi_result_dittoffi_sync_subscription_ptr_t
 /* fn */ dittoffi_sync_register_subscription_throws (
     CDitto_t const * ditto,
     char const * query,
     slice_ref_uint8_t query_args_cbor);
 
-/** <No documentation available> */
+/** \brief
+ *  Cancels the given sync subscription, after which Ditto will no longer sync the data matching
+ *  the subscription's query.
+ */
 void
 /* fn */ dittoffi_sync_subscription_cancel (
-    dittoffi_sync_subscription_t const * handle);
+    dittoffi_sync_subscription_t const * sync_subscription);
 
 /** \brief
  *  Free a singular boxed [`FfiSyncSubscription`].
@@ -4338,26 +4551,28 @@ void
  */
 slice_boxed_uint8_t
 /* fn */ dittoffi_sync_subscription_id (
-    dittoffi_sync_subscription_t const * handle);
+    dittoffi_sync_subscription_t const * sync_subscription);
 
-/** <No documentation available> */
+/** \brief
+ *  Returns true if the given sync subscription has been cancelled.
+ */
 bool
 /* fn */ dittoffi_sync_subscription_is_cancelled (
-    dittoffi_sync_subscription_t const * handle);
+    dittoffi_sync_subscription_t const * sync_subscription);
 
 /** \brief
- *  From a `FfiSyncSubscription` handle, extract the DQL query query arguments as a CBOR buffer.
+ *  Returns the DQL arguments object associated with the given sync subscription, if one exists.
  */
 slice_boxed_uint8_t
 /* fn */ dittoffi_sync_subscription_query_arguments (
-    dittoffi_sync_subscription_t const * handle);
+    dittoffi_sync_subscription_t const * sync_subscription);
 
 /** \brief
- *  From a `FfiSyncSubscription` handle, extract the DQL query string.
+ *  Returns the DQL query string associated with the given sync subscription.
  */
 char *
 /* fn */ dittoffi_sync_subscription_query_string (
-    dittoffi_sync_subscription_t const * handle);
+    dittoffi_sync_subscription_t const * sync_subscription);
 
 /** \brief
  *  Same as [`Vec<T>`][`rust::Vec`], but with guaranteed `#[repr(C)]` layout
@@ -4373,7 +4588,9 @@ typedef struct Vec_dittoffi_sync_subscription_ptr {
     size_t cap;
 } Vec_dittoffi_sync_subscription_ptr_t;
 
-/** <No documentation available> */
+/** \brief
+ *  Returns a list of all active sync subscriptions.
+ */
 Vec_dittoffi_sync_subscription_ptr_t
 /* fn */ dittoffi_sync_subscriptions (
     CDitto_t const * ditto);
@@ -4760,12 +4977,13 @@ dittoffi_result_slice_boxed_uint8_t
 /** \brief
  *  Execute specified DQL statement.
  *
- *  Returns a [`QueryResult`], which contains a vector of [`QueryResultItem`]s.
+ *  Returns a [`FfiQueryResult`], which contains a vector of [`FfiQueryResultItem`]s.
  *
  *  This is replacement for the old FFI, which was returning documents, but still uses the "old"
  *  style of FFI transaction API.
  *
- *  [`QueryResultItem`]: crate::store::dql::response::QueryResultItem
+ *  [`FfiQueryResult`]: crate::store::dql::response::FfiQueryResult
+ *  [`FfiQueryResultItem`]: crate::store::dql::response::FfiQueryResultItem
  */
 dittoffi_result_dittoffi_query_result_ptr_t
 /* fn */ dittoffi_try_exec_statement (
@@ -4832,7 +5050,7 @@ dittoffi_result_Vec_char_ptr_t
 dittoffi_result_void_t
 /* fn */ dittoffi_try_live_query_start (
     CDitto_t const * ditto,
-    int64_t id);
+    int64_t legacy_id);
 
 /** <No documentation available> */
 dittoffi_result_uint64_t
@@ -4921,27 +5139,16 @@ dittoffi_result_void_t
  */
 void
 /* fn */ mdns_advertising_state_changed (
-    TransportHandle_MdnsServerPlatformEvent_t const * handle,
+    TransportHandle_MdnsPlatformEvent_t const * handle,
     OnlineState_t state,
     TransportCondition_t condition);
 
-/** \brief
- *  The SDK requests to drop its handle to the mDNS discovery transport
- *
- *  At some point dropping this events channel will effectively shut down and
- *  remove the Transport. At time of writing, the Transport is still owned
- *  within Peer.
- */
-void
-/* fn */ mdns_client_free_handle (
-    TransportHandle_MdnsClientPlatformEvent_t * handle);
-
 /** \brief
  *  The platform advises Rust that a peer has been identified.
  */
 void
 /* fn */ mdns_platform_peer_appeared (
-    TransportHandle_MdnsClientPlatformEvent_t const * handle,
+    TransportHandle_MdnsPlatformEvent_t const * handle,
     char const * announce_string);
 
 /** \brief
@@ -4949,7 +5156,7 @@ void
  */
 void
 /* fn */ mdns_platform_peer_disappeared (
-    TransportHandle_MdnsClientPlatformEvent_t const * handle,
+    TransportHandle_MdnsPlatformEvent_t const * handle,
     char const * announce_string);
 
 /** \brief
@@ -4958,26 +5165,16 @@ void
  */
 void
 /* fn */ mdns_scanning_state_changed (
-    TransportHandle_MdnsClientPlatformEvent_t const * handle,
+    TransportHandle_MdnsPlatformEvent_t const * handle,
     OnlineState_t state,
     TransportCondition_t condition);
 
-/** \brief
- *  The SDK requests to drop its handle to the mDNS advertising service.
- *
- *  Ideally this should remove the advertiser automatically.
- *  At time of writing now this must be done manually through Peer.
- */
-void
-/* fn */ mdns_server_free_handle (
-    TransportHandle_MdnsServerPlatformEvent_t * handle);
-
 /** \brief
  *  The platform advises Rust that the TCP listener will need to be restarted.
  */
 void
 /* fn */ mdns_server_invalidate_listener (
-    TransportHandle_MdnsServerPlatformEvent_t const * handle);
+    TransportHandle_MdnsPlatformEvent_t const * handle);
 
 /** \brief
  *  The platform advises Rust that we failed to resolve a peer's hostname and
@@ -4985,7 +5182,7 @@ void
  */
 void
 /* fn */ mdns_service_did_not_resolve (
-    TransportHandle_MdnsClientPlatformEvent_t const * handle,
+    TransportHandle_MdnsPlatformEvent_t const * handle,
     char const * announce_string);
 
 /** \brief
@@ -4993,7 +5190,7 @@ void
  */
 void
 /* fn */ mdns_service_did_resolve (
-    TransportHandle_MdnsClientPlatformEvent_t const * handle,
+    TransportHandle_MdnsPlatformEvent_t const * handle,
     char const * announce_string,
     char const * hostname,
     uint16_t port);