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 sign(&self, user: &User) -> 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();

Sign a user object for use with the widget signature prop.

@vortex category=authentication since=0.5.0

Returns a signature string in kid:hexDigest format.

Arguments

• user - User object with id and email

pub fn generate_token( &self, payload: &GenerateTokenPayload, options: Option<&GenerateTokenOptions>, ) -> Result<String, VortexError>

Generate a signed token for use with Vortex widgets

@vortex category=authentication since=0.8.0 primary=true

Arguments

• payload - Data to sign (user, component, scope, vars, etc.)
• options - Optional configuration (expires_in)

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

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

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)

@vortex category=invitations since=0.1.0

Arguments

• target_type - Type of target (email, phone)
• target_value - The target value

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

Get a specific invitation by ID

@vortex category=invitations since=0.1.0 primary=true

Arguments

• invitation_id - The invitation ID

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

Revoke (delete) an invitation

@vortex category=invitations since=0.1.0

Arguments

• invitation_id - The invitation ID to revoke

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 accept_invitation( &self, invitation_id: &str, user: AcceptUser, ) -> Result<Invitation, VortexError>

Accept a single invitation (recommended method)

@vortex category=invitations since=0.6.0 primary=true

Arguments

• invitation_id - Single invitation ID to accept

• user - User object with email and/or phone

• Result<Invitation, VortexError> - The accepted invitation result

Example

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_invitation("inv-123", user).await;

pub async fn delete_invitations_by_scope( &self, scope_type: &str, scope: &str, ) -> Result<(), VortexError>

Delete all invitations for a specific scope

@vortex category=invitations since=0.4.0

Arguments

• scope_type - The scope type (organization, team, etc.)
• scope - The scope identifier

pub async fn get_invitations_by_scope( &self, scope_type: &str, scope: &str, ) -> Result<Vec<Invitation>, VortexError>

Get all invitations for a specific scope

@vortex category=invitations since=0.4.0

Arguments

• scope_type - The scope type (organization, team, etc.)
• scope - The scope identifier

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

Reinvite a user (send invitation again)

@vortex category=invitations since=0.2.0

Arguments

• invitation_id - The invitation ID to reinvite

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, CreateInvitationScope};

#[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![
        CreateInvitationScope::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(())
}

pub async fn get_autojoin_domains( &self, scope_type: &str, scope: &str, ) -> Result<AutojoinDomainsResponse, VortexError>

Get autojoin domains configured for a specific scope

@vortex category=autojoin since=0.6.0

Arguments

• scope_type - The type of scope (e.g., “organization”, “team”, “project”)
• scope - The scope identifier (customer’s group ID)

use vortex_sdk::VortexClient;

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

    let result = client.get_autojoin_domains("organization", "acme-org").await?;
    for domain in &result.autojoin_domains {
        println!("Domain: {}", domain.domain);
    }
    Ok(())
}

pub async fn sync_internal_invitation( &self, request: &SyncInternalInvitationRequest, ) -> Result<SyncInternalInvitationResponse, VortexError>

Configure autojoin domains for a specific scope

@vortex category=autojoin since=0.6.0

Arguments

• request - The configure autojoin request

use vortex_sdk::{VortexClient, ConfigureAutojoinRequest};

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

    let request = ConfigureAutojoinRequest::new(
        "acme-org",
        "organization",
        vec!["acme.com".to_string(), "acme.org".to_string()],
        "widget-123",
    )
    .with_scope_name("Acme Corporation");

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

Sync an internal invitation action (accept or decline)

This method notifies Vortex that an internal invitation was accepted or declined within your application, so Vortex can update the invitation status accordingly.

Example

use vortex_sdk::{VortexClient, SyncInternalInvitationRequest};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = VortexClient::new("VRTX.xxx.yyy".to_string());
    let request = SyncInternalInvitationRequest::new(
        "user-123", "user-456", "accepted", "component-uuid",
    );
    let result = client.sync_internal_invitation(&request).await?;
    println!("Processed {} invitations", result.processed);
    Ok(())
}

pub async fn configure_autojoin( &self, request: &ConfigureAutojoinRequest, ) -> Result<AutojoinDomainsResponse, VortexError>

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

👎Deprecated since 0.1.0:

Use get_invitations_by_scope instead

Get invitations by group (deprecated: use get_invitations_by_scope instead)

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

👎Deprecated since 0.1.0:

Use delete_invitations_by_scope instead

Delete invitations by group (deprecated: use delete_invitations_by_scope instead)