Struct VoltClient 

pub struct VoltClient { /* private fields */ }

The main Volt client

Implementations

impl VoltClient

pub fn new() -> Result<Self>

Create a new Volt client

pub fn config(&self) -> Option<&VoltClientConfig>

Get the client configuration

pub fn credential(&self) -> Option<&VoltCredential>

Get the credential manager

pub fn credential_mut(&mut self) -> Option<&mut VoltCredential>

Get mutable credential manager

pub fn volt_config(&self) -> Option<&VoltConfig>

Get the Volt configuration

pub fn is_relayed(&self) -> bool

Check if connected via relay

pub async fn is_connected(&self) -> bool

Check if connected

pub async fn close(&mut self)

Close the client and release resources

pub async fn initialise( &mut self, config: ConfigSource, options: InitialiseOptions, ) -> Result<VoltClientConfig>

Initialize the client with configuration

Arguments

• config - Either a path to a config file or a configuration object
• options - Initialization options

pub async fn initialise_and_connect( &mut self, config: ConfigSource, options: InitialiseOptions, hello_payload: Option<Value>, ) -> Result<EventReceiver>

Initialize and connect in one call

pub async fn connect( &mut self, hello_payload: Option<Value>, ) -> Result<EventReceiver>

Connect to the Volt server

pub async fn disconnect(&mut self)

Disconnect from the Volt server

pub async fn request_access_blocking( &self, target_resource_id: &str, access_type: VoltAccessType, ) -> Result<bool>

Request resource access (blocking until decision)

pub async fn can_access_resource(&self, request: Value) -> Result<ApiResponse>

Check if a resource can be accessed

pub async fn delete_resource(&self, request: Value) -> Result<ApiResponse>

Delete a resource

pub async fn discover_services(&self, request: Value) -> Result<ApiResponse>

Discover services

pub async fn get_resource(&self, request: Value) -> Result<ApiResponse>

Get a resource

pub async fn get_resources(&self, request: Value) -> Result<ApiResponse>

Get multiple resources

pub async fn get_resource_ancestors( &self, request: Value, ) -> Result<ApiResponse>

Get resource ancestors

pub async fn get_resource_descendants( &self, request: Value, ) -> Result<ApiResponse>

Get resource descendants

pub async fn request_access( &self, request: AccessRequest, ) -> Result<AccessResponse>

Request access to a resource

pub async fn save_resource(&self, request: Value) -> Result<ApiResponse>

Save a resource

pub async fn authenticate(&self, request: Value) -> Result<ApiResponse>

Authenticate

pub async fn bind(&self, request: Value) -> Result<ApiResponse>

Bind to the Volt

pub async fn get_bindings(&self, request: Value) -> Result<ApiResponse>

Get bindings

pub async fn get_identities(&self, request: Value) -> Result<ApiResponse>

Get identities

pub async fn get_identity(&self, request: Value) -> Result<ApiResponse>

Get a specific identity

pub async fn get_policy(&self, request: Value) -> Result<ApiResponse>

Get policy

pub async fn get_access(&self, request: Value) -> Result<ApiResponse>

Get access permissions for a resource

pub async fn get_settings(&self, request: Value) -> Result<ApiResponse>

Get settings

pub async fn save_access(&self, request: Value) -> Result<ApiResponse>

Save access

pub async fn save_identity(&self, request: Value) -> Result<ApiResponse>

Save identity

pub async fn save_settings(&self, request: Value) -> Result<ApiResponse>

Save settings

pub async fn shutdown(&self, request: Value) -> Result<ApiResponse>

Shutdown the Volt

pub async fn get_file_descendants(&self, request: Value) -> Result<ApiResponse>

Get file descendants

pub async fn get_file_content(&self, request: Value) -> Result<ApiResponse>

Get file content

pub async fn set_file_content(&self, request: Value) -> Result<ApiResponse>

Set file content

pub async fn create_database(&self, request: Value) -> Result<ApiResponse>

Create a database

pub async fn bulk_update(&self, request: Value) -> Result<ApiResponse>

Bulk update

pub async fn is_relay_connected(&self) -> bool

Check if relay connection is established

pub async fn sync_document( &self, initial_request: SyncDocumentRequest, ) -> Result<(Sender<SyncDocumentRequest>, SyncDocumentStream)>

Create a bidirectional streaming connection for document synchronization

This method creates a bidirectional stream for syncing CRDT documents using Y.js/yrs. The stream allows sending updates to the server and receiving updates from other clients.

Returns

A tuple of:

• mpsc::Sender<volt::SyncDocumentRequest> - Use this to send requests to the server
• Streaming<volt::SyncDocumentResponse> - Use this to receive responses from the server

Example

let (tx, mut rx) = client.sync_document().await?;

// Send initial sync request
tx.send(volt::SyncDocumentRequest {
    sync_start: Some(volt::SyncDocumentStart {
        database_id: "my-db".to_string(),
        document_id: "my-doc".to_string(),
        state_vector: vec![],
        read_only: false,
        read_only_fallback: false,
    }),
    ..Default::default()
}).await?;

// Receive responses
while let Some(response) = rx.next().await {
    match response {
        Ok(resp) => println!("Received: {:?}", resp),
        Err(e) => eprintln!("Error: {:?}", e),
    }
}

Trait Implementations

impl Default for VoltClient

fn default() -> Self

Returns the “default value” for a type.