@agntcy/slim-bindings-linux-arm64-gnu 2.0.0-alpha.4 → 2.0.0-alpha.5

package/slim_bindings.d.ts

@@ -1,10 +1,10 @@
 import { type UniffiByteArray, type UniffiGcObject, type UniffiHandle, FfiConverterObject, RustBuffer, UniffiAbstractObject, destructorGuardSymbol, pointerLiteralSymbol, uniffiTypeNameSymbol } from "@ubjs/core";
 /**
- * Create a new Service with builder pattern
+ * Create a new Service with builder pattern (native only)
  */
 export declare function createService(name: string): ServiceLike;
 /**
- * Create a new Service with configuration
+ * Create a new Service with configuration (native only)
  */
 export declare function createServiceWithConfig(name: string, config: ServiceConfig): ServiceLike;
 /**
@@ -109,7 +109,7 @@ export declare function isInitialized(): boolean;
  */
 export declare function newConfigFromJson(json: string): ClientConfig;
 /**
- * Create a new DataplaneConfig
+ * Create a new DataplaneConfig (native only)
  */
 export declare function newDataplaneConfig(): DataplaneConfig;
 /**
@@ -147,9 +147,9 @@ export declare function newServiceConfig(): ServiceConfig;
 /**
  * Create a new BindingsServiceConfig with custom values
  */
-export declare function newServiceConfigWith(nodeId: string | undefined, groupName: string | undefined, dataplane: DataplaneConfig): ServiceConfig;
+export declare function newServiceConfigWith(nodeId: string | undefined, domainName: string | undefined, dataplane: DataplaneConfig): ServiceConfig;
 /**
- * Create a new ServiceConfiguration
+ * Create a new ServiceConfiguration (native only)
  */
 export declare function newServiceConfiguration(): ServiceConfig;
 /**
@@ -1761,7 +1761,7 @@ export declare const ServerConfig: Readonly<{
     defaults: () => Partial<ServerConfig>;
 }>;
 /**
- * DataPlane configuration wrapper for uniffi bindings
+ * DataPlane configuration wrapper for uniffi bindings (native only — wraps gRPC config)
  */
 export type DataplaneConfig = {
     /**
@@ -1880,15 +1880,73 @@ export type MlsSettings = {
      * 0 = disable header-integrity checks; 1–100 = percent of messages to verify after decrypt.
      */
     headerIntegrityValidationPercent: number;
+    /**
+     * Maximum remembered control-message IDs used for replay protection.
+     * `None` uses the SLIM core default.
+     */
+    maxSeenControlMessageIdsSize?: bigint;
 };
 /**
  * Generated factory for {@link MlsSettings} record objects.
  */
 export declare const MlsSettings: Readonly<{
-    create: (partial: Partial<MlsSettings> & Required<Omit<MlsSettings, "headerIntegrityValidationPercent">>) => MlsSettings;
-    new: (partial: Partial<MlsSettings> & Required<Omit<MlsSettings, "headerIntegrityValidationPercent">>) => MlsSettings;
+    create: (partial: Partial<MlsSettings> & Required<Omit<MlsSettings, "headerIntegrityValidationPercent" | "maxSeenControlMessageIdsSize">>) => MlsSettings;
+    new: (partial: Partial<MlsSettings> & Required<Omit<MlsSettings, "headerIntegrityValidationPercent" | "maxSeenControlMessageIdsSize">>) => MlsSettings;
     defaults: () => Partial<MlsSettings>;
 }>;
+/**
+ * Online/offline status of a session participant
+ */
+export declare enum ParticipantStatus {
+    Online = 0,
+    Offline = 1
+}
+/**
+ * A participant in a session together with their current status
+ */
+export type ParticipantInfo = {
+    name: NameLike;
+    status: ParticipantStatus;
+};
+/**
+ * Generated factory for {@link ParticipantInfo} record objects.
+ */
+export declare const ParticipantInfo: Readonly<{
+    create: (partial: Partial<ParticipantInfo> & Required<Omit<ParticipantInfo, "name" | "status">>) => ParticipantInfo;
+    new: (partial: Partial<ParticipantInfo> & Required<Omit<ParticipantInfo, "name" | "status">>) => ParticipantInfo;
+    defaults: () => Partial<ParticipantInfo>;
+}>;
+/**
+ * Where and how a session's MLS/state is persisted at rest.
+ *
+ * Persistence is opt-in and app-level: pass this to
+ * [`Service::create_app_with_persistence`] to get a restorable app.
+ */
+export type PersistenceConfig = {
+    /**
+     * Directory holding the encrypted store (one file per identity).
+     */
+    path: string;
+    /**
+     * Passphrase protecting the store. **Set this.**
+     *
+     * When `Some`, a 256-bit AES key is derived from it and the store is
+     * genuinely confidential. When `None`, the key is instead derived from the
+     * app's **public** name: the store still detects tampering and is stable
+     * across restarts, but it offers **no confidentiality** — anyone who can
+     * read the database file and knows the app name can decrypt it. Only rely
+     * on the `None` fallback when the filesystem itself is your trust boundary.
+     */
+    passphrase?: string;
+};
+/**
+ * Generated factory for {@link PersistenceConfig} record objects.
+ */
+export declare const PersistenceConfig: Readonly<{
+    create: (partial: Partial<PersistenceConfig> & Required<Omit<PersistenceConfig, "path" | "passphrase">>) => PersistenceConfig;
+    new: (partial: Partial<PersistenceConfig> & Required<Omit<PersistenceConfig, "path" | "passphrase">>) => PersistenceConfig;
+    defaults: () => Partial<PersistenceConfig>;
+}>;
 /**
  * Received message containing context and payload
  */
@@ -1932,7 +1990,7 @@ export declare const RuntimeConfig: Readonly<{
     defaults: () => Partial<RuntimeConfig>;
 }>;
 /**
- * Service configuration wrapper for uniffi bindings
+ * Service configuration wrapper for uniffi bindings (native only — includes gRPC dataplane config)
  */
 export type ServiceConfig = {
     /**
@@ -1942,7 +2000,7 @@ export type ServiceConfig = {
     /**
      * Optional group name for the service
      */
-    groupName?: string;
+    domainName?: string;
     /**
      * DataPlane configuration (servers and clients)
      */
@@ -1952,8 +2010,8 @@ export type ServiceConfig = {
  * Generated factory for {@link ServiceConfig} record objects.
  */
 export declare const ServiceConfig: Readonly<{
-    create: (partial: Partial<ServiceConfig> & Required<Omit<ServiceConfig, "nodeId" | "groupName" | "dataplane">>) => ServiceConfig;
-    new: (partial: Partial<ServiceConfig> & Required<Omit<ServiceConfig, "nodeId" | "groupName" | "dataplane">>) => ServiceConfig;
+    create: (partial: Partial<ServiceConfig> & Required<Omit<ServiceConfig, "nodeId" | "domainName" | "dataplane">>) => ServiceConfig;
+    new: (partial: Partial<ServiceConfig> & Required<Omit<ServiceConfig, "nodeId" | "domainName" | "dataplane">>) => ServiceConfig;
     defaults: () => Partial<ServiceConfig>;
 }>;
 /**
@@ -2978,6 +3036,22 @@ export declare class CompletionHandle extends UniffiAbstractObject implements Co
     uniffiDestroy(): void;
     static instanceOf(obj_: any): obj_ is CompletionHandle;
 }
+/**
+ * How a session should be closed.
+ */
+export declare enum CloseMode {
+    /**
+     * Soft close: go offline so the session can be brought back later with
+     * `rejoin()`. This is an in-memory group operation and does not require
+     * persistence (though a persisted session also survives a process restart).
+     * Not valid for point-to-point sessions.
+     */
+    Soft = 0,
+    /**
+     * Hard close: terminate the session permanently.
+     */
+    Hard = 1
+}
 /**
  * Session context for language bindings (UniFFI-compatible)
  *
@@ -2985,6 +3059,54 @@ export declare class CompletionHandle extends UniffiAbstractObject implements Co
  * Provides both synchronous (blocking) and asynchronous methods for FFI compatibility.
  */
 export interface SessionLike {
+    /**
+     * Hard-close the session (blocking version): terminate it permanently.
+     * For a soft, restorable close use [`Self::close_with_mode`].
+     */
+    close(): CompletionHandleLike;
+    /**
+     * Hard-close the session and wait for completion (blocking version). See [`Self::close`].
+     */
+    closeAndWait(): void;
+    /**
+     * Hard-close the session and wait for completion (async version). See [`Self::close`].
+     */
+    closeAndWaitAsync(asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<void>;
+    /**
+     * Hard-close the session (async version). See [`Self::close`].
+     */
+    closeAsync(asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<CompletionHandleLike>;
+    /**
+     * Close the session with an explicit [`CloseMode`] (blocking version).
+     *
+     * [`CloseMode::Soft`] notifies the group that this participant is going
+     * offline so it can be brought back with `rejoin()` (an in-memory group
+     * operation; persistence is not required). Only valid for Group sessions;
+     * returns an error for PointToPoint sessions. [`CloseMode::Hard`] terminates
+     * the session permanently. Returns a completion handle that resolves when
+     * ACKs are collected or on timeout.
+     */
+    closeWithMode(mode: CloseMode): CompletionHandleLike;
+    /**
+     * Close the session with an explicit [`CloseMode`] and wait for completion (blocking version).
+     */
+    closeWithModeAndWait(mode: CloseMode): void;
+    /**
+     * Close the session with an explicit [`CloseMode`] and wait for completion (async version).
+     */
+    closeWithModeAndWaitAsync(mode: CloseMode, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<void>;
+    /**
+     * Close the session with an explicit [`CloseMode`] (async version). See [`Self::close_with_mode`].
+     */
+    closeWithModeAsync(mode: CloseMode, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<CompletionHandleLike>;
     /**
      * Get the session configuration
      */
@@ -3047,15 +3169,15 @@ export interface SessionLike {
      */
     metadata(): Map<string, string>;
     /**
-     * Get list of participants in the session (blocking version for FFI)
+     * Get list of participants in the session with their online/offline status (blocking version for FFI)
      */
-    participantsList(): Array<NameLike>;
+    participantsList(): Array<ParticipantInfo>;
     /**
-     * Get list of participants in the session
+     * Get list of participants in the session with their online/offline status (async version)
      */
     participantsListAsync(asyncOpts_?: {
         signal: AbortSignal;
-    }): Promise<Array<NameLike>>;
+    }): Promise<Array<ParticipantInfo>>;
     /**
      * Publish a message to the session's destination (blocking version)
      *
@@ -3162,6 +3284,30 @@ export interface SessionLike {
     publishWithParamsAsync(destination: NameLike, fanout: number, data: ArrayBuffer, connectionOut: bigint | undefined, payloadType: string | undefined, metadata: Map<string, string> | undefined, asyncOpts_?: {
         signal: AbortSignal;
     }): Promise<void>;
+    /**
+     * Notify the group that this participant is back online (blocking version).
+     *
+     * Only valid for Group sessions; returns an error for PointToPoint sessions.
+     * Returns a completion handle that resolves when ACKs/NACKs are collected.
+     * If any participant NACKs due to an MLS epoch mismatch, the rejoin fails.
+     */
+    rejoin(): CompletionHandleLike;
+    /**
+     * Notify the group that this participant is back online and wait for completion (blocking version).
+     */
+    rejoinAndWait(): void;
+    /**
+     * Notify the group that this participant is back online and wait for completion (async version).
+     */
+    rejoinAndWaitAsync(asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<void>;
+    /**
+     * Notify the group that this participant is back online (async version).
+     */
+    rejoinAsync(asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<CompletionHandleLike>;
     /**
      * Remove a participant from the session (blocking version)
      *
@@ -3218,6 +3364,54 @@ export declare class Session extends UniffiAbstractObject implements SessionLike
     readonly [destructorGuardSymbol]: UniffiGcObject;
     readonly [pointerLiteralSymbol]: UniffiHandle;
     private constructor();
+    /**
+     * Hard-close the session (blocking version): terminate it permanently.
+     * For a soft, restorable close use [`Self::close_with_mode`].
+     */
+    close(): CompletionHandleLike;
+    /**
+     * Hard-close the session and wait for completion (blocking version). See [`Self::close`].
+     */
+    closeAndWait(): void;
+    /**
+     * Hard-close the session and wait for completion (async version). See [`Self::close`].
+     */
+    closeAndWaitAsync(asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<void>;
+    /**
+     * Hard-close the session (async version). See [`Self::close`].
+     */
+    closeAsync(asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<CompletionHandleLike>;
+    /**
+     * Close the session with an explicit [`CloseMode`] (blocking version).
+     *
+     * [`CloseMode::Soft`] notifies the group that this participant is going
+     * offline so it can be brought back with `rejoin()` (an in-memory group
+     * operation; persistence is not required). Only valid for Group sessions;
+     * returns an error for PointToPoint sessions. [`CloseMode::Hard`] terminates
+     * the session permanently. Returns a completion handle that resolves when
+     * ACKs are collected or on timeout.
+     */
+    closeWithMode(mode: CloseMode): CompletionHandleLike;
+    /**
+     * Close the session with an explicit [`CloseMode`] and wait for completion (blocking version).
+     */
+    closeWithModeAndWait(mode: CloseMode): void;
+    /**
+     * Close the session with an explicit [`CloseMode`] and wait for completion (async version).
+     */
+    closeWithModeAndWaitAsync(mode: CloseMode, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<void>;
+    /**
+     * Close the session with an explicit [`CloseMode`] (async version). See [`Self::close_with_mode`].
+     */
+    closeWithModeAsync(mode: CloseMode, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<CompletionHandleLike>;
     /**
      * Get the session configuration
      */
@@ -3280,15 +3474,15 @@ export declare class Session extends UniffiAbstractObject implements SessionLike
      */
     metadata(): Map<string, string>;
     /**
-     * Get list of participants in the session (blocking version for FFI)
+     * Get list of participants in the session with their online/offline status (blocking version for FFI)
      */
-    participantsList(): Array<NameLike>;
+    participantsList(): Array<ParticipantInfo>;
     /**
-     * Get list of participants in the session
+     * Get list of participants in the session with their online/offline status (async version)
      */
     participantsListAsync(asyncOpts_?: {
         signal: AbortSignal;
-    }): Promise<Array<NameLike>>;
+    }): Promise<Array<ParticipantInfo>>;
     /**
      * Publish a message to the session's destination (blocking version)
      *
@@ -3395,6 +3589,30 @@ export declare class Session extends UniffiAbstractObject implements SessionLike
     publishWithParamsAsync(destination: NameLike, fanout: number, data: ArrayBuffer, connectionOut: bigint | undefined, payloadType: string | undefined, metadata: Map<string, string> | undefined, asyncOpts_?: {
         signal: AbortSignal;
     }): Promise<void>;
+    /**
+     * Notify the group that this participant is back online (blocking version).
+     *
+     * Only valid for Group sessions; returns an error for PointToPoint sessions.
+     * Returns a completion handle that resolves when ACKs/NACKs are collected.
+     * If any participant NACKs due to an MLS epoch mismatch, the rejoin fails.
+     */
+    rejoin(): CompletionHandleLike;
+    /**
+     * Notify the group that this participant is back online and wait for completion (blocking version).
+     */
+    rejoinAndWait(): void;
+    /**
+     * Notify the group that this participant is back online and wait for completion (async version).
+     */
+    rejoinAndWaitAsync(asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<void>;
+    /**
+     * Notify the group that this participant is back online (async version).
+     */
+    rejoinAsync(asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<CompletionHandleLike>;
     /**
      * Remove a participant from the session (blocking version)
      *
@@ -3878,12 +4096,16 @@ export declare enum TransportProtocol {
     Websocket = 1
 }
 /**
- * Adapter that bridges the App API with language-bindings interface
+ * Adapter that bridges the App API with the language-bindings interface.
+ *
+ * Both native and browser builds wrap the same [`slim_service::app::App`] with
+ * the same `AuthProvider`/`AuthVerifier` type parameters; the only structural
+ * difference is the lifecycle owner:
  *
- * This adapter uses enum-based auth types (`AuthProvider`/`AuthVerifier`) instead of generics
- * to be compatible with UniFFI, supporting multiple authentication mechanisms (SharedSecret,
- * JWT, SPIRE, StaticToken). It provides both synchronous (blocking) and asynchronous methods
- * for flexibility.
+ * - Native keeps the owning [`slim_service::Service`] alive.
+ * - Browser (wasm32) uses `AuthProvider::SharedSecret` identity and keeps the
+ * WebSocket [`slim_datapath::message_processing::MessageProcessor`] alive
+ * together with the upstream connection id.
  */
 export interface AppLike {
     /**
@@ -3976,6 +4198,23 @@ export interface AppLike {
     removeRouteAsync(name: NameLike, connectionId: bigint, asyncOpts_?: {
         signal: AbortSignal;
     }): Promise<void>;
+    /**
+     * Blocking wrapper around [`App::restore_sessions_async`].
+     */
+    restoreSessions(connId: bigint): Array<SessionLike>;
+    /**
+     * Restore the app's persisted sessions after a restart (async).
+     *
+     * Only meaningful for an app created with
+     * [`crate::service::Service::create_app_with_persistence`]; returns an
+     * empty list when persistence is disabled. `conn_id` must be the live
+     * upstream connection to the node (the one the app subscribes over).
+     * Each restored session rejoins its MLS group without repeating the
+     * invite/welcome handshake.
+     */
+    restoreSessionsAsync(connId: bigint, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<Array<SessionLike>>;
     /**
      * Set a route to a name for a specific connection (blocking version for FFI)
      */
@@ -4012,12 +4251,16 @@ export interface AppLike {
  */
 export type AppInterface = AppLike;
 /**
- * Adapter that bridges the App API with language-bindings interface
+ * Adapter that bridges the App API with the language-bindings interface.
  *
- * This adapter uses enum-based auth types (`AuthProvider`/`AuthVerifier`) instead of generics
- * to be compatible with UniFFI, supporting multiple authentication mechanisms (SharedSecret,
- * JWT, SPIRE, StaticToken). It provides both synchronous (blocking) and asynchronous methods
- * for flexibility.
+ * Both native and browser builds wrap the same [`slim_service::app::App`] with
+ * the same `AuthProvider`/`AuthVerifier` type parameters; the only structural
+ * difference is the lifecycle owner:
+ *
+ * - Native keeps the owning [`slim_service::Service`] alive.
+ * - Browser (wasm32) uses `AuthProvider::SharedSecret` identity and keeps the
+ * WebSocket [`slim_datapath::message_processing::MessageProcessor`] alive
+ * together with the upstream connection id.
  */
 export declare class App extends UniffiAbstractObject implements AppLike {
     readonly [uniffiTypeNameSymbol] = "App";
@@ -4164,6 +4407,23 @@ export declare class App extends UniffiAbstractObject implements AppLike {
     removeRouteAsync(name: NameLike, connectionId: bigint, asyncOpts_?: {
         signal: AbortSignal;
     }): Promise<void>;
+    /**
+     * Blocking wrapper around [`App::restore_sessions_async`].
+     */
+    restoreSessions(connId: bigint): Array<SessionLike>;
+    /**
+     * Restore the app's persisted sessions after a restart (async).
+     *
+     * Only meaningful for an app created with
+     * [`crate::service::Service::create_app_with_persistence`]; returns an
+     * empty list when persistence is disabled. `conn_id` must be the live
+     * upstream connection to the node (the one the app subscribes over).
+     * Each restored session rejoins its MLS group without repeating the
+     * invite/welcome handshake.
+     */
+    restoreSessionsAsync(connId: bigint, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<Array<SessionLike>>;
     /**
      * Set a route to a name for a specific connection (blocking version for FFI)
      */
@@ -4287,6 +4547,21 @@ export interface ServiceLike {
     createAppWithDirectionAsync(name: NameLike, identityProviderConfig: IdentityProviderConfig, identityVerifierConfig: IdentityVerifierConfig, direction: Direction, asyncOpts_?: {
         signal: AbortSignal;
     }): Promise<AppLike>;
+    /**
+     * Blocking wrapper around [`Service::create_app_with_persistence_async`].
+     */
+    createAppWithPersistence(name: NameLike, identityProviderConfig: IdentityProviderConfig, identityVerifierConfig: IdentityVerifierConfig, direction: Direction, persistence: PersistenceConfig): AppLike;
+    /**
+     * Create an app with restorable MLS/session state persisted under
+     * `persistence.path` (async).
+     *
+     * Mirror of [`Service::create_app_with_direction_async`] with persistence
+     * enabled. Restore the app's sessions after a restart with
+     * [`App::restore_sessions`].
+     */
+    createAppWithPersistenceAsync(name: NameLike, identityProviderConfig: IdentityProviderConfig, identityVerifierConfig: IdentityVerifierConfig, direction: Direction, persistence: PersistenceConfig, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<AppLike>;
     /**
      * Create a new App with SharedSecret authentication (helper function)
      *
@@ -4471,6 +4746,21 @@ export declare class Service extends UniffiAbstractObject implements ServiceLike
     createAppWithDirectionAsync(name: NameLike, identityProviderConfig: IdentityProviderConfig, identityVerifierConfig: IdentityVerifierConfig, direction: Direction, asyncOpts_?: {
         signal: AbortSignal;
     }): Promise<AppLike>;
+    /**
+     * Blocking wrapper around [`Service::create_app_with_persistence_async`].
+     */
+    createAppWithPersistence(name: NameLike, identityProviderConfig: IdentityProviderConfig, identityVerifierConfig: IdentityVerifierConfig, direction: Direction, persistence: PersistenceConfig): AppLike;
+    /**
+     * Create an app with restorable MLS/session state persisted under
+     * `persistence.path` (async).
+     *
+     * Mirror of [`Service::create_app_with_direction_async`] with persistence
+     * enabled. Restore the app's sessions after a restart with
+     * [`App::restore_sessions`].
+     */
+    createAppWithPersistenceAsync(name: NameLike, identityProviderConfig: IdentityProviderConfig, identityVerifierConfig: IdentityVerifierConfig, direction: Direction, persistence: PersistenceConfig, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<AppLike>;
     /**
      * Create a new App with SharedSecret authentication (helper function)
      *
@@ -4616,6 +4906,13 @@ declare const _default: Readonly<{
             lift(value: UniffiByteArray): ClientJwtAuth;
             lower(value: ClientJwtAuth, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
         };
+        FfiConverterTypeCloseMode: {
+            read(from: RustBuffer): CloseMode;
+            write(value: CloseMode, into: RustBuffer): void;
+            allocationSize(value: CloseMode): number;
+            lift(value: UniffiByteArray): CloseMode;
+            lower(value: CloseMode, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
         FfiConverterTypeCompletionHandle: FfiConverterObject<CompletionHandleLike>;
         FfiConverterTypeCompressionType: {
             read(from: RustBuffer): CompressionType;
@@ -4737,6 +5034,27 @@ declare const _default: Readonly<{
             lower(value: MlsSettings, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
         };
         FfiConverterTypeName: FfiConverterObject<NameLike>;
+        FfiConverterTypeParticipantInfo: {
+            read(from: RustBuffer): ParticipantInfo;
+            write(value: ParticipantInfo, into: RustBuffer): void;
+            allocationSize(value: ParticipantInfo): number;
+            lift(value: UniffiByteArray): ParticipantInfo;
+            lower(value: ParticipantInfo, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeParticipantStatus: {
+            read(from: RustBuffer): ParticipantStatus;
+            write(value: ParticipantStatus, into: RustBuffer): void;
+            allocationSize(value: ParticipantStatus): number;
+            lift(value: UniffiByteArray): ParticipantStatus;
+            lower(value: ParticipantStatus, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypePersistenceConfig: {
+            read(from: RustBuffer): PersistenceConfig;
+            write(value: PersistenceConfig, into: RustBuffer): void;
+            allocationSize(value: PersistenceConfig): number;
+            lift(value: UniffiByteArray): PersistenceConfig;
+            lower(value: PersistenceConfig, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
         FfiConverterTypeProxyConfig: {
             read(from: RustBuffer): ProxyConfig;
             write(value: ProxyConfig, into: RustBuffer): void;