Struct BundleHandler 

pub struct BundleHandler { /* private fields */ }

Handler for bundle operations

Implementations

impl BundleHandler

pub fn new(client: FilesClient) -> Self

Create a new bundle handler

pub async fn list( &self, user_id: Option<i64>, cursor: Option<&str>, per_page: Option<i64>, ) -> Result<(Vec<BundleEntity>, PaginationInfo)>

List all bundles accessible to the current user

Returns a paginated list of bundles (share links) with optional filtering.

Arguments

• user_id - Filter bundles by user ID (None for all accessible bundles)
• cursor - Pagination cursor from previous response
• per_page - Number of results per page (max 10,000)

Returns

A tuple containing:

• Vector of BundleEntity objects
• PaginationInfo with cursors for next/previous pages

Example

use files_sdk::{FilesClient, BundleHandler};

let client = FilesClient::builder().api_key("key").build()?;
let handler = BundleHandler::new(client);

// List first page of bundles
let (bundles, pagination) = handler.list(None, None, Some(50)).await?;

for bundle in bundles {
    println!("Bundle: {} - {}",
        bundle.code.unwrap_or_default(),
        bundle.url.unwrap_or_default());
}

// Get next page if available
if let Some(next_cursor) = pagination.cursor_next {
    let (more_bundles, _) = handler.list(None, Some(&next_cursor), Some(50)).await?;
}

pub async fn get(&self, id: i64) -> Result<BundleEntity>

Get details of a specific bundle by ID

Arguments

• id - The unique bundle ID

Returns

A BundleEntity with complete bundle information

Example

use files_sdk::{FilesClient, BundleHandler};

let client = FilesClient::builder().api_key("key").build()?;
let handler = BundleHandler::new(client);

let bundle = handler.get(12345).await?;
println!("Bundle URL: {}", bundle.url.unwrap_or_default());
println!("Expires: {}", bundle.expires_at.unwrap_or_default());

pub async fn create( &self, paths: Vec<String>, password: Option<&str>, expires_at: Option<&str>, max_uses: Option<i64>, description: Option<&str>, note: Option<&str>, code: Option<&str>, require_registration: Option<bool>, permissions: Option<&str>, ) -> Result<BundleEntity>

Create a new bundle (share link)

Creates a shareable link to one or more files or folders with configurable access controls and restrictions.

Arguments

• paths - Vector of file/folder paths to share (required, must not be empty)
• password - Password required to access the bundle
• expires_at - ISO 8601 timestamp when bundle expires (e.g., “2024-12-31T23:59:59Z”)
• max_uses - Maximum number of times bundle can be accessed
• description - Public description shown to recipients
• note - Private internal note (not shown to recipients)
• code - Custom URL code (auto-generated if not provided)
• require_registration - Require recipients to register before access
• permissions - Access level: “read”, “write”, “read_write”, “full”, “preview_only”

Returns

The newly created BundleEntity with URL and access details

Example

use files_sdk::{FilesClient, BundleHandler};

let client = FilesClient::builder().api_key("key").build()?;
let handler = BundleHandler::new(client);

// Create a simple share link
let bundle = handler.create(
    vec!["/documents/report.pdf".to_string()],
    None,
    None,
    None,
    Some("Monthly Report"),
    None,
    None,
    Some(false),
    Some("read")
).await?;

println!("Share this link: {}", bundle.url.unwrap());

pub async fn update( &self, id: i64, password: Option<&str>, expires_at: Option<&str>, max_uses: Option<i64>, description: Option<&str>, note: Option<&str>, ) -> Result<BundleEntity>

Update an existing bundle’s settings

Modifies bundle properties such as password, expiration, and description. Only provided fields will be updated; omitted fields remain unchanged.

Arguments

• id - Bundle ID to update
• password - New password (pass empty string to remove password)
• expires_at - New expiration timestamp
• max_uses - New maximum access count
• description - New public description
• note - New internal note

Returns

The updated BundleEntity

Example

use files_sdk::{FilesClient, BundleHandler};

let client = FilesClient::builder().api_key("key").build()?;
let handler = BundleHandler::new(client);

// Extend expiration and update description
let bundle = handler.update(
    12345,
    None,
    Some("2025-06-30T23:59:59Z"),
    None,
    Some("Updated report - extended access"),
    None
).await?;

pub async fn delete(&self, id: i64) -> Result<()>

Delete a bundle permanently

Removes the bundle and revokes access via its share link. This operation cannot be undone.

Arguments

• id - Bundle ID to delete

Example

use files_sdk::{FilesClient, BundleHandler};

let client = FilesClient::builder().api_key("key").build()?;
let handler = BundleHandler::new(client);

handler.delete(12345).await?;
println!("Bundle deleted successfully");

pub async fn share( &self, id: i64, to: Vec<String>, note: Option<&str>, ) -> Result<()>

Share a bundle via email

Sends email notifications with the bundle link to specified recipients. Recipients receive an email with the share link and optional message.

Arguments

• id - Bundle ID to share
• to - Vector of recipient email addresses
• note - Optional message to include in the email

Example

use files_sdk::{FilesClient, BundleHandler};

let client = FilesClient::builder().api_key("key").build()?;
let handler = BundleHandler::new(client);

// Share with multiple recipients
handler.share(
    12345,
    vec![
        "user1@example.com".to_string(),
        "user2@example.com".to_string()
    ],
    Some("Please review these files by Friday")
).await?;

println!("Bundle shared successfully");