Struct VortexClient 

pub struct VortexClient { /* private fields */ }

Vortex Rust SDK Client

Provides JWT generation and Vortex API integration for Rust applications. Compatible with React providers and follows the same paradigms as other Vortex SDKs.

Implementations

impl VortexClient

pub fn new(api_key: String) -> Self

Create a new Vortex client

Arguments

• api_key - Your Vortex API key

Example

use vortex_sdk::VortexClient;

let api_key = "VRTX.your_encoded_id.your_key".to_string();
let client = VortexClient::new(api_key);

pub fn with_base_url(api_key: String, base_url: String) -> Self

Create a new Vortex client with a custom base URL

Arguments

• api_key - Your Vortex API key
• base_url - Custom base URL for the Vortex API

pub fn generate_jwt( &self, user: &User, extra: Option<HashMap<String, Value>>, ) -> Result<String, VortexError>

Generate a JWT token for a user

Arguments

• user - User object with id, email, and optional admin_scopes
• extra - Optional additional properties to include in the JWT payload

Example

use vortex_sdk::{VortexClient, User};
use std::collections::HashMap;

let client = VortexClient::new("VRTX.AAAAAAAAAAAAAAAAAAAAAA.test_secret_key".to_string());

// Simple usage
let user = User::new("user-123", "user@example.com")
    .with_admin_scopes(vec!["autojoin".to_string()]);
let jwt = client.generate_jwt(&user, None).unwrap();

// With additional properties
let mut extra = HashMap::new();
extra.insert("role".to_string(), serde_json::json!("admin"));
let jwt = client.generate_jwt(&user, Some(extra)).unwrap();

pub async fn get_invitations_by_target( &self, target_type: &str, target_value: &str, ) -> Result<Vec<Invitation>, VortexError>

Get invitations by target (email or sms)

pub async fn get_invitation( &self, invitation_id: &str, ) -> Result<Invitation, VortexError>

Get a specific invitation by ID

pub async fn revoke_invitation( &self, invitation_id: &str, ) -> Result<(), VortexError>

Revoke (delete) an invitation

pub async fn accept_invitations( &self, invitation_ids: Vec<String>, param: impl Into<AcceptInvitationParam>, ) -> Result<Invitation, VortexError>

Accept multiple invitations

Arguments

• invitation_ids - Vector of invitation IDs to accept
• param - User data (preferred) or legacy target format

New User Format (Preferred)

use vortex_sdk::{VortexClient, AcceptUser};

let client = VortexClient::new("VRTX.key.secret".to_string());
let user = AcceptUser::new().with_email("user@example.com");
let result = client.accept_invitations(vec!["inv-123".to_string()], user).await;

Legacy Target Format (Deprecated)

use vortex_sdk::{VortexClient, InvitationTarget};

let client = VortexClient::new("VRTX.key.secret".to_string());
let target = InvitationTarget::new("email", "user@example.com");
let result = client.accept_invitations(vec!["inv-123".to_string()], target).await;

pub async fn delete_invitations_by_group( &self, group_type: &str, group_id: &str, ) -> Result<(), VortexError>

Delete all invitations for a specific group

pub async fn get_invitations_by_group( &self, group_type: &str, group_id: &str, ) -> Result<Vec<Invitation>, VortexError>

Get all invitations for a specific group

pub async fn reinvite( &self, invitation_id: &str, ) -> Result<Invitation, VortexError>

Reinvite a user (send invitation again)