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

package/slim_bindings.d.ts

@@ -1,10 +1,10 @@
-import { type UniffiByteArray, type UniffiGcObject, type UniffiHandle, FfiConverterObject, FfiConverterObjectWithCallbacks, RustBuffer, UniffiAbstractObject, destructorGuardSymbol, pointerLiteralSymbol, uniffiTypeNameSymbol } from "@ubjs/core";
+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;
 /**
@@ -1422,8 +1422,8 @@ export type ClientConfig = {
  * Generated factory for {@link ClientConfig} record objects.
  */
 export declare const ClientConfig: Readonly<{
-    create: (partial: Partial<ClientConfig> & Required<Omit<ClientConfig, "origin" | "tls" | "headers" | "endpoint" | "serverName" | "compression" | "rateLimit" | "keepalive" | "proxy" | "connectTimeout" | "requestTimeout" | "bufferSize" | "auth" | "backoff" | "metadata" | "requireHeaderMac">>) => ClientConfig;
-    new: (partial: Partial<ClientConfig> & Required<Omit<ClientConfig, "origin" | "tls" | "headers" | "endpoint" | "serverName" | "compression" | "rateLimit" | "keepalive" | "proxy" | "connectTimeout" | "requestTimeout" | "bufferSize" | "auth" | "backoff" | "metadata" | "requireHeaderMac">>) => ClientConfig;
+    create: (partial: Partial<ClientConfig> & Required<Omit<ClientConfig, "tls" | "headers" | "endpoint" | "origin" | "serverName" | "compression" | "rateLimit" | "keepalive" | "proxy" | "connectTimeout" | "requestTimeout" | "bufferSize" | "auth" | "backoff" | "metadata" | "requireHeaderMac">>) => ClientConfig;
+    new: (partial: Partial<ClientConfig> & Required<Omit<ClientConfig, "tls" | "headers" | "endpoint" | "origin" | "serverName" | "compression" | "rateLimit" | "keepalive" | "proxy" | "connectTimeout" | "requestTimeout" | "bufferSize" | "auth" | "backoff" | "metadata" | "requireHeaderMac">>) => ClientConfig;
     defaults: () => Partial<ClientConfig>;
 }>;
 /**
@@ -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,69 +1880,87 @@ 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>;
 }>;
 /**
- * Received message containing context and payload
+ * Online/offline status of a session participant
  */
-export type ReceivedMessage = {
-    context: MessageContext;
-    payload: ArrayBuffer;
+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 ReceivedMessage} record objects.
+ * Generated factory for {@link ParticipantInfo} record objects.
  */
-export declare const ReceivedMessage: Readonly<{
-    create: (partial: Partial<ReceivedMessage> & Required<Omit<ReceivedMessage, "context" | "payload">>) => ReceivedMessage;
-    new: (partial: Partial<ReceivedMessage> & Required<Omit<ReceivedMessage, "context" | "payload">>) => ReceivedMessage;
-    defaults: () => Partial<ReceivedMessage>;
+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>;
 }>;
 /**
- * Per-message context for a multicast RPC response — identifies which group
- * member sent the response.
+ * 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 RpcMessageContext = {
+export type PersistenceConfig = {
+    /**
+     * Directory holding the encrypted store (one file per identity).
+     */
+    path: string;
     /**
-     * The SLIM name of the group member that sent this response.
+     * 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.
      */
-    source: NameLike;
+    passphrase?: string;
 };
 /**
- * Generated factory for {@link RpcMessageContext} record objects.
+ * Generated factory for {@link PersistenceConfig} record objects.
  */
-export declare const RpcMessageContext: Readonly<{
-    create: (partial: Partial<RpcMessageContext> & Required<Omit<RpcMessageContext, "source">>) => RpcMessageContext;
-    new: (partial: Partial<RpcMessageContext> & Required<Omit<RpcMessageContext, "source">>) => RpcMessageContext;
-    defaults: () => Partial<RpcMessageContext>;
+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>;
 }>;
 /**
- * A single item in a multicast response stream, pairing the response payload
- * with the identity of the member that produced it.
+ * Received message containing context and payload
  */
-export type RpcMulticastItem = {
-    /**
-     * Context identifying the source member.
-     */
-    context: RpcMessageContext;
-    /**
-     * The encoded response payload (raw bytes).
-     */
-    message: ArrayBuffer;
+export type ReceivedMessage = {
+    context: MessageContext;
+    payload: ArrayBuffer;
 };
 /**
- * Generated factory for {@link RpcMulticastItem} record objects.
+ * Generated factory for {@link ReceivedMessage} record objects.
  */
-export declare const RpcMulticastItem: Readonly<{
-    create: (partial: Partial<RpcMulticastItem> & Required<Omit<RpcMulticastItem, "message" | "context">>) => RpcMulticastItem;
-    new: (partial: Partial<RpcMulticastItem> & Required<Omit<RpcMulticastItem, "message" | "context">>) => RpcMulticastItem;
-    defaults: () => Partial<RpcMulticastItem>;
+export declare const ReceivedMessage: Readonly<{
+    create: (partial: Partial<ReceivedMessage> & Required<Omit<ReceivedMessage, "context" | "payload">>) => ReceivedMessage;
+    new: (partial: Partial<ReceivedMessage> & Required<Omit<ReceivedMessage, "context" | "payload">>) => ReceivedMessage;
+    defaults: () => Partial<ReceivedMessage>;
 }>;
 /**
  * Runtime configuration for the SLIM bindings
@@ -1972,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 = {
     /**
@@ -1982,7 +2000,7 @@ export type ServiceConfig = {
     /**
      * Optional group name for the service
      */
-    groupName?: string;
+    domainName?: string;
     /**
      * DataPlane configuration (servers and clients)
      */
@@ -1992,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>;
 }>;
 /**
@@ -3018,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)
  *
@@ -3025,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
      */
@@ -3087,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)
      *
@@ -3202,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)
      *
@@ -3258,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
      */
@@ -3320,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)
      *
@@ -3435,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)
      *
@@ -3911,2249 +4089,373 @@ export declare const IdentityVerifierConfig: Readonly<{
  */
 export type IdentityVerifierConfig = InstanceType<typeof IdentityVerifierConfig['SharedSecret' | 'Jwt' | 'Spire' | 'None']>;
 /**
- * gRPC status codes
+ * Transport protocol for dataplane communication.
+ */
+export declare enum TransportProtocol {
+    Grpc = 0,
+    Websocket = 1
+}
+/**
+ * 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:
+ *
+ * - 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 enum RpcCode {
+export interface AppLike {
+    /**
+     * Create a new session (blocking version for FFI)
+     *
+     * Returns a SessionWithCompletion containing the session context and a completion handle.
+     * Call `.wait()` on the completion handle to wait for session establishment.
+     */
+    createSession(config: SessionConfig, destination: NameLike): SessionWithCompletion;
+    /**
+     * Create a new session and wait for completion (blocking version)
+     *
+     * This method creates a session and blocks until the session establishment completes.
+     * Returns only the session context, as the completion has already been awaited.
+     */
+    createSessionAndWait(config: SessionConfig, destination: NameLike): SessionLike;
+    /**
+     * Create a new session and wait for completion (async version)
+     *
+     * This method creates a session and waits until the session establishment completes.
+     * Returns only the session context, as the completion has already been awaited.
+     */
+    createSessionAndWaitAsync(config: SessionConfig, destination: NameLike, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<SessionLike>;
+    /**
+     * Create a new session (async version)
+     *
+     * Returns a SessionWithCompletion containing the session context and a completion handle.
+     * Await the completion handle to wait for session establishment.
+     * For point-to-point sessions, this ensures the remote peer has acknowledged the session.
+     * For multicast sessions, this ensures the initial setup is complete.
+     */
+    createSessionAsync(config: SessionConfig, destination: NameLike, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<SessionWithCompletion>;
     /**
-     * Success
+     * Delete a session (blocking version for FFI)
+     *
+     * Returns a completion handle that can be awaited to ensure the deletion completes.
+     */
+    deleteSession(session: SessionLike): CompletionHandleLike;
+    /**
+     * Delete a session and wait for completion (blocking version)
+     *
+     * This method deletes a session and blocks until the deletion completes.
      */
-    Ok = 0,
+    deleteSessionAndWait(session: SessionLike): void;
     /**
-     * The operation was cancelled
+     * Delete a session and wait for completion (async version)
+     *
+     * This method deletes a session and waits until the deletion completes.
      */
-    Cancelled = 1,
+    deleteSessionAndWaitAsync(session: SessionLike, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<void>;
     /**
-     * Unknown error
+     * Delete a session (async version)
+     *
+     * Returns a completion handle that can be awaited to ensure the deletion completes.
      */
-    Unknown = 2,
+    deleteSessionAsync(session: SessionLike, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<CompletionHandleLike>;
     /**
-     * Client specified an invalid argument
+     * Get the app ID in UUID format
      */
-    InvalidArgument = 3,
+    id(): string;
     /**
-     * Deadline exceeded before operation could complete
+     * Listen for incoming sessions (blocking version for FFI)
      */
-    DeadlineExceeded = 4,
+    listenForSession(timeout: number | undefined): SessionLike;
     /**
-     * Some requested entity was not found
+     * Listen for incoming sessions (async version)
      */
-    NotFound = 5,
+    listenForSessionAsync(timeout: number | undefined, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<SessionLike>;
     /**
-     * Some entity that we attempted to create already exists
+     * Get the app name
      */
-    AlreadyExists = 6,
+    name(): NameLike;
     /**
-     * The caller does not have permission to execute the specified operation
+     * Remove a route (blocking version for FFI)
      */
-    PermissionDenied = 7,
+    removeRoute(name: NameLike, connectionId: bigint): void;
     /**
-     * Some resource has been exhausted
+     * Remove a route (async version)
      */
-    ResourceExhausted = 8,
+    removeRouteAsync(name: NameLike, connectionId: bigint, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<void>;
     /**
-     * The system is not in a state required for the operation's execution
+     * Blocking wrapper around [`App::restore_sessions_async`].
      */
-    FailedPrecondition = 9,
+    restoreSessions(connId: bigint): Array<SessionLike>;
     /**
-     * The operation was aborted
+     * 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.
      */
-    Aborted = 10,
+    restoreSessionsAsync(connId: bigint, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<Array<SessionLike>>;
     /**
-     * Operation was attempted past the valid range
+     * Set a route to a name for a specific connection (blocking version for FFI)
      */
-    OutOfRange = 11,
+    setRoute(name: NameLike, connectionId: bigint): void;
     /**
-     * Operation is not implemented or not supported
+     * Set a route to a name for a specific connection (async version)
      */
-    Unimplemented = 12,
+    setRouteAsync(name: NameLike, connectionId: bigint, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<void>;
     /**
-     * Internal errors
+     * Subscribe to a session name (blocking version for FFI)
      */
-    Internal = 13,
+    subscribe(name: NameLike, connectionId: bigint | undefined): void;
     /**
-     * The service is currently unavailable
+     * Subscribe to a name (async version)
      */
-    Unavailable = 14,
+    subscribeAsync(name: NameLike, connectionId: bigint | undefined, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<void>;
     /**
-     * Unrecoverable data loss or corruption
+     * Unsubscribe from a name (blocking version for FFI)
      */
-    DataLoss = 15,
+    unsubscribe(name: NameLike, connectionId: bigint | undefined): void;
     /**
-     * The request does not have valid authentication credentials
+     * Unsubscribe from a name (async version)
      */
-    Unauthenticated = 16
-}
-export declare enum RpcError_Tags {
-    Rpc = "Rpc",
-    MulticastRpc = "MulticastRpc",
-    MulticastSessionClosed = "MulticastSessionClosed"
+    unsubscribeAsync(name: NameLike, connectionId: bigint | undefined, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<void>;
 }
 /**
- * UniFFI-compatible RPC error
+ * @deprecated Use `AppLike` instead.
+ */
+export type AppInterface = AppLike;
+/**
+ * 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 represents RPC errors with gRPC-compatible status codes.
+ * - 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 const RpcError: Readonly<{
-    instanceOf: (obj: any) => obj is RpcError;
-    Rpc: {
-        new (inner: {
-            code: RpcCode;
-            message: string;
-            details?: ArrayBuffer;
-        }): {
-            readonly tag: RpcError_Tags.Rpc;
-            readonly inner: Readonly<{
-                code: RpcCode;
-                message: string;
-                details?: ArrayBuffer;
-            }>;
-            /**
-             * @private
-             * This field is private and should not be used, use `tag` instead.
-             */
-            readonly [uniffiTypeNameSymbol]: "RpcError";
-            name: string;
-            message: string;
-            stack?: string;
-        };
-        "new"(inner: {
-            code: RpcCode;
-            message: string;
-            details?: ArrayBuffer;
-        }): {
-            readonly tag: RpcError_Tags.Rpc;
-            readonly inner: Readonly<{
-                code: RpcCode;
-                message: string;
-                details?: ArrayBuffer;
-            }>;
-            /**
-             * @private
-             * This field is private and should not be used, use `tag` instead.
-             */
-            readonly [uniffiTypeNameSymbol]: "RpcError";
-            name: string;
-            message: string;
-            stack?: string;
-        };
-        instanceOf(obj: any): obj is {
-            readonly tag: RpcError_Tags.Rpc;
-            readonly inner: Readonly<{
-                code: RpcCode;
-                message: string;
-                details?: ArrayBuffer;
-            }>;
-            /**
-             * @private
-             * This field is private and should not be used, use `tag` instead.
-             */
-            readonly [uniffiTypeNameSymbol]: "RpcError";
-            name: string;
-            message: string;
-            stack?: string;
-        };
-        hasInner(obj: any): obj is {
-            readonly tag: RpcError_Tags.Rpc;
-            readonly inner: Readonly<{
-                code: RpcCode;
-                message: string;
-                details?: ArrayBuffer;
-            }>;
-            /**
-             * @private
-             * This field is private and should not be used, use `tag` instead.
-             */
-            readonly [uniffiTypeNameSymbol]: "RpcError";
-            name: string;
-            message: string;
-            stack?: string;
-        };
-        getInner(obj: {
-            readonly tag: RpcError_Tags.Rpc;
-            readonly inner: Readonly<{
-                code: RpcCode;
-                message: string;
-                details?: ArrayBuffer;
-            }>;
-            /**
-             * @private
-             * This field is private and should not be used, use `tag` instead.
-             */
-            readonly [uniffiTypeNameSymbol]: "RpcError";
-            name: string;
-            message: string;
-            stack?: string;
-        }): Readonly<{
-            code: RpcCode;
-            message: string;
-            details?: ArrayBuffer;
-        }>;
-        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
-        stackTraceLimit: number;
-    };
-    MulticastRpc: {
-        new (inner: {
-            origin: string;
-            code: RpcCode;
-            message: string;
-            details?: ArrayBuffer;
-        }): {
-            readonly tag: RpcError_Tags.MulticastRpc;
-            readonly inner: Readonly<{
-                origin: string;
-                code: RpcCode;
-                message: string;
-                details?: ArrayBuffer;
-            }>;
-            /**
-             * @private
-             * This field is private and should not be used, use `tag` instead.
-             */
-            readonly [uniffiTypeNameSymbol]: "RpcError";
-            name: string;
-            message: string;
-            stack?: string;
-        };
-        "new"(inner: {
-            origin: string;
-            code: RpcCode;
-            message: string;
-            details?: ArrayBuffer;
-        }): {
-            readonly tag: RpcError_Tags.MulticastRpc;
-            readonly inner: Readonly<{
-                origin: string;
-                code: RpcCode;
-                message: string;
-                details?: ArrayBuffer;
-            }>;
-            /**
-             * @private
-             * This field is private and should not be used, use `tag` instead.
-             */
-            readonly [uniffiTypeNameSymbol]: "RpcError";
-            name: string;
-            message: string;
-            stack?: string;
-        };
-        instanceOf(obj: any): obj is {
-            readonly tag: RpcError_Tags.MulticastRpc;
-            readonly inner: Readonly<{
-                origin: string;
-                code: RpcCode;
-                message: string;
-                details?: ArrayBuffer;
-            }>;
-            /**
-             * @private
-             * This field is private and should not be used, use `tag` instead.
-             */
-            readonly [uniffiTypeNameSymbol]: "RpcError";
-            name: string;
-            message: string;
-            stack?: string;
-        };
-        hasInner(obj: any): obj is {
-            readonly tag: RpcError_Tags.MulticastRpc;
-            readonly inner: Readonly<{
-                origin: string;
-                code: RpcCode;
-                message: string;
-                details?: ArrayBuffer;
-            }>;
-            /**
-             * @private
-             * This field is private and should not be used, use `tag` instead.
-             */
-            readonly [uniffiTypeNameSymbol]: "RpcError";
-            name: string;
-            message: string;
-            stack?: string;
-        };
-        getInner(obj: {
-            readonly tag: RpcError_Tags.MulticastRpc;
-            readonly inner: Readonly<{
-                origin: string;
-                code: RpcCode;
-                message: string;
-                details?: ArrayBuffer;
-            }>;
-            /**
-             * @private
-             * This field is private and should not be used, use `tag` instead.
-             */
-            readonly [uniffiTypeNameSymbol]: "RpcError";
-            name: string;
-            message: string;
-            stack?: string;
-        }): Readonly<{
-            origin: string;
-            code: RpcCode;
-            message: string;
-            details?: ArrayBuffer;
-        }>;
-        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
-        stackTraceLimit: number;
-    };
-    MulticastSessionClosed: {
-        new (inner: {
-            completed: bigint;
-            total: bigint;
-            received: Array<string>;
-            missing: Array<string>;
-        }): {
-            readonly tag: RpcError_Tags.MulticastSessionClosed;
-            readonly inner: Readonly<{
-                completed: bigint;
-                total: bigint;
-                received: Array<string>;
-                missing: Array<string>;
-            }>;
-            /**
-             * @private
-             * This field is private and should not be used, use `tag` instead.
-             */
-            readonly [uniffiTypeNameSymbol]: "RpcError";
-            name: string;
-            message: string;
-            stack?: string;
-        };
-        "new"(inner: {
-            completed: bigint;
-            total: bigint;
-            received: Array<string>;
-            missing: Array<string>;
-        }): {
-            readonly tag: RpcError_Tags.MulticastSessionClosed;
-            readonly inner: Readonly<{
-                completed: bigint;
-                total: bigint;
-                received: Array<string>;
-                missing: Array<string>;
-            }>;
-            /**
-             * @private
-             * This field is private and should not be used, use `tag` instead.
-             */
-            readonly [uniffiTypeNameSymbol]: "RpcError";
-            name: string;
-            message: string;
-            stack?: string;
-        };
-        instanceOf(obj: any): obj is {
-            readonly tag: RpcError_Tags.MulticastSessionClosed;
-            readonly inner: Readonly<{
-                completed: bigint;
-                total: bigint;
-                received: Array<string>;
-                missing: Array<string>;
-            }>;
-            /**
-             * @private
-             * This field is private and should not be used, use `tag` instead.
-             */
-            readonly [uniffiTypeNameSymbol]: "RpcError";
-            name: string;
-            message: string;
-            stack?: string;
-        };
-        hasInner(obj: any): obj is {
-            readonly tag: RpcError_Tags.MulticastSessionClosed;
-            readonly inner: Readonly<{
-                completed: bigint;
-                total: bigint;
-                received: Array<string>;
-                missing: Array<string>;
-            }>;
-            /**
-             * @private
-             * This field is private and should not be used, use `tag` instead.
-             */
-            readonly [uniffiTypeNameSymbol]: "RpcError";
-            name: string;
-            message: string;
-            stack?: string;
-        };
-        getInner(obj: {
-            readonly tag: RpcError_Tags.MulticastSessionClosed;
-            readonly inner: Readonly<{
-                completed: bigint;
-                total: bigint;
-                received: Array<string>;
-                missing: Array<string>;
-            }>;
-            /**
-             * @private
-             * This field is private and should not be used, use `tag` instead.
-             */
-            readonly [uniffiTypeNameSymbol]: "RpcError";
-            name: string;
-            message: string;
-            stack?: string;
-        }): Readonly<{
-            completed: bigint;
-            total: bigint;
-            received: Array<string>;
-            missing: Array<string>;
-        }>;
-        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
-        stackTraceLimit: number;
-    };
-}>;
-/**
- * UniFFI-compatible RPC error
- *
- * This represents RPC errors with gRPC-compatible status codes.
- */
-export type RpcError = InstanceType<typeof RpcError['Rpc' | 'MulticastRpc' | 'MulticastSessionClosed']>;
-export declare enum MulticastStreamMessage_Tags {
-    Data = "Data",
-    Error = "Error",
-    End = "End"
-}
-/**
- * Message from a multicast response stream.
- */
-export declare const MulticastStreamMessage: Readonly<{
-    instanceOf: (obj: any) => obj is MulticastStreamMessage;
-    Data: {
-        new (inner: {
-            item: RpcMulticastItem;
-        }): {
-            readonly tag: MulticastStreamMessage_Tags.Data;
-            readonly inner: Readonly<{
-                item: RpcMulticastItem;
-            }>;
-            /**
-             * @private
-             * This field is private and should not be used, use `tag` instead.
-             */
-            readonly [uniffiTypeNameSymbol]: "MulticastStreamMessage";
-        };
-        "new"(inner: {
-            item: RpcMulticastItem;
-        }): {
-            readonly tag: MulticastStreamMessage_Tags.Data;
-            readonly inner: Readonly<{
-                item: RpcMulticastItem;
-            }>;
-            /**
-             * @private
-             * This field is private and should not be used, use `tag` instead.
-             */
-            readonly [uniffiTypeNameSymbol]: "MulticastStreamMessage";
-        };
-        instanceOf(obj: any): obj is {
-            readonly tag: MulticastStreamMessage_Tags.Data;
-            readonly inner: Readonly<{
-                item: RpcMulticastItem;
-            }>;
-            /**
-             * @private
-             * This field is private and should not be used, use `tag` instead.
-             */
-            readonly [uniffiTypeNameSymbol]: "MulticastStreamMessage";
-        };
-    };
-    Error: {
-        new (inner: {
-            error: RpcError;
-        }): {
-            readonly tag: MulticastStreamMessage_Tags.Error;
-            readonly inner: Readonly<{
-                error: RpcError;
-            }>;
-            /**
-             * @private
-             * This field is private and should not be used, use `tag` instead.
-             */
-            readonly [uniffiTypeNameSymbol]: "MulticastStreamMessage";
-        };
-        "new"(inner: {
-            error: RpcError;
-        }): {
-            readonly tag: MulticastStreamMessage_Tags.Error;
-            readonly inner: Readonly<{
-                error: RpcError;
-            }>;
-            /**
-             * @private
-             * This field is private and should not be used, use `tag` instead.
-             */
-            readonly [uniffiTypeNameSymbol]: "MulticastStreamMessage";
-        };
-        instanceOf(obj: any): obj is {
-            readonly tag: MulticastStreamMessage_Tags.Error;
-            readonly inner: Readonly<{
-                error: RpcError;
-            }>;
-            /**
-             * @private
-             * This field is private and should not be used, use `tag` instead.
-             */
-            readonly [uniffiTypeNameSymbol]: "MulticastStreamMessage";
-        };
-    };
-    End: {
-        new (): {
-            readonly tag: MulticastStreamMessage_Tags.End;
-            /**
-             * @private
-             * This field is private and should not be used, use `tag` instead.
-             */
-            readonly [uniffiTypeNameSymbol]: "MulticastStreamMessage";
-        };
-        "new"(): {
-            readonly tag: MulticastStreamMessage_Tags.End;
-            /**
-             * @private
-             * This field is private and should not be used, use `tag` instead.
-             */
-            readonly [uniffiTypeNameSymbol]: "MulticastStreamMessage";
-        };
-        instanceOf(obj: any): obj is {
-            readonly tag: MulticastStreamMessage_Tags.End;
-            /**
-             * @private
-             * This field is private and should not be used, use `tag` instead.
-             */
-            readonly [uniffiTypeNameSymbol]: "MulticastStreamMessage";
-        };
-    };
-}>;
-/**
- * Message from a multicast response stream.
- */
-export type MulticastStreamMessage = InstanceType<typeof MulticastStreamMessage['Data' | 'Error' | 'End']>;
-export declare enum StreamMessage_Tags {
-    Data = "Data",
-    Error = "Error",
-    End = "End"
-}
-/**
- * Message from a stream
- */
-export declare const StreamMessage: Readonly<{
-    instanceOf: (obj: any) => obj is StreamMessage;
-    Data: {
-        new (v0: ArrayBuffer): {
-            readonly tag: StreamMessage_Tags.Data;
-            readonly inner: Readonly<[ArrayBuffer]>;
-            /**
-             * @private
-             * This field is private and should not be used, use `tag` instead.
-             */
-            readonly [uniffiTypeNameSymbol]: "StreamMessage";
-        };
-        "new"(v0: ArrayBuffer): {
-            readonly tag: StreamMessage_Tags.Data;
-            readonly inner: Readonly<[ArrayBuffer]>;
-            /**
-             * @private
-             * This field is private and should not be used, use `tag` instead.
-             */
-            readonly [uniffiTypeNameSymbol]: "StreamMessage";
-        };
-        instanceOf(obj: any): obj is {
-            readonly tag: StreamMessage_Tags.Data;
-            readonly inner: Readonly<[ArrayBuffer]>;
-            /**
-             * @private
-             * This field is private and should not be used, use `tag` instead.
-             */
-            readonly [uniffiTypeNameSymbol]: "StreamMessage";
-        };
-    };
-    Error: {
-        new (v0: RpcError): {
-            readonly tag: StreamMessage_Tags.Error;
-            readonly inner: Readonly<[RpcError]>;
-            /**
-             * @private
-             * This field is private and should not be used, use `tag` instead.
-             */
-            readonly [uniffiTypeNameSymbol]: "StreamMessage";
-        };
-        "new"(v0: RpcError): {
-            readonly tag: StreamMessage_Tags.Error;
-            readonly inner: Readonly<[RpcError]>;
-            /**
-             * @private
-             * This field is private and should not be used, use `tag` instead.
-             */
-            readonly [uniffiTypeNameSymbol]: "StreamMessage";
-        };
-        instanceOf(obj: any): obj is {
-            readonly tag: StreamMessage_Tags.Error;
-            readonly inner: Readonly<[RpcError]>;
-            /**
-             * @private
-             * This field is private and should not be used, use `tag` instead.
-             */
-            readonly [uniffiTypeNameSymbol]: "StreamMessage";
-        };
-    };
-    End: {
-        new (): {
-            readonly tag: StreamMessage_Tags.End;
-            /**
-             * @private
-             * This field is private and should not be used, use `tag` instead.
-             */
-            readonly [uniffiTypeNameSymbol]: "StreamMessage";
-        };
-        "new"(): {
-            readonly tag: StreamMessage_Tags.End;
-            /**
-             * @private
-             * This field is private and should not be used, use `tag` instead.
-             */
-            readonly [uniffiTypeNameSymbol]: "StreamMessage";
-        };
-        instanceOf(obj: any): obj is {
-            readonly tag: StreamMessage_Tags.End;
-            /**
-             * @private
-             * This field is private and should not be used, use `tag` instead.
-             */
-            readonly [uniffiTypeNameSymbol]: "StreamMessage";
-        };
-    };
-}>;
-/**
- * Message from a stream
- */
-export type StreamMessage = InstanceType<typeof StreamMessage['Data' | 'Error' | 'End']>;
-/**
- * Transport protocol for dataplane communication.
- */
-export declare enum TransportProtocol {
-    Grpc = 0,
-    Websocket = 1
-}
-/**
- * Adapter that bridges the App API with 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.
- */
-export interface AppLike {
-    /**
-     * Create a new session (blocking version for FFI)
-     *
-     * Returns a SessionWithCompletion containing the session context and a completion handle.
-     * Call `.wait()` on the completion handle to wait for session establishment.
-     */
-    createSession(config: SessionConfig, destination: NameLike): SessionWithCompletion;
-    /**
-     * Create a new session and wait for completion (blocking version)
-     *
-     * This method creates a session and blocks until the session establishment completes.
-     * Returns only the session context, as the completion has already been awaited.
-     */
-    createSessionAndWait(config: SessionConfig, destination: NameLike): SessionLike;
-    /**
-     * Create a new session and wait for completion (async version)
-     *
-     * This method creates a session and waits until the session establishment completes.
-     * Returns only the session context, as the completion has already been awaited.
-     */
-    createSessionAndWaitAsync(config: SessionConfig, destination: NameLike, asyncOpts_?: {
-        signal: AbortSignal;
-    }): Promise<SessionLike>;
-    /**
-     * Create a new session (async version)
-     *
-     * Returns a SessionWithCompletion containing the session context and a completion handle.
-     * Await the completion handle to wait for session establishment.
-     * For point-to-point sessions, this ensures the remote peer has acknowledged the session.
-     * For multicast sessions, this ensures the initial setup is complete.
-     */
-    createSessionAsync(config: SessionConfig, destination: NameLike, asyncOpts_?: {
-        signal: AbortSignal;
-    }): Promise<SessionWithCompletion>;
-    /**
-     * Delete a session (blocking version for FFI)
-     *
-     * Returns a completion handle that can be awaited to ensure the deletion completes.
-     */
-    deleteSession(session: SessionLike): CompletionHandleLike;
-    /**
-     * Delete a session and wait for completion (blocking version)
-     *
-     * This method deletes a session and blocks until the deletion completes.
-     */
-    deleteSessionAndWait(session: SessionLike): void;
-    /**
-     * Delete a session and wait for completion (async version)
-     *
-     * This method deletes a session and waits until the deletion completes.
-     */
-    deleteSessionAndWaitAsync(session: SessionLike, asyncOpts_?: {
-        signal: AbortSignal;
-    }): Promise<void>;
-    /**
-     * Delete a session (async version)
-     *
-     * Returns a completion handle that can be awaited to ensure the deletion completes.
-     */
-    deleteSessionAsync(session: SessionLike, asyncOpts_?: {
-        signal: AbortSignal;
-    }): Promise<CompletionHandleLike>;
-    /**
-     * Get the app ID in UUID format
-     */
-    id(): string;
-    /**
-     * Listen for incoming sessions (blocking version for FFI)
-     */
-    listenForSession(timeout: number | undefined): SessionLike;
-    /**
-     * Listen for incoming sessions (async version)
-     */
-    listenForSessionAsync(timeout: number | undefined, asyncOpts_?: {
-        signal: AbortSignal;
-    }): Promise<SessionLike>;
-    /**
-     * Get the app name
-     */
-    name(): NameLike;
-    /**
-     * Remove a route (blocking version for FFI)
-     */
-    removeRoute(name: NameLike, connectionId: bigint): void;
-    /**
-     * Remove a route (async version)
-     */
-    removeRouteAsync(name: NameLike, connectionId: bigint, asyncOpts_?: {
-        signal: AbortSignal;
-    }): Promise<void>;
-    /**
-     * Set a route to a name for a specific connection (blocking version for FFI)
-     */
-    setRoute(name: NameLike, connectionId: bigint): void;
-    /**
-     * Set a route to a name for a specific connection (async version)
-     */
-    setRouteAsync(name: NameLike, connectionId: bigint, asyncOpts_?: {
-        signal: AbortSignal;
-    }): Promise<void>;
-    /**
-     * Subscribe to a session name (blocking version for FFI)
-     */
-    subscribe(name: NameLike, connectionId: bigint | undefined): void;
-    /**
-     * Subscribe to a name (async version)
-     */
-    subscribeAsync(name: NameLike, connectionId: bigint | undefined, asyncOpts_?: {
-        signal: AbortSignal;
-    }): Promise<void>;
-    /**
-     * Unsubscribe from a name (blocking version for FFI)
-     */
-    unsubscribe(name: NameLike, connectionId: bigint | undefined): void;
-    /**
-     * Unsubscribe from a name (async version)
-     */
-    unsubscribeAsync(name: NameLike, connectionId: bigint | undefined, asyncOpts_?: {
-        signal: AbortSignal;
-    }): Promise<void>;
-}
-/**
- * @deprecated Use `AppLike` instead.
- */
-export type AppInterface = AppLike;
-/**
- * Adapter that bridges the App API with 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.
- */
-export declare class App extends UniffiAbstractObject implements AppLike {
-    readonly [uniffiTypeNameSymbol] = "App";
-    readonly [destructorGuardSymbol]: UniffiGcObject;
-    readonly [pointerLiteralSymbol]: UniffiHandle;
-    /**
-     * Create a new App with identity provider and verifier configurations
-     *
-     * This is the main entry point for creating a SLIM application from language bindings.
-     *
-     * # Arguments
-     * * `base_name` - The base name for the app (without ID)
-     * * `identity_provider_config` - Configuration for proving identity to others
-     * * `identity_verifier_config` - Configuration for verifying identity of others
-     *
-     * # Returns
-     * * `Ok(Arc<App>)` - Successfully created adapter
-     * * `Err(SlimError)` - If adapter creation fails
-     *
-     * # Supported Identity Types
-     * - SharedSecret: Symmetric key authentication
-     * - JWT: Dynamic JWT generation/verification with signing/decoding keys
-     * - StaticJWT: Static JWT loaded from file with auto-reload
-     */
-    constructor(baseName: NameLike, identityProviderConfig: IdentityProviderConfig, identityVerifierConfig: IdentityVerifierConfig);
-    /**
-     * Create a new App with traffic direction (blocking version)
-     *
-     * This is a convenience function for creating a SLIM application with configurable
-     * traffic direction (send-only, receive-only, bidirectional, or none).
-     *
-     * # Arguments
-     * * `name` - The base name for the app (without ID)
-     * * `identity_provider_config` - Configuration for proving identity to others
-     * * `identity_verifier_config` - Configuration for verifying identity of others
-     * * `direction` - Traffic direction for sessions (Send, Recv, Bidirectional, or None)
-     *
-     * # Returns
-     * * `Ok(Arc<App>)` - Successfully created app
-     * * `Err(SlimError)` - If app creation fails
-     */
-    static newWithDirection(name: NameLike, identityProviderConfig: IdentityProviderConfig, identityVerifierConfig: IdentityVerifierConfig, direction: Direction): AppLike;
-    /**
-     * Create a new App with SharedSecret authentication (blocking version)
-     *
-     * This is a convenience function for creating a SLIM application using SharedSecret authentication.
-     *
-     * # Arguments
-     * * `name` - The base name for the app (without ID)
-     * * `secret` - The shared secret string for authentication
-     *
-     * # Returns
-     * * `Ok(Arc<App>)` - Successfully created adapter
-     * * `Err(SlimError)` - If adapter creation fails
-     */
-    static newWithSecret(name: NameLike, secret: string): AppLike;
-    /**
-     * Create a new session (blocking version for FFI)
-     *
-     * Returns a SessionWithCompletion containing the session context and a completion handle.
-     * Call `.wait()` on the completion handle to wait for session establishment.
-     */
-    createSession(config: SessionConfig, destination: NameLike): SessionWithCompletion;
-    /**
-     * Create a new session and wait for completion (blocking version)
-     *
-     * This method creates a session and blocks until the session establishment completes.
-     * Returns only the session context, as the completion has already been awaited.
-     */
-    createSessionAndWait(config: SessionConfig, destination: NameLike): SessionLike;
-    /**
-     * Create a new session and wait for completion (async version)
-     *
-     * This method creates a session and waits until the session establishment completes.
-     * Returns only the session context, as the completion has already been awaited.
-     */
-    createSessionAndWaitAsync(config: SessionConfig, destination: NameLike, asyncOpts_?: {
-        signal: AbortSignal;
-    }): Promise<SessionLike>;
-    /**
-     * Create a new session (async version)
-     *
-     * Returns a SessionWithCompletion containing the session context and a completion handle.
-     * Await the completion handle to wait for session establishment.
-     * For point-to-point sessions, this ensures the remote peer has acknowledged the session.
-     * For multicast sessions, this ensures the initial setup is complete.
-     */
-    createSessionAsync(config: SessionConfig, destination: NameLike, asyncOpts_?: {
-        signal: AbortSignal;
-    }): Promise<SessionWithCompletion>;
-    /**
-     * Delete a session (blocking version for FFI)
-     *
-     * Returns a completion handle that can be awaited to ensure the deletion completes.
-     */
-    deleteSession(session: SessionLike): CompletionHandleLike;
-    /**
-     * Delete a session and wait for completion (blocking version)
-     *
-     * This method deletes a session and blocks until the deletion completes.
-     */
-    deleteSessionAndWait(session: SessionLike): void;
-    /**
-     * Delete a session and wait for completion (async version)
-     *
-     * This method deletes a session and waits until the deletion completes.
-     */
-    deleteSessionAndWaitAsync(session: SessionLike, asyncOpts_?: {
-        signal: AbortSignal;
-    }): Promise<void>;
-    /**
-     * Delete a session (async version)
-     *
-     * Returns a completion handle that can be awaited to ensure the deletion completes.
-     */
-    deleteSessionAsync(session: SessionLike, asyncOpts_?: {
-        signal: AbortSignal;
-    }): Promise<CompletionHandleLike>;
-    /**
-     * Get the app ID in UUID format
-     */
-    id(): string;
-    /**
-     * Listen for incoming sessions (blocking version for FFI)
-     */
-    listenForSession(timeout: number | undefined): SessionLike;
-    /**
-     * Listen for incoming sessions (async version)
-     */
-    listenForSessionAsync(timeout: number | undefined, asyncOpts_?: {
-        signal: AbortSignal;
-    }): Promise<SessionLike>;
-    /**
-     * Get the app name
-     */
-    name(): NameLike;
-    /**
-     * Remove a route (blocking version for FFI)
-     */
-    removeRoute(name: NameLike, connectionId: bigint): void;
-    /**
-     * Remove a route (async version)
-     */
-    removeRouteAsync(name: NameLike, connectionId: bigint, asyncOpts_?: {
-        signal: AbortSignal;
-    }): Promise<void>;
-    /**
-     * Set a route to a name for a specific connection (blocking version for FFI)
-     */
-    setRoute(name: NameLike, connectionId: bigint): void;
-    /**
-     * Set a route to a name for a specific connection (async version)
-     */
-    setRouteAsync(name: NameLike, connectionId: bigint, asyncOpts_?: {
-        signal: AbortSignal;
-    }): Promise<void>;
-    /**
-     * Subscribe to a session name (blocking version for FFI)
-     */
-    subscribe(name: NameLike, connectionId: bigint | undefined): void;
-    /**
-     * Subscribe to a name (async version)
-     */
-    subscribeAsync(name: NameLike, connectionId: bigint | undefined, asyncOpts_?: {
-        signal: AbortSignal;
-    }): Promise<void>;
-    /**
-     * Unsubscribe from a name (blocking version for FFI)
-     */
-    unsubscribe(name: NameLike, connectionId: bigint | undefined): void;
-    /**
-     * Unsubscribe from a name (async version)
-     */
-    unsubscribeAsync(name: NameLike, connectionId: bigint | undefined, asyncOpts_?: {
-        signal: AbortSignal;
-    }): Promise<void>;
-    uniffiDestroy(): void;
-    static instanceOf(obj_: any): obj_ is App;
-}
-/**
- * Bidirectional stream handler for stream-to-stream RPC calls
- *
- * Allows sending and receiving messages concurrently.
- */
-export interface BidiStreamHandlerLike {
-    /**
-     * Close the request stream (no more messages will be sent)
-     */
-    closeSend(): void;
-    /**
-     * Close the request stream (async version)
-     */
-    closeSendAsync(asyncOpts_?: {
-        signal: AbortSignal;
-    }): Promise<void>;
-    /**
-     * Receive the next response message (blocking version)
-     */
-    recv(): StreamMessage;
-    /**
-     * Receive the next response message (async version)
-     */
-    recvAsync(asyncOpts_?: {
-        signal: AbortSignal;
-    }): Promise<StreamMessage>;
-    /**
-     * Send a request message to the stream (blocking version)
-     */
-    send(data: ArrayBuffer): void;
-    /**
-     * Send a request message to the stream (async version)
-     */
-    sendAsync(data: ArrayBuffer, asyncOpts_?: {
-        signal: AbortSignal;
-    }): Promise<void>;
-}
-/**
- * @deprecated Use `BidiStreamHandlerLike` instead.
- */
-export type BidiStreamHandlerInterface = BidiStreamHandlerLike;
-/**
- * Bidirectional stream handler for stream-to-stream RPC calls
- *
- * Allows sending and receiving messages concurrently.
- */
-export declare class BidiStreamHandler extends UniffiAbstractObject implements BidiStreamHandlerLike {
-    readonly [uniffiTypeNameSymbol] = "BidiStreamHandler";
-    readonly [destructorGuardSymbol]: UniffiGcObject;
-    readonly [pointerLiteralSymbol]: UniffiHandle;
-    private constructor();
-    /**
-     * Close the request stream (no more messages will be sent)
-     */
-    closeSend(): void;
-    /**
-     * Close the request stream (async version)
-     */
-    closeSendAsync(asyncOpts_?: {
-        signal: AbortSignal;
-    }): Promise<void>;
-    /**
-     * Receive the next response message (blocking version)
-     */
-    recv(): StreamMessage;
-    /**
-     * Receive the next response message (async version)
-     */
-    recvAsync(asyncOpts_?: {
-        signal: AbortSignal;
-    }): Promise<StreamMessage>;
-    /**
-     * Send a request message to the stream (blocking version)
-     */
-    send(data: ArrayBuffer): void;
-    /**
-     * Send a request message to the stream (async version)
-     */
-    sendAsync(data: ArrayBuffer, asyncOpts_?: {
-        signal: AbortSignal;
-    }): Promise<void>;
-    uniffiDestroy(): void;
-    static instanceOf(obj_: any): obj_ is BidiStreamHandler;
-}
-/**
- * Bidirectional stream handler for multicast stream-to-unary and
- * stream-to-stream RPC calls.
- *
- * Send request messages via [`send`](Self::send) / [`send_async`](Self::send_async),
- * close the request stream via [`close_send`](Self::close_send), and receive
- * responses via [`recv`](Self::recv) / [`recv_async`](Self::recv_async). Each
- * response item carries the source member's identity.
- */
-export interface MulticastBidiStreamHandlerLike {
-    /**
-     * Close the request stream — signals that no more messages will be sent
-     * (blocking).
-     */
-    closeSend(): void;
-    /**
-     * Close the request stream (async).
-     */
-    closeSendAsync(asyncOpts_?: {
-        signal: AbortSignal;
-    }): Promise<void>;
-    /**
-     * Receive the next response item (blocking).
-     */
-    recv(): MulticastStreamMessage;
-    /**
-     * Receive the next response item (async).
-     */
-    recvAsync(asyncOpts_?: {
-        signal: AbortSignal;
-    }): Promise<MulticastStreamMessage>;
-    /**
-     * Send a request message to the stream (blocking).
-     */
-    send(data: ArrayBuffer): void;
-    /**
-     * Send a request message to the stream (async).
-     */
-    sendAsync(data: ArrayBuffer, asyncOpts_?: {
-        signal: AbortSignal;
-    }): Promise<void>;
-}
-/**
- * @deprecated Use `MulticastBidiStreamHandlerLike` instead.
- */
-export type MulticastBidiStreamHandlerInterface = MulticastBidiStreamHandlerLike;
-/**
- * Bidirectional stream handler for multicast stream-to-unary and
- * stream-to-stream RPC calls.
- *
- * Send request messages via [`send`](Self::send) / [`send_async`](Self::send_async),
- * close the request stream via [`close_send`](Self::close_send), and receive
- * responses via [`recv`](Self::recv) / [`recv_async`](Self::recv_async). Each
- * response item carries the source member's identity.
- */
-export declare class MulticastBidiStreamHandler extends UniffiAbstractObject implements MulticastBidiStreamHandlerLike {
-    readonly [uniffiTypeNameSymbol] = "MulticastBidiStreamHandler";
-    readonly [destructorGuardSymbol]: UniffiGcObject;
-    readonly [pointerLiteralSymbol]: UniffiHandle;
-    private constructor();
-    /**
-     * Close the request stream — signals that no more messages will be sent
-     * (blocking).
-     */
-    closeSend(): void;
-    /**
-     * Close the request stream (async).
-     */
-    closeSendAsync(asyncOpts_?: {
-        signal: AbortSignal;
-    }): Promise<void>;
-    /**
-     * Receive the next response item (blocking).
-     */
-    recv(): MulticastStreamMessage;
-    /**
-     * Receive the next response item (async).
-     */
-    recvAsync(asyncOpts_?: {
-        signal: AbortSignal;
-    }): Promise<MulticastStreamMessage>;
-    /**
-     * Send a request message to the stream (blocking).
-     */
-    send(data: ArrayBuffer): void;
-    /**
-     * Send a request message to the stream (async).
-     */
-    sendAsync(data: ArrayBuffer, asyncOpts_?: {
-        signal: AbortSignal;
-    }): Promise<void>;
-    uniffiDestroy(): void;
-    static instanceOf(obj_: any): obj_ is MulticastBidiStreamHandler;
-}
-/**
- * Response stream reader for multicast RPC calls.
- *
- * Allows pulling `RpcMulticastItem`s from a GROUP response stream one at a
- * time. Each item carries the source member's identity alongside the payload.
- */
-export interface MulticastResponseReaderLike {
-    /**
-     * Pull the next item from the multicast response stream (blocking).
-     */
-    next(): MulticastStreamMessage;
-    /**
-     * Pull the next item from the multicast response stream (async).
-     */
-    nextAsync(asyncOpts_?: {
-        signal: AbortSignal;
-    }): Promise<MulticastStreamMessage>;
-}
-/**
- * @deprecated Use `MulticastResponseReaderLike` instead.
- */
-export type MulticastResponseReaderInterface = MulticastResponseReaderLike;
-/**
- * Response stream reader for multicast RPC calls.
- *
- * Allows pulling `RpcMulticastItem`s from a GROUP response stream one at a
- * time. Each item carries the source member's identity alongside the payload.
- */
-export declare class MulticastResponseReader extends UniffiAbstractObject implements MulticastResponseReaderLike {
-    readonly [uniffiTypeNameSymbol] = "MulticastResponseReader";
-    readonly [destructorGuardSymbol]: UniffiGcObject;
-    readonly [pointerLiteralSymbol]: UniffiHandle;
-    private constructor();
-    /**
-     * Pull the next item from the multicast response stream (blocking).
-     */
-    next(): MulticastStreamMessage;
-    /**
-     * Pull the next item from the multicast response stream (async).
-     */
-    nextAsync(asyncOpts_?: {
-        signal: AbortSignal;
-    }): Promise<MulticastStreamMessage>;
-    uniffiDestroy(): void;
-    static instanceOf(obj_: any): obj_ is MulticastResponseReader;
-}
-/**
- * Request stream writer for stream-to-unary RPC calls
- *
- * Allows sending multiple request messages and getting a final response.
- */
-export interface RequestStreamWriterLike {
-    /**
-     * Finalize the stream and get the response (async version)
-     *
-     * **Deprecated**: Use [`finalize_stream_async`](Self::finalize_stream_async) instead.
-     */
-    finalizeAsync(asyncOpts_?: {
-        signal: AbortSignal;
-    }): Promise<ArrayBuffer>;
-    /**
-     * Finalize the stream and get the response (blocking version)
-     */
-    finalizeStream(): ArrayBuffer;
-    /**
-     * Finalize the stream and get the response (async version)
-     */
-    finalizeStreamAsync(asyncOpts_?: {
-        signal: AbortSignal;
-    }): Promise<ArrayBuffer>;
-    /**
-     * Send a request message to the stream (blocking version)
-     */
-    send(data: ArrayBuffer): void;
-    /**
-     * Send a request message to the stream (async version)
-     */
-    sendAsync(data: ArrayBuffer, asyncOpts_?: {
-        signal: AbortSignal;
-    }): Promise<void>;
-}
-/**
- * @deprecated Use `RequestStreamWriterLike` instead.
- */
-export type RequestStreamWriterInterface = RequestStreamWriterLike;
-/**
- * Request stream writer for stream-to-unary RPC calls
- *
- * Allows sending multiple request messages and getting a final response.
- */
-export declare class RequestStreamWriter extends UniffiAbstractObject implements RequestStreamWriterLike {
-    readonly [uniffiTypeNameSymbol] = "RequestStreamWriter";
-    readonly [destructorGuardSymbol]: UniffiGcObject;
-    readonly [pointerLiteralSymbol]: UniffiHandle;
-    private constructor();
-    /**
-     * Finalize the stream and get the response (async version)
-     *
-     * **Deprecated**: Use [`finalize_stream_async`](Self::finalize_stream_async) instead.
-     */
-    finalizeAsync(asyncOpts_?: {
-        signal: AbortSignal;
-    }): Promise<ArrayBuffer>;
-    /**
-     * Finalize the stream and get the response (blocking version)
-     */
-    finalizeStream(): ArrayBuffer;
-    /**
-     * Finalize the stream and get the response (async version)
-     */
-    finalizeStreamAsync(asyncOpts_?: {
-        signal: AbortSignal;
-    }): Promise<ArrayBuffer>;
-    /**
-     * Send a request message to the stream (blocking version)
-     */
-    send(data: ArrayBuffer): void;
-    /**
-     * Send a request message to the stream (async version)
-     */
-    sendAsync(data: ArrayBuffer, asyncOpts_?: {
-        signal: AbortSignal;
-    }): Promise<void>;
-    uniffiDestroy(): void;
-    static instanceOf(obj_: any): obj_ is RequestStreamWriter;
-}
-/**
- * Response stream reader for unary-to-stream RPC calls
- *
- * Allows pulling messages from a server response stream one at a time.
- */
-export interface ResponseStreamReaderLike {
-    /**
-     * Pull the next message from the response stream (blocking version)
-     *
-     * Returns a StreamMessage indicating the result
-     */
-    next(): StreamMessage;
-    /**
-     * Pull the next message from the response stream (async version)
-     *
-     * Returns a StreamMessage indicating the result
-     */
-    nextAsync(asyncOpts_?: {
-        signal: AbortSignal;
-    }): Promise<StreamMessage>;
-}
-/**
- * @deprecated Use `ResponseStreamReaderLike` instead.
- */
-export type ResponseStreamReaderInterface = ResponseStreamReaderLike;
-/**
- * Response stream reader for unary-to-stream RPC calls
- *
- * Allows pulling messages from a server response stream one at a time.
- */
-export declare class ResponseStreamReader extends UniffiAbstractObject implements ResponseStreamReaderLike {
-    readonly [uniffiTypeNameSymbol] = "ResponseStreamReader";
-    readonly [destructorGuardSymbol]: UniffiGcObject;
-    readonly [pointerLiteralSymbol]: UniffiHandle;
-    private constructor();
-    /**
-     * Pull the next message from the response stream (blocking version)
-     *
-     * Returns a StreamMessage indicating the result
-     */
-    next(): StreamMessage;
-    /**
-     * Pull the next message from the response stream (async version)
-     *
-     * Returns a StreamMessage indicating the result
-     */
-    nextAsync(asyncOpts_?: {
-        signal: AbortSignal;
-    }): Promise<StreamMessage>;
-    uniffiDestroy(): void;
-    static instanceOf(obj_: any): obj_ is ResponseStreamReader;
-}
-/**
- * Client-side channel for making RPC calls.
- *
- * Manages a single persistent SLIM session: either a `PointToPoint` session
- * to a single remote server, or a `Multicast` (GROUP) session shared across
- * multiple remote servers. The session is lazily initialised and recreated
- * when dead.
- *
- * ## Constructor
- *
- * - `new_with_members_internal(app, members)` — Smart constructor:
- * - **1 member**: creates a P2P channel.
- * - **Many members**: creates a GROUP channel with a generated session name
- * and auto-invites all members on the first multicast call.
- */
-export interface ChannelLike {
-    /**
-     * Broadcast a request stream to all GROUP members and stream their
-     * responses.
-     *
-     * Semantically equivalent to `call_multicast_stream_unary` at the
-     * transport level; the difference (one vs many responses per member) is
-     * determined by the server handler.
-     */
-    callMulticastStreamStream(serviceName: string, methodName: string, timeout: number | undefined, metadata: Map<string, string> | undefined): MulticastBidiStreamHandlerLike;
-    /**
-     * Broadcast a request stream to all GROUP members and collect their
-     * responses.
-     *
-     * Returns a handler that lets you send requests and receive responses
-     * concurrently. Use `send` / `send_async` to push request messages,
-     * `close_send` / `close_send_async` to signal end-of-requests, and
-     * `recv` / `recv_async` to pull response items.
-     */
-    callMulticastStreamUnary(serviceName: string, methodName: string, timeout: number | undefined, metadata: Map<string, string> | undefined): MulticastBidiStreamHandlerLike;
-    /**
-     * Broadcast one request to all GROUP members and collect their responses.
-     *
-     * Returns a reader from which each member's response (wrapped in
-     * `MulticastStreamMessage`) can be pulled one at a time (blocking).
-     */
-    callMulticastUnary(serviceName: string, methodName: string, request: ArrayBuffer, timeout: number | undefined, metadata: Map<string, string> | undefined): MulticastResponseReaderLike;
-    /**
-     * Broadcast one request to all GROUP members and collect their responses
-     * (async).
-     */
-    callMulticastUnaryAsync(serviceName: string, methodName: string, request: ArrayBuffer, timeout: number | undefined, metadata: Map<string, string> | undefined, asyncOpts_?: {
-        signal: AbortSignal;
-    }): Promise<MulticastResponseReaderLike>;
-    /**
-     * Broadcast one request to all GROUP members and stream their responses
-     * (blocking).
-     *
-     * Semantically identical to `call_multicast_unary` at the transport level;
-     * the difference is that each member may send multiple responses before its
-     * EOS, which the server handler determines.
-     */
-    callMulticastUnaryStream(serviceName: string, methodName: string, request: ArrayBuffer, timeout: number | undefined, metadata: Map<string, string> | undefined): MulticastResponseReaderLike;
-    /**
-     * Broadcast one request to all GROUP members and stream their responses
-     * (async).
-     */
-    callMulticastUnaryStreamAsync(serviceName: string, methodName: string, request: ArrayBuffer, timeout: number | undefined, metadata: Map<string, string> | undefined, asyncOpts_?: {
-        signal: AbortSignal;
-    }): Promise<MulticastResponseReaderLike>;
-    callStreamStream(serviceName: string, methodName: string, timeout: number | undefined, metadata: Map<string, string> | undefined): BidiStreamHandlerLike;
-    callStreamUnary(serviceName: string, methodName: string, timeout: number | undefined, metadata: Map<string, string> | undefined): RequestStreamWriterLike;
-    callUnary(serviceName: string, methodName: string, request: ArrayBuffer, timeout: number | undefined, metadata: Map<string, string> | undefined): ArrayBuffer;
-    callUnaryAsync(serviceName: string, methodName: string, request: ArrayBuffer, timeout: number | undefined, metadata: Map<string, string> | undefined, asyncOpts_?: {
-        signal: AbortSignal;
-    }): Promise<ArrayBuffer>;
-    callUnaryStream(serviceName: string, methodName: string, request: ArrayBuffer, timeout: number | undefined, metadata: Map<string, string> | undefined): ResponseStreamReaderLike;
-    callUnaryStreamAsync(serviceName: string, methodName: string, request: ArrayBuffer, timeout: number | undefined, metadata: Map<string, string> | undefined, asyncOpts_?: {
-        signal: AbortSignal;
-    }): Promise<ResponseStreamReaderLike>;
-    /**
-     * Close the persistent SLIM session held by this channel, if any.
-     *
-     * `timeout` optionally bounds how long to wait for the session layer to
-     * confirm the close before giving up and proceeding with cleanup anyway.
-     * Pass `None` to wait indefinitely.
-     *
-     * After this call the channel can still be used; a new session will be
-     * created automatically on the next RPC call.
-     */
-    close(timeout: number | undefined): void;
-    /**
-     * Async version of [`close`](Self::close).
-     */
-    closeAsync(timeout: number | undefined, asyncOpts_?: {
-        signal: AbortSignal;
-    }): Promise<void>;
-}
-/**
- * @deprecated Use `ChannelLike` instead.
- */
-export type ChannelInterface = ChannelLike;
-/**
- * Client-side channel for making RPC calls.
- *
- * Manages a single persistent SLIM session: either a `PointToPoint` session
- * to a single remote server, or a `Multicast` (GROUP) session shared across
- * multiple remote servers. The session is lazily initialised and recreated
- * when dead.
- *
- * ## Constructor
- *
- * - `new_with_members_internal(app, members)` — Smart constructor:
- * - **1 member**: creates a P2P channel.
- * - **Many members**: creates a GROUP channel with a generated session name
- * and auto-invites all members on the first multicast call.
- */
-export declare class Channel extends UniffiAbstractObject implements ChannelLike {
-    readonly [uniffiTypeNameSymbol] = "Channel";
-    readonly [destructorGuardSymbol]: UniffiGcObject;
-    readonly [pointerLiteralSymbol]: UniffiHandle;
-    constructor(app: AppLike, remote: NameLike);
-    static newGroup(app: AppLike, members: Array<NameLike>): ChannelLike;
-    static newGroupWithConnection(app: AppLike, members: Array<NameLike>, connectionId: bigint | undefined): ChannelLike;
-    static newWithConnection(app: AppLike, remote: NameLike, connectionId: bigint | undefined): ChannelLike;
-    /**
-     * Broadcast a request stream to all GROUP members and stream their
-     * responses.
-     *
-     * Semantically equivalent to `call_multicast_stream_unary` at the
-     * transport level; the difference (one vs many responses per member) is
-     * determined by the server handler.
-     */
-    callMulticastStreamStream(serviceName: string, methodName: string, timeout: number | undefined, metadata: Map<string, string> | undefined): MulticastBidiStreamHandlerLike;
-    /**
-     * Broadcast a request stream to all GROUP members and collect their
-     * responses.
-     *
-     * Returns a handler that lets you send requests and receive responses
-     * concurrently. Use `send` / `send_async` to push request messages,
-     * `close_send` / `close_send_async` to signal end-of-requests, and
-     * `recv` / `recv_async` to pull response items.
-     */
-    callMulticastStreamUnary(serviceName: string, methodName: string, timeout: number | undefined, metadata: Map<string, string> | undefined): MulticastBidiStreamHandlerLike;
-    /**
-     * Broadcast one request to all GROUP members and collect their responses.
-     *
-     * Returns a reader from which each member's response (wrapped in
-     * `MulticastStreamMessage`) can be pulled one at a time (blocking).
-     */
-    callMulticastUnary(serviceName: string, methodName: string, request: ArrayBuffer, timeout: number | undefined, metadata: Map<string, string> | undefined): MulticastResponseReaderLike;
-    /**
-     * Broadcast one request to all GROUP members and collect their responses
-     * (async).
-     */
-    callMulticastUnaryAsync(serviceName: string, methodName: string, request: ArrayBuffer, timeout: number | undefined, metadata: Map<string, string> | undefined, asyncOpts_?: {
-        signal: AbortSignal;
-    }): Promise<MulticastResponseReaderLike>;
-    /**
-     * Broadcast one request to all GROUP members and stream their responses
-     * (blocking).
-     *
-     * Semantically identical to `call_multicast_unary` at the transport level;
-     * the difference is that each member may send multiple responses before its
-     * EOS, which the server handler determines.
-     */
-    callMulticastUnaryStream(serviceName: string, methodName: string, request: ArrayBuffer, timeout: number | undefined, metadata: Map<string, string> | undefined): MulticastResponseReaderLike;
-    /**
-     * Broadcast one request to all GROUP members and stream their responses
-     * (async).
-     */
-    callMulticastUnaryStreamAsync(serviceName: string, methodName: string, request: ArrayBuffer, timeout: number | undefined, metadata: Map<string, string> | undefined, asyncOpts_?: {
-        signal: AbortSignal;
-    }): Promise<MulticastResponseReaderLike>;
-    callStreamStream(serviceName: string, methodName: string, timeout: number | undefined, metadata: Map<string, string> | undefined): BidiStreamHandlerLike;
-    callStreamUnary(serviceName: string, methodName: string, timeout: number | undefined, metadata: Map<string, string> | undefined): RequestStreamWriterLike;
-    callUnary(serviceName: string, methodName: string, request: ArrayBuffer, timeout: number | undefined, metadata: Map<string, string> | undefined): ArrayBuffer;
-    callUnaryAsync(serviceName: string, methodName: string, request: ArrayBuffer, timeout: number | undefined, metadata: Map<string, string> | undefined, asyncOpts_?: {
-        signal: AbortSignal;
-    }): Promise<ArrayBuffer>;
-    callUnaryStream(serviceName: string, methodName: string, request: ArrayBuffer, timeout: number | undefined, metadata: Map<string, string> | undefined): ResponseStreamReaderLike;
-    callUnaryStreamAsync(serviceName: string, methodName: string, request: ArrayBuffer, timeout: number | undefined, metadata: Map<string, string> | undefined, asyncOpts_?: {
-        signal: AbortSignal;
-    }): Promise<ResponseStreamReaderLike>;
-    /**
-     * Close the persistent SLIM session held by this channel, if any.
-     *
-     * `timeout` optionally bounds how long to wait for the session layer to
-     * confirm the close before giving up and proceeding with cleanup anyway.
-     * Pass `None` to wait indefinitely.
-     *
-     * After this call the channel can still be used; a new session will be
-     * created automatically on the next RPC call.
-     */
-    close(timeout: number | undefined): void;
-    /**
-     * Async version of [`close`](Self::close).
-     */
-    closeAsync(timeout: number | undefined, asyncOpts_?: {
-        signal: AbortSignal;
-    }): Promise<void>;
-    uniffiDestroy(): void;
-    static instanceOf(obj_: any): obj_ is Channel;
-}
-/**
- * Context passed to RPC handlers
- *
- * Contains all contextual information about an RPC call including:
- * - Session information (source, destination, session ID)
- * - Metadata (key-value pairs)
- * - Deadline/timeout information
- * - Message routing details
- */
-export interface ContextLike {
-    /**
-     * Get the deadline for this RPC call
-     */
-    deadline(): Date;
-    /**
-     * Check if the deadline has been exceeded
-     */
-    isDeadlineExceeded(): boolean;
-    /**
-     * Get the rpc session metadata
-     */
-    metadata(): Map<string, string>;
-    /**
-     * Get the remaining time until deadline
-     *
-     * Returns Duration::ZERO if the deadline has already passed
-     */
-    remainingTime(): number;
-    /**
-     * Get the session ID
-     */
-    sessionId(): string;
-}
-/**
- * @deprecated Use `ContextLike` instead.
- */
-export type ContextInterface = ContextLike;
-/**
- * Context passed to RPC handlers
- *
- * Contains all contextual information about an RPC call including:
- * - Session information (source, destination, session ID)
- * - Metadata (key-value pairs)
- * - Deadline/timeout information
- * - Message routing details
- */
-export declare class Context extends UniffiAbstractObject implements ContextLike {
-    readonly [uniffiTypeNameSymbol] = "Context";
-    readonly [destructorGuardSymbol]: UniffiGcObject;
-    readonly [pointerLiteralSymbol]: UniffiHandle;
-    private constructor();
-    /**
-     * Get the deadline for this RPC call
-     */
-    deadline(): Date;
-    /**
-     * Check if the deadline has been exceeded
-     */
-    isDeadlineExceeded(): boolean;
-    /**
-     * Get the rpc session metadata
-     */
-    metadata(): Map<string, string>;
-    /**
-     * Get the remaining time until deadline
-     *
-     * Returns Duration::ZERO if the deadline has already passed
-     */
-    remainingTime(): number;
-    /**
-     * Get the session ID
-     */
-    sessionId(): string;
-    uniffiDestroy(): void;
-    static instanceOf(obj_: any): obj_ is Context;
-}
-/**
- * Request stream reader
- *
- * Allows pulling messages from a client request stream.
- * This wraps the underlying async stream and provides a blocking interface
- * suitable for UniFFI callback traits.
- */
-export interface RequestStreamLike {
-    /**
-     * Pull the next message from the stream (blocking version)
-     *
-     * Returns a StreamMessage indicating the result
-     */
-    next(): StreamMessage;
-    /**
-     * Pull the next message from the stream (async version)
-     *
-     * Returns a StreamMessage indicating the result
-     */
-    nextAsync(asyncOpts_?: {
-        signal: AbortSignal;
-    }): Promise<StreamMessage>;
-}
-/**
- * @deprecated Use `RequestStreamLike` instead.
- */
-export type RequestStreamInterface = RequestStreamLike;
-/**
- * Request stream reader
- *
- * Allows pulling messages from a client request stream.
- * This wraps the underlying async stream and provides a blocking interface
- * suitable for UniFFI callback traits.
- */
-export declare class RequestStream extends UniffiAbstractObject implements RequestStreamLike {
-    readonly [uniffiTypeNameSymbol] = "RequestStream";
-    readonly [destructorGuardSymbol]: UniffiGcObject;
-    readonly [pointerLiteralSymbol]: UniffiHandle;
-    private constructor();
-    /**
-     * Pull the next message from the stream (blocking version)
-     *
-     * Returns a StreamMessage indicating the result
-     */
-    next(): StreamMessage;
-    /**
-     * Pull the next message from the stream (async version)
-     *
-     * Returns a StreamMessage indicating the result
-     */
-    nextAsync(asyncOpts_?: {
-        signal: AbortSignal;
-    }): Promise<StreamMessage>;
-    uniffiDestroy(): void;
-    static instanceOf(obj_: any): obj_ is RequestStream;
-}
-/**
- * Response stream writer
- *
- * Allows pushing messages to a client response stream.
- * This wraps an async channel sender and provides a blocking interface
- * suitable for UniFFI callback traits.
- */
-export interface ResponseSinkLike {
-    /**
-     * Close the response stream (blocking version)
-     *
-     * Signals that no more messages will be sent.
-     * The stream will end gracefully.
-     */
-    close(): void;
-    /**
-     * Close the response stream (async version)
-     *
-     * Signals that no more messages will be sent.
-     * The stream will end gracefully.
-     */
-    closeAsync(asyncOpts_?: {
-        signal: AbortSignal;
-    }): Promise<void>;
-    /**
-     * Check if the sink has been closed (blocking version)
-     */
-    isClosed(): boolean;
-    /**
-     * Check if the sink has been closed (async version)
-     */
-    isClosedAsync(asyncOpts_?: {
-        signal: AbortSignal;
-    }): Promise<boolean>;
-    /**
-     * Send a message to the response stream (blocking version)
-     *
-     * Returns an error if the stream has been closed or if sending fails.
-     */
-    send(data: ArrayBuffer): void;
-    /**
-     * Send a message to the response stream (async version)
-     *
-     * Returns an error if the stream has been closed or if sending fails.
-     */
-    sendAsync(data: ArrayBuffer, asyncOpts_?: {
-        signal: AbortSignal;
-    }): Promise<void>;
-    /**
-     * Send an error to the response stream and close it (blocking version)
-     *
-     * This terminates the stream with an error status.
-     */
-    sendError(error: RpcError): void;
-    /**
-     * Send an error to the response stream and close it (async version)
-     *
-     * This terminates the stream with an error status.
-     */
-    sendErrorAsync(error: RpcError, asyncOpts_?: {
-        signal: AbortSignal;
-    }): Promise<void>;
-}
-/**
- * @deprecated Use `ResponseSinkLike` instead.
- */
-export type ResponseSinkInterface = ResponseSinkLike;
-/**
- * Response stream writer
- *
- * Allows pushing messages to a client response stream.
- * This wraps an async channel sender and provides a blocking interface
- * suitable for UniFFI callback traits.
- */
-export declare class ResponseSink extends UniffiAbstractObject implements ResponseSinkLike {
-    readonly [uniffiTypeNameSymbol] = "ResponseSink";
-    readonly [destructorGuardSymbol]: UniffiGcObject;
-    readonly [pointerLiteralSymbol]: UniffiHandle;
-    private constructor();
-    /**
-     * Close the response stream (blocking version)
-     *
-     * Signals that no more messages will be sent.
-     * The stream will end gracefully.
-     */
-    close(): void;
-    /**
-     * Close the response stream (async version)
-     *
-     * Signals that no more messages will be sent.
-     * The stream will end gracefully.
-     */
-    closeAsync(asyncOpts_?: {
-        signal: AbortSignal;
-    }): Promise<void>;
-    /**
-     * Check if the sink has been closed (blocking version)
-     */
-    isClosed(): boolean;
-    /**
-     * Check if the sink has been closed (async version)
-     */
-    isClosedAsync(asyncOpts_?: {
-        signal: AbortSignal;
-    }): Promise<boolean>;
-    /**
-     * Send a message to the response stream (blocking version)
-     *
-     * Returns an error if the stream has been closed or if sending fails.
-     */
-    send(data: ArrayBuffer): void;
-    /**
-     * Send a message to the response stream (async version)
-     *
-     * Returns an error if the stream has been closed or if sending fails.
-     */
-    sendAsync(data: ArrayBuffer, asyncOpts_?: {
-        signal: AbortSignal;
-    }): Promise<void>;
-    /**
-     * Send an error to the response stream and close it (blocking version)
-     *
-     * This terminates the stream with an error status.
-     */
-    sendError(error: RpcError): void;
-    /**
-     * Send an error to the response stream and close it (async version)
-     *
-     * This terminates the stream with an error status.
-     */
-    sendErrorAsync(error: RpcError, asyncOpts_?: {
-        signal: AbortSignal;
-    }): Promise<void>;
-    uniffiDestroy(): void;
-    static instanceOf(obj_: any): obj_ is ResponseSink;
-}
-/**
- * Stream-to-Stream RPC handler trait
- *
- * Implement this trait to handle stream-to-stream RPC calls.
- * The handler receives multiple requests via the stream and sends multiple responses via the sink.
- */
-export interface StreamStreamHandler {
-    /**
-     * Handle a stream-to-stream RPC call
-     *
-     * # Arguments
-     * * `stream` - Request stream to pull messages from
-     * * `context` - RPC context with metadata and session information
-     * * `sink` - Response sink to send streaming responses
-     *
-     * # Returns
-     * Ok(()) if handling succeeded, or an error
-     *
-     * # Note
-     * You must call `sink.close()` or `sink.send_error()` when done.
-     */
-    handle(stream: RequestStreamLike, context: ContextLike, sink: ResponseSinkLike, asyncOpts_?: {
-        signal: AbortSignal;
-    }): Promise<void>;
-}
-/**
- * Stream-to-Stream RPC handler trait
- *
- * Implement this trait to handle stream-to-stream RPC calls.
- * The handler receives multiple requests via the stream and sends multiple responses via the sink.
- */
-export declare class StreamStreamHandlerImpl extends UniffiAbstractObject implements StreamStreamHandler {
-    readonly [uniffiTypeNameSymbol] = "StreamStreamHandlerImpl";
+export declare class App extends UniffiAbstractObject implements AppLike {
+    readonly [uniffiTypeNameSymbol] = "App";
     readonly [destructorGuardSymbol]: UniffiGcObject;
     readonly [pointerLiteralSymbol]: UniffiHandle;
-    private constructor();
     /**
-     * Handle a stream-to-stream RPC call
+     * Create a new App with identity provider and verifier configurations
+     *
+     * This is the main entry point for creating a SLIM application from language bindings.
      *
      * # Arguments
-     * * `stream` - Request stream to pull messages from
-     * * `context` - RPC context with metadata and session information
-     * * `sink` - Response sink to send streaming responses
+     * * `base_name` - The base name for the app (without ID)
+     * * `identity_provider_config` - Configuration for proving identity to others
+     * * `identity_verifier_config` - Configuration for verifying identity of others
      *
      * # Returns
-     * Ok(()) if handling succeeded, or an error
+     * * `Ok(Arc<App>)` - Successfully created adapter
+     * * `Err(SlimError)` - If adapter creation fails
      *
-     * # Note
-     * You must call `sink.close()` or `sink.send_error()` when done.
+     * # Supported Identity Types
+     * - SharedSecret: Symmetric key authentication
+     * - JWT: Dynamic JWT generation/verification with signing/decoding keys
+     * - StaticJWT: Static JWT loaded from file with auto-reload
      */
-    handle(stream: RequestStreamLike, context: ContextLike, sink: ResponseSinkLike, asyncOpts_?: {
-        signal: AbortSignal;
-    }): Promise<void>;
-    uniffiDestroy(): void;
-    static instanceOf(obj_: any): obj_ is StreamStreamHandlerImpl;
-}
-/**
- * Stream-to-Unary RPC handler trait
- *
- * Implement this trait to handle stream-to-unary RPC calls.
- * The handler receives multiple requests via the stream and returns a single response.
- */
-export interface StreamUnaryHandler {
+    constructor(baseName: NameLike, identityProviderConfig: IdentityProviderConfig, identityVerifierConfig: IdentityVerifierConfig);
     /**
-     * Handle a stream-to-unary RPC call
+     * Create a new App with traffic direction (blocking version)
+     *
+     * This is a convenience function for creating a SLIM application with configurable
+     * traffic direction (send-only, receive-only, bidirectional, or none).
      *
      * # Arguments
-     * * `stream` - Request stream to pull messages from
-     * * `context` - RPC context with metadata and session information
+     * * `name` - The base name for the app (without ID)
+     * * `identity_provider_config` - Configuration for proving identity to others
+     * * `identity_verifier_config` - Configuration for verifying identity of others
+     * * `direction` - Traffic direction for sessions (Send, Recv, Bidirectional, or None)
      *
      * # Returns
-     * The response message bytes or an error
+     * * `Ok(Arc<App>)` - Successfully created app
+     * * `Err(SlimError)` - If app creation fails
      */
-    handle(stream: RequestStreamLike, context: ContextLike, asyncOpts_?: {
-        signal: AbortSignal;
-    }): Promise<ArrayBuffer>;
-}
-/**
- * Stream-to-Unary RPC handler trait
- *
- * Implement this trait to handle stream-to-unary RPC calls.
- * The handler receives multiple requests via the stream and returns a single response.
- */
-export declare class StreamUnaryHandlerImpl extends UniffiAbstractObject implements StreamUnaryHandler {
-    readonly [uniffiTypeNameSymbol] = "StreamUnaryHandlerImpl";
-    readonly [destructorGuardSymbol]: UniffiGcObject;
-    readonly [pointerLiteralSymbol]: UniffiHandle;
-    private constructor();
+    static newWithDirection(name: NameLike, identityProviderConfig: IdentityProviderConfig, identityVerifierConfig: IdentityVerifierConfig, direction: Direction): AppLike;
     /**
-     * Handle a stream-to-unary RPC call
+     * Create a new App with SharedSecret authentication (blocking version)
+     *
+     * This is a convenience function for creating a SLIM application using SharedSecret authentication.
      *
      * # Arguments
-     * * `stream` - Request stream to pull messages from
-     * * `context` - RPC context with metadata and session information
+     * * `name` - The base name for the app (without ID)
+     * * `secret` - The shared secret string for authentication
      *
      * # Returns
-     * The response message bytes or an error
+     * * `Ok(Arc<App>)` - Successfully created adapter
+     * * `Err(SlimError)` - If adapter creation fails
      */
-    handle(stream: RequestStreamLike, context: ContextLike, asyncOpts_?: {
-        signal: AbortSignal;
-    }): Promise<ArrayBuffer>;
-    uniffiDestroy(): void;
-    static instanceOf(obj_: any): obj_ is StreamUnaryHandlerImpl;
-}
-/**
- * Unary-to-Stream RPC handler trait
- *
- * Implement this trait to handle unary-to-stream RPC calls.
- * The handler receives a single request and sends multiple responses via the sink.
- */
-export interface UnaryStreamHandler {
+    static newWithSecret(name: NameLike, secret: string): AppLike;
     /**
-     * Handle a unary-to-stream RPC call
-     *
-     * # Arguments
-     * * `request` - The request message bytes
-     * * `context` - RPC context with metadata and session information
-     * * `sink` - Response sink to send streaming responses
-     *
-     * # Returns
-     * Ok(()) if handling succeeded, or an error
+     * Create a new session (blocking version for FFI)
      *
-     * # Note
-     * You must call `sink.close()` or `sink.send_error()` when done.
+     * Returns a SessionWithCompletion containing the session context and a completion handle.
+     * Call `.wait()` on the completion handle to wait for session establishment.
      */
-    handle(request: ArrayBuffer, context: ContextLike, sink: ResponseSinkLike, asyncOpts_?: {
-        signal: AbortSignal;
-    }): Promise<void>;
-}
-/**
- * Unary-to-Stream RPC handler trait
- *
- * Implement this trait to handle unary-to-stream RPC calls.
- * The handler receives a single request and sends multiple responses via the sink.
- */
-export declare class UnaryStreamHandlerImpl extends UniffiAbstractObject implements UnaryStreamHandler {
-    readonly [uniffiTypeNameSymbol] = "UnaryStreamHandlerImpl";
-    readonly [destructorGuardSymbol]: UniffiGcObject;
-    readonly [pointerLiteralSymbol]: UniffiHandle;
-    private constructor();
+    createSession(config: SessionConfig, destination: NameLike): SessionWithCompletion;
     /**
-     * Handle a unary-to-stream RPC call
-     *
-     * # Arguments
-     * * `request` - The request message bytes
-     * * `context` - RPC context with metadata and session information
-     * * `sink` - Response sink to send streaming responses
-     *
-     * # Returns
-     * Ok(()) if handling succeeded, or an error
+     * Create a new session and wait for completion (blocking version)
      *
-     * # Note
-     * You must call `sink.close()` or `sink.send_error()` when done.
+     * This method creates a session and blocks until the session establishment completes.
+     * Returns only the session context, as the completion has already been awaited.
      */
-    handle(request: ArrayBuffer, context: ContextLike, sink: ResponseSinkLike, asyncOpts_?: {
-        signal: AbortSignal;
-    }): Promise<void>;
-    uniffiDestroy(): void;
-    static instanceOf(obj_: any): obj_ is UnaryStreamHandlerImpl;
-}
-/**
- * Unary-to-Unary RPC handler trait
- *
- * Implement this trait to handle unary-to-unary RPC calls.
- * The handler receives a single request and returns a single response.
- */
-export interface UnaryUnaryHandler {
+    createSessionAndWait(config: SessionConfig, destination: NameLike): SessionLike;
     /**
-     * Handle a unary-to-unary RPC call
-     *
-     * # Arguments
-     * * `request` - The request message bytes
-     * * `context` - RPC context with metadata and session information
+     * Create a new session and wait for completion (async version)
      *
-     * # Returns
-     * The response message bytes or an error
+     * This method creates a session and waits until the session establishment completes.
+     * Returns only the session context, as the completion has already been awaited.
      */
-    handle(request: ArrayBuffer, context: ContextLike, asyncOpts_?: {
+    createSessionAndWaitAsync(config: SessionConfig, destination: NameLike, asyncOpts_?: {
         signal: AbortSignal;
-    }): Promise<ArrayBuffer>;
-}
-/**
- * Unary-to-Unary RPC handler trait
- *
- * Implement this trait to handle unary-to-unary RPC calls.
- * The handler receives a single request and returns a single response.
- */
-export declare class UnaryUnaryHandlerImpl extends UniffiAbstractObject implements UnaryUnaryHandler {
-    readonly [uniffiTypeNameSymbol] = "UnaryUnaryHandlerImpl";
-    readonly [destructorGuardSymbol]: UniffiGcObject;
-    readonly [pointerLiteralSymbol]: UniffiHandle;
-    private constructor();
+    }): Promise<SessionLike>;
     /**
-     * Handle a unary-to-unary RPC call
-     *
-     * # Arguments
-     * * `request` - The request message bytes
-     * * `context` - RPC context with metadata and session information
+     * Create a new session (async version)
      *
-     * # Returns
-     * The response message bytes or an error
+     * Returns a SessionWithCompletion containing the session context and a completion handle.
+     * Await the completion handle to wait for session establishment.
+     * For point-to-point sessions, this ensures the remote peer has acknowledged the session.
+     * For multicast sessions, this ensures the initial setup is complete.
      */
-    handle(request: ArrayBuffer, context: ContextLike, asyncOpts_?: {
+    createSessionAsync(config: SessionConfig, destination: NameLike, asyncOpts_?: {
         signal: AbortSignal;
-    }): Promise<ArrayBuffer>;
-    uniffiDestroy(): void;
-    static instanceOf(obj_: any): obj_ is UnaryUnaryHandlerImpl;
-}
-/**
- * RPC Server
- *
- * Handles incoming RPC requests by creating sessions and dispatching
- * to registered service handlers.
- *
- * # Example
- *
- * ```no_run
- * # use slim_bindings::{Server, Context, RpcError, Decoder, Encoder, App, Name};
- * # use std::sync::Arc;
- * # fn main() -> Result<(), Box<dyn std::error::Error>> {
- * # use slim_bindings::{IdentityProviderConfig, IdentityVerifierConfig};
- * # let app_name = Arc::new(Name::new("test".to_string(), "app".to_string(), "v1".to_string()));
- * # let provider = IdentityProviderConfig::SharedSecret { id: "test".to_string(), data: "secret".to_string() };
- * # let verifier = IdentityVerifierConfig::SharedSecret { id: "test".to_string(), data: "secret".to_string() };
- * # let app = App::new(app_name, provider, verifier)?;
- * # let core_app = app.inner();
- * # let notification_rx = app.notification_receiver();
- * # #[derive(Default)]
- * # struct Request {}
- * # impl Decoder for Request {
- * #     fn decode(_buf: impl Into<Vec<u8>>) -> Result<Self, RpcError> { Ok(Request::default()) }
- * # }
- * # #[derive(Default)]
- * # struct Response {}
- * # impl Encoder for Response {
- * #     fn encode(self) -> Result<Vec<u8>, RpcError> { Ok(vec![]) }
- * # }
- * let base_name = Name::new("org".to_string(), "namespace".to_string(), "service".to_string());
- * let server = Server::new_with_shared_rx_and_connection(core_app, base_name.as_slim_name(), None, notification_rx, None);
- *
- * // Register handlers
- * server.register_unary_unary_internal(
- * "MyService",
- * "MyMethod",
- * |request: Request, _ctx: Context| async move {
- * Ok(Response::default())
- * }
- * );
- * # Ok(())
- * # }
- * ```
- */
-export interface ServerLike {
+    }): Promise<SessionWithCompletion>;
     /**
-     * Register a stream-to-stream RPC handler
+     * Delete a session (blocking version for FFI)
      *
-     * # Arguments
-     * * `service_name` - The service name
-     * * `method_name` - The method name
-     * * `handler` - Implementation of the StreamStreamHandler trait
+     * Returns a completion handle that can be awaited to ensure the deletion completes.
      */
-    registerStreamStream(serviceName: string, methodName: string, handler: StreamStreamHandler): void;
+    deleteSession(session: SessionLike): CompletionHandleLike;
     /**
-     * Register a stream-to-unary RPC handler
+     * Delete a session and wait for completion (blocking version)
      *
-     * # Arguments
-     * * `service_name` - The service name
-     * * `method_name` - The method name
-     * * `handler` - Implementation of the StreamUnaryHandler trait
+     * This method deletes a session and blocks until the deletion completes.
      */
-    registerStreamUnary(serviceName: string, methodName: string, handler: StreamUnaryHandler): void;
+    deleteSessionAndWait(session: SessionLike): void;
     /**
-     * Register a unary-to-stream RPC handler
+     * Delete a session and wait for completion (async version)
      *
-     * # Arguments
-     * * `service_name` - The service name
-     * * `method_name` - The method name
-     * * `handler` - Implementation of the UnaryStreamHandler trait
+     * This method deletes a session and waits until the deletion completes.
      */
-    registerUnaryStream(serviceName: string, methodName: string, handler: UnaryStreamHandler): void;
+    deleteSessionAndWaitAsync(session: SessionLike, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<void>;
     /**
-     * Register a unary-to-unary RPC handler
+     * Delete a session (async version)
      *
-     * # Arguments
-     * * `service_name` - The service name (e.g., "MyService")
-     * * `method_name` - The method name (e.g., "GetUser")
-     * * `handler` - Implementation of the UnaryUnaryHandler trait
+     * Returns a completion handle that can be awaited to ensure the deletion completes.
      */
-    registerUnaryUnary(serviceName: string, methodName: string, handler: UnaryUnaryHandler): void;
+    deleteSessionAsync(session: SessionLike, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<CompletionHandleLike>;
     /**
-     * Start serving RPC requests (blocking version)
-     *
-     * This is a blocking method that runs until the server is shut down.
-     * It listens for incoming RPC calls and dispatches them to registered handlers.
+     * Get the app ID in UUID format
      */
-    serve(): void;
+    id(): string;
     /**
-     * Start serving RPC requests (async version)
-     *
-     * This is an async method that runs until the server is shut down.
-     * It listens for incoming RPC calls and dispatches them to registered handlers.
+     * Listen for incoming sessions (blocking version for FFI)
      */
-    serveAsync(asyncOpts_?: {
-        signal: AbortSignal;
-    }): Promise<void>;
+    listenForSession(timeout: number | undefined): SessionLike;
     /**
-     * Shutdown the server gracefully (blocking version)
-     *
-     * This signals the server to stop accepting new requests and wait for
-     * in-flight requests to complete.
+     * Listen for incoming sessions (async version)
      */
-    shutdown(): void;
+    listenForSessionAsync(timeout: number | undefined, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<SessionLike>;
     /**
-     * Shutdown the server gracefully (async version)
-     *
-     * This signals the server to stop accepting new requests and wait for
-     * in-flight requests to complete.
+     * Get the app name
      */
-    shutdownAsync(asyncOpts_?: {
-        signal: AbortSignal;
-    }): Promise<void>;
-}
-/**
- * @deprecated Use `ServerLike` instead.
- */
-export type ServerInterface = ServerLike;
-/**
- * RPC Server
- *
- * Handles incoming RPC requests by creating sessions and dispatching
- * to registered service handlers.
- *
- * # Example
- *
- * ```no_run
- * # use slim_bindings::{Server, Context, RpcError, Decoder, Encoder, App, Name};
- * # use std::sync::Arc;
- * # fn main() -> Result<(), Box<dyn std::error::Error>> {
- * # use slim_bindings::{IdentityProviderConfig, IdentityVerifierConfig};
- * # let app_name = Arc::new(Name::new("test".to_string(), "app".to_string(), "v1".to_string()));
- * # let provider = IdentityProviderConfig::SharedSecret { id: "test".to_string(), data: "secret".to_string() };
- * # let verifier = IdentityVerifierConfig::SharedSecret { id: "test".to_string(), data: "secret".to_string() };
- * # let app = App::new(app_name, provider, verifier)?;
- * # let core_app = app.inner();
- * # let notification_rx = app.notification_receiver();
- * # #[derive(Default)]
- * # struct Request {}
- * # impl Decoder for Request {
- * #     fn decode(_buf: impl Into<Vec<u8>>) -> Result<Self, RpcError> { Ok(Request::default()) }
- * # }
- * # #[derive(Default)]
- * # struct Response {}
- * # impl Encoder for Response {
- * #     fn encode(self) -> Result<Vec<u8>, RpcError> { Ok(vec![]) }
- * # }
- * let base_name = Name::new("org".to_string(), "namespace".to_string(), "service".to_string());
- * let server = Server::new_with_shared_rx_and_connection(core_app, base_name.as_slim_name(), None, notification_rx, None);
- *
- * // Register handlers
- * server.register_unary_unary_internal(
- * "MyService",
- * "MyMethod",
- * |request: Request, _ctx: Context| async move {
- * Ok(Response::default())
- * }
- * );
- * # Ok(())
- * # }
- * ```
- */
-export declare class Server extends UniffiAbstractObject implements ServerLike {
-    readonly [uniffiTypeNameSymbol] = "Server";
-    readonly [destructorGuardSymbol]: UniffiGcObject;
-    readonly [pointerLiteralSymbol]: UniffiHandle;
+    name(): NameLike;
     /**
-     * Create a new RPC server
-     *
-     * This is the primary constructor for creating an RPC server instance
-     * that can handle incoming RPC requests over SLIM.
-     *
-     * # Arguments
-     * * `app` - The SLIM application instance that provides the underlying
-     * network transport and session management
-     * * `base_name` - The base name for this service (e.g., org.namespace.service).
-     * This name is used to construct subscription names for RPC methods.
-     *
-     * # Returns
-     * A new RPC server instance wrapped in an Arc for shared ownership
+     * Remove a route (blocking version for FFI)
      */
-    constructor(app: AppLike, baseName: NameLike);
+    removeRoute(name: NameLike, connectionId: bigint): void;
     /**
-     * Create a new RPC server with optional connection ID
-     *
-     * The connection ID is used to set up routing before serving RPC requests,
-     * enabling multi-hop RPC calls through specific connections.
-     *
-     * # Arguments
-     * * `app` - The SLIM application instance that provides the underlying
-     * network transport and session management
-     * * `base_name` - The base name for this service (e.g., org.namespace.service).
-     * This name is used to construct subscription names for RPC methods.
-     * * `connection_id` - Optional connection ID for routing setup
-     *
-     * # Returns
-     * A new RPC server instance wrapped in an Arc for shared ownership
+     * Remove a route (async version)
      */
-    static newWithConnection(app: AppLike, baseName: NameLike, connectionId: bigint | undefined): ServerLike;
+    removeRouteAsync(name: NameLike, connectionId: bigint, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<void>;
     /**
-     * Register a stream-to-stream RPC handler
-     *
-     * # Arguments
-     * * `service_name` - The service name
-     * * `method_name` - The method name
-     * * `handler` - Implementation of the StreamStreamHandler trait
+     * Blocking wrapper around [`App::restore_sessions_async`].
      */
-    registerStreamStream(serviceName: string, methodName: string, handler: StreamStreamHandler): void;
+    restoreSessions(connId: bigint): Array<SessionLike>;
     /**
-     * Register a stream-to-unary RPC handler
+     * Restore the app's persisted sessions after a restart (async).
      *
-     * # Arguments
-     * * `service_name` - The service name
-     * * `method_name` - The method name
-     * * `handler` - Implementation of the StreamUnaryHandler trait
+     * 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.
      */
-    registerStreamUnary(serviceName: string, methodName: string, handler: StreamUnaryHandler): void;
+    restoreSessionsAsync(connId: bigint, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<Array<SessionLike>>;
     /**
-     * Register a unary-to-stream RPC handler
-     *
-     * # Arguments
-     * * `service_name` - The service name
-     * * `method_name` - The method name
-     * * `handler` - Implementation of the UnaryStreamHandler trait
+     * Set a route to a name for a specific connection (blocking version for FFI)
      */
-    registerUnaryStream(serviceName: string, methodName: string, handler: UnaryStreamHandler): void;
+    setRoute(name: NameLike, connectionId: bigint): void;
     /**
-     * Register a unary-to-unary RPC handler
-     *
-     * # Arguments
-     * * `service_name` - The service name (e.g., "MyService")
-     * * `method_name` - The method name (e.g., "GetUser")
-     * * `handler` - Implementation of the UnaryUnaryHandler trait
+     * Set a route to a name for a specific connection (async version)
      */
-    registerUnaryUnary(serviceName: string, methodName: string, handler: UnaryUnaryHandler): void;
+    setRouteAsync(name: NameLike, connectionId: bigint, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<void>;
     /**
-     * Start serving RPC requests (blocking version)
-     *
-     * This is a blocking method that runs until the server is shut down.
-     * It listens for incoming RPC calls and dispatches them to registered handlers.
+     * Subscribe to a session name (blocking version for FFI)
      */
-    serve(): void;
+    subscribe(name: NameLike, connectionId: bigint | undefined): void;
     /**
-     * Start serving RPC requests (async version)
-     *
-     * This is an async method that runs until the server is shut down.
-     * It listens for incoming RPC calls and dispatches them to registered handlers.
+     * Subscribe to a name (async version)
      */
-    serveAsync(asyncOpts_?: {
+    subscribeAsync(name: NameLike, connectionId: bigint | undefined, asyncOpts_?: {
         signal: AbortSignal;
     }): Promise<void>;
     /**
-     * Shutdown the server gracefully (blocking version)
-     *
-     * This signals the server to stop accepting new requests and wait for
-     * in-flight requests to complete.
+     * Unsubscribe from a name (blocking version for FFI)
      */
-    shutdown(): void;
+    unsubscribe(name: NameLike, connectionId: bigint | undefined): void;
     /**
-     * Shutdown the server gracefully (async version)
-     *
-     * This signals the server to stop accepting new requests and wait for
-     * in-flight requests to complete.
+     * Unsubscribe from a name (async version)
      */
-    shutdownAsync(asyncOpts_?: {
+    unsubscribeAsync(name: NameLike, connectionId: bigint | undefined, asyncOpts_?: {
         signal: AbortSignal;
     }): Promise<void>;
     uniffiDestroy(): void;
-    static instanceOf(obj_: any): obj_ is Server;
+    static instanceOf(obj_: any): obj_ is App;
 }
 /**
  * Service wrapper for uniffi bindings
@@ -6245,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)
      *
@@ -6429,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)
      *
@@ -6539,7 +4871,6 @@ declare const _default: Readonly<{
             lift(value: UniffiByteArray): BasicAuth;
             lower(value: BasicAuth, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
         };
-        FfiConverterTypeBidiStreamHandler: FfiConverterObject<BidiStreamHandlerLike>;
         FfiConverterTypeBuildInfo: {
             read(from: RustBuffer): BuildInfo;
             write(value: BuildInfo, into: RustBuffer): void;
@@ -6554,7 +4885,6 @@ declare const _default: Readonly<{
             lift(value: UniffiByteArray): CaSource;
             lower(value: CaSource, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
         };
-        FfiConverterTypeChannel: FfiConverterObject<ChannelLike>;
         FfiConverterTypeClientAuthenticationConfig: {
             read(from: RustBuffer): ClientAuthenticationConfig;
             write(value: ClientAuthenticationConfig, into: RustBuffer): void;
@@ -6576,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;
@@ -6584,7 +4921,6 @@ declare const _default: Readonly<{
             lift(value: UniffiByteArray): CompressionType;
             lower(value: CompressionType, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
         };
-        FfiConverterTypeContext: FfiConverterObject<ContextLike>;
         FfiConverterTypeDataplaneConfig: {
             read(from: RustBuffer): DataplaneConfig;
             write(value: DataplaneConfig, into: RustBuffer): void;
@@ -6697,16 +5033,28 @@ declare const _default: Readonly<{
             lift(value: UniffiByteArray): MlsSettings;
             lower(value: MlsSettings, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
         };
-        FfiConverterTypeMulticastBidiStreamHandler: FfiConverterObject<MulticastBidiStreamHandlerLike>;
-        FfiConverterTypeMulticastResponseReader: FfiConverterObject<MulticastResponseReaderLike>;
-        FfiConverterTypeMulticastStreamMessage: {
-            read(from: RustBuffer): MulticastStreamMessage;
-            write(value: MulticastStreamMessage, into: RustBuffer): void;
-            allocationSize(value: MulticastStreamMessage): number;
-            lift(value: UniffiByteArray): MulticastStreamMessage;
-            lower(value: MulticastStreamMessage, 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;
@@ -6721,38 +5069,6 @@ declare const _default: Readonly<{
             lift(value: UniffiByteArray): ReceivedMessage;
             lower(value: ReceivedMessage, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
         };
-        FfiConverterTypeRequestStream: FfiConverterObject<RequestStreamLike>;
-        FfiConverterTypeRequestStreamWriter: FfiConverterObject<RequestStreamWriterLike>;
-        FfiConverterTypeResponseSink: FfiConverterObject<ResponseSinkLike>;
-        FfiConverterTypeResponseStreamReader: FfiConverterObject<ResponseStreamReaderLike>;
-        FfiConverterTypeRpcCode: {
-            read(from: RustBuffer): RpcCode;
-            write(value: RpcCode, into: RustBuffer): void;
-            allocationSize(value: RpcCode): number;
-            lift(value: UniffiByteArray): RpcCode;
-            lower(value: RpcCode, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
-        };
-        FfiConverterTypeRpcError: {
-            read(from: RustBuffer): RpcError;
-            write(value: RpcError, into: RustBuffer): void;
-            allocationSize(value: RpcError): number;
-            lift(value: UniffiByteArray): RpcError;
-            lower(value: RpcError, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
-        };
-        FfiConverterTypeRpcMessageContext: {
-            read(from: RustBuffer): RpcMessageContext;
-            write(value: RpcMessageContext, into: RustBuffer): void;
-            allocationSize(value: RpcMessageContext): number;
-            lift(value: UniffiByteArray): RpcMessageContext;
-            lower(value: RpcMessageContext, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
-        };
-        FfiConverterTypeRpcMulticastItem: {
-            read(from: RustBuffer): RpcMulticastItem;
-            write(value: RpcMulticastItem, into: RustBuffer): void;
-            allocationSize(value: RpcMulticastItem): number;
-            lift(value: UniffiByteArray): RpcMulticastItem;
-            lower(value: RpcMulticastItem, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
-        };
         FfiConverterTypeRuntimeConfig: {
             read(from: RustBuffer): RuntimeConfig;
             write(value: RuntimeConfig, into: RustBuffer): void;
@@ -6760,7 +5076,6 @@ declare const _default: Readonly<{
             lift(value: UniffiByteArray): RuntimeConfig;
             lower(value: RuntimeConfig, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
         };
-        FfiConverterTypeServer: FfiConverterObject<ServerLike>;
         FfiConverterTypeServerAuthenticationConfig: {
             read(from: RustBuffer): ServerAuthenticationConfig;
             write(value: ServerAuthenticationConfig, into: RustBuffer): void;
@@ -6826,15 +5141,6 @@ declare const _default: Readonly<{
             lift(value: UniffiByteArray): StaticJwtAuth;
             lower(value: StaticJwtAuth, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
         };
-        FfiConverterTypeStreamMessage: {
-            read(from: RustBuffer): StreamMessage;
-            write(value: StreamMessage, into: RustBuffer): void;
-            allocationSize(value: StreamMessage): number;
-            lift(value: UniffiByteArray): StreamMessage;
-            lower(value: StreamMessage, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
-        };
-        FfiConverterTypeStreamStreamHandler: FfiConverterObjectWithCallbacks<StreamStreamHandler>;
-        FfiConverterTypeStreamUnaryHandler: FfiConverterObjectWithCallbacks<StreamUnaryHandler>;
         FfiConverterTypeTlsClientConfig: {
             read(from: RustBuffer): TlsClientConfig;
             write(value: TlsClientConfig, into: RustBuffer): void;
@@ -6870,8 +5176,6 @@ declare const _default: Readonly<{
             lift(value: UniffiByteArray): TransportProtocol;
             lower(value: TransportProtocol, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
         };
-        FfiConverterTypeUnaryStreamHandler: FfiConverterObjectWithCallbacks<UnaryStreamHandler>;
-        FfiConverterTypeUnaryUnaryHandler: FfiConverterObjectWithCallbacks<UnaryUnaryHandler>;
     };
 }>;
 export default _default;