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 fields:
  • name: user’s display name (max 200 characters)
  • avatar_url: user’s avatar URL (must be HTTPS, max 2000 characters)
  • admin_scopes: list of admin scopes (e.g., vec![“autojoin”])
• 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_user_name("Jane Doe")                                     // Optional: user's display name
    .with_user_avatar_url("https://example.com/avatars/jane.jpg")  // Optional: user's avatar URL
    .with_admin_scopes(vec!["autojoin".to_string()]);         // Optional: grants admin privileges
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::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)

pub async fn create_invitation( &self, request: &CreateInvitationRequest, ) -> Result<CreateInvitationResponse, VortexError>

Create an invitation from your backend

This method allows you to create invitations programmatically using your API key, without requiring a user JWT token. Useful for server-side invitation creation, such as “People You May Know” flows or admin-initiated invitations.

Target types

• email: Send an email invitation
• sms: Create an SMS invitation (short link returned for you to send)
• internal: Create an internal invitation for PYMK flows (no email sent)

Example

use vortex_sdk::{VortexClient, CreateInvitationRequest, CreateInvitationTarget, Inviter, CreateInvitationGroup};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = VortexClient::new("VRTX.xxx.yyy".to_string());

    // Create an email invitation
    let request = CreateInvitationRequest::new(
        "widget-config-123",
        CreateInvitationTarget::email("invitee@example.com"),
        Inviter::new("user-456")
            .with_email("inviter@example.com")
            .with_user_name("John Doe"),
    )
    .with_groups(vec![
        CreateInvitationGroup::new("team", "team-789", "Engineering"),
    ]);

    let result = client.create_invitation(&request).await?;

    // Create an internal invitation (PYMK flow - no email sent)
    let request = CreateInvitationRequest::new(
        "widget-config-123",
        CreateInvitationTarget::internal("internal-user-abc"),
        Inviter::new("user-456"),
    )
    .with_source("pymk");

    let result = client.create_invitation(&request).await?;
    Ok(())
}